#include <iostream>
#include <fstream>
#include <string>

using namespace std;

int main()
{
    ifstream filestream("test.txt");
    string s;

    for(char ch;filestream.good();)
    {
        filestream.get(ch);
        if((ch>='0') && (ch<='9'))
        {
            s+=ch;
        }
         else
        {
           cout<<s<<" ";
           s.clear();
        }

        }

    return 0;
}

Ebenso ist das Problem nach dem du fragst auf einen Logikfehler zu schieben. Wenn du die Ausgabe nur machst, wenn du etwas anderes liest als eine Ziffer, dann brauchst du dich auch nicht wundern, dass du die letzte Ausgabe nicht bekommst, wenn das letzte Zeichen eine Ziffer ist. Formulier deinen Ablauf doch mal ein bisschen anders.

Aber: Was willst du überhaupt erreichen? Im Moment sieht das nach einer unendlich umständlichen Art und Weise aus, (bis auf den Fehler) alle Zahlen aus einer Datei auszugeben.

Du liest, verarbeitest, dann prüfst du (im Schleifenkopf) ob das Lesen erfolgreich war. Überleg mal, was wohl passiert, wenn das Lesen nicht erfolgreich war. Üblicherweise sehen Leseschleifen daher so aus:
while(Leseaktion) verarbeitung;

Ok. Verbesserungsvorschlag:

if(!filestream())
{
cerr<<"Fehler beim Öffnen der Datei.";
}
else
{
 char ch;
 while(filestream.get(ch))
{
 cout<<ch;  
} 
}

SeppJ schrieb:

Ebenso ist das Problem nach dem du fragst auf einen Logikfehler zu schieben. Wenn du die Ausgabe nur machst, wenn du etwas anderes liest als eine Ziffer, dann brauchst du dich auch nicht wundern, dass du die letzte Ausgabe nicht bekommst, wenn das letzte Zeichen eine Ziffer ist. Formulier deinen Ablauf doch mal ein bisschen anders.

Ja, das stimmt. Mittlerweile habe ich eine Lösung gefunden. Es werden alle Zeichen in ein Array gespeichert. Beim Auslesen des Arrays wird nach dem Übertragen eines Zeichens in den String das nächste Zeichen abgefragt, ist es keine Zahl wird der String ausgegeben und geleert. Usw.
Theoretisch müßte man dies auch innerhalb des Streams machen können, indem man die Leseposition ein Zeichen weitersetzt, abfragt und dann wieder zurückgeht.

#include <iostream>
#include <fstream>
#include <string>

using namespace std;

int main ()

{
 int length;                   
 ifstream filestream("test.txt",ios::binary);
 //Länge des Streams ermitteln
 filestream.seekg(0,ios::end);
 length=filestream.tellg();
 filestream.seekg(0,ios::beg);
 //Array mit der Länge des Streams erzeugen und Daten übertragen.
 char buffer[length];
 filestream.read(buffer,length);
 //filestream.close();
 //Analyse des Streams und Ausgabe der Zahlen
 string s;
 for(int i=0;i<length;++i)
 {
     if ((buffer[i])>='0' && (buffer[i]<='9'))    //Wenn Zahl ja, dann Übertrag in den String.
         {
           s+=buffer[i];
             if ((buffer[i+1])<'0'|| (buffer[i+1])>'9')   //Wenn das nächste Zeichen im Array keine Zahl ist, dann
             {                                            //Ausgabe des Strings mit anschließender Leerung.
                 cout<<s<<" ";
                 s.clear();
                 continue;                               //nächster Schleifendurchlauf.
             }
         }
 }
 return 0;
}

SeppJ schrieb:

Aber: Was willst du überhaupt erreichen? Im Moment sieht das nach einer unendlich umständlichen Art und Weise aus, (bis auf den Fehler) alle Zahlen aus einer Datei auszugeben.

Ja, Ziel ist es, alle Zahlen aus einer Datei auszulesen. Wichtig ist mir dabei, daß zusammenhängende Ziffern als Zahl erkannt werden und jegliche Zwischenraumzeichen ignoriert werden.
Ist Marke Eigenbau und da natürlich noch kein Meister vom Himmel gefallen ist, geht es vermutlich auch einfacher.
Wenn Du weißt, wie es besser geht, schaue ich mir das gerne an.

Wenn du uns sagst, wie die File genau aussieht, gibt es bestimmt eine viel elegantere Lösung. Enthält sie nur Zahlen, ',' und Leerzeichen?

Der Inhalt soll beliebig sein, z.B. auch: "§!56 zp-,7789".

Gugelmoser schrieb:

Im Übrigen würde ich nicht exit(-1) verwenden, da werden lokale Objekte nicht zerstört.

Ok, hatte das aus einem Lehrbuch (Der C++-Programmierer) übernommen.

Ok, hatte das aus einem Lehrbuch (Der C++-Programmierer) übernommen.

Lese ich auch gerade. Die Stelle kam bei mir auch vor ein paar Tagen vor und da hatte ich mich schon gefragt, wieso er exit verwendet.

Verstehst du die Lösung von SeppJ oder noch Erklärungsbedarf?

Beim Testen des Programms ist mir etwas aufgefallen:
Ein "-" vor einer Zahl wird nicht als Bindestrich angesehen, sondern als Minuszeichen.
Es wäre nicht schlecht, wenn man das entsprechend einstellen könnte, je nachdem ob es halt negative Zahlen geben soll oder
nicht.

Gugelmoser schrieb:

Verstehst du die Lösung von SeppJ oder noch Erklärungsbedarf?

Was ich nicht verstehe ist, warum zusammenhängende Ziffern als Zahl gewertet werden.
Vermutlich ist die entsprechende Klassenfunktion so programmiert, die würde ich mir gerne mal anschauen, hab bei
http://www.cplusplus.com/reference/iostream/istream/ leider nichts dazu gefunden.

Wenn man bei dem Programm z.B. "--798" o. "+-298" eingibt, wird "798" bzw. "298" ausgegeben.
Das ist irgendwie unlogisch. Entweder wird ein Bindestrich als Minuszeichen angesehen oder halt nicht.

Die Klassenfunktion ist diese:
http://www.cplusplus.com/reference/iostream/istream/operator>>/ (leider scheint die Formatierung auf der Seite nicht in Ordnung zu sein)
Kennst du also sicherlich schon.

Nimm eben unsigned int.

Hatte ich schon ausprobiert, das geht leider auch nicht.
Bei Eingabe von z.B. "-764" gibt die Konsole "4294966498" aus.

Auch cin.ignore(1,'-') habe ich[Edit: separat] probiert, wobei ich nicht genau weiß, ob das in diesem Kontext überhaupt Sinn macht.

Ja was denn nun? Willst du Vorzeichen oder nicht?

Das verstehe ich jetzt nicht. Dein Vorschlag war, aus "int" "unsigned int" zu machen. Das funktioniert aber nicht.
Das Programm sollte dann aus z.B. "b-764" 764 machen, tut es aber nicht.

#include <iostream>
#include <cctype>

using namespace std;

int main()
{
  while (cin)
    if (isdigit(cin.peek()))
      {
        unsigned wert;
        cin >> wert;
        cout << wert << '\n';
      }
      else
        cin.ignore(1);
}

Auch schön kurz und knackig.

P.S.: Oder noch einen Tacken kürzer:

int main()
{
  do 
    if (isdigit(cin.peek()))
      {
        unsigned wert;
        cin >> wert;
        cout << wert << '\n';
      }
  while (cin.ignore(1));
}

Ok, dieses Feature war mir bisher gar nicht so bewusst.

Das sieht eher aus wie ein Bug, nicht wie ein Feature. Denn auch die Ausgabe von negativen Zahlen funktioniert nicht, z.B. wird aus "b--764" "764".

SeppJ schrieb:

Dann eben so:

#include <iostream>
#include <cctype>

using namespace std;

int main()
{
  while (cin)
    if (isdigit(cin.peek()))
      {
        unsigned wert;
        cin >> wert;
        cout << wert << '\n';
      }
      else
        cin.ignore(1);
}

Auch schön kurz und knackig.

P.S.: Oder noch einen Tacken kürzer:

int main()
{
  do 
    if (isdigit(cin.peek()))
      {
        unsigned wert;
        cin >> wert;
        cout << wert << '\n';
      }
  while (cin.ignore(1));
}

Jupp, das funktioniert beides. Aber wenn ich das richtig sehe, ist das doch geschummelt, da Du eine C-Bibliothek verwendest, oder?

Das sieht eher aus wie ein Bug, nicht wie ein Feature. Denn auch die Ausgabe von negativen Zahlen funktioniert nicht, z.B. wird aus "b--764" "764".

Nein, das ist vom Standard so vorgesehen.

Jupp, das funktioniert beides. Aber wenn ich das richtig sehe, ist das doch geschummelt, da Du eine C-Bibliothek verwendest, oder?

Die C-Bibliothek ist Teil von C++. Aber meinetwegen:

#include <iostream>
#include <locale>

using namespace std;

int main()
{
  locale loc;
  do
    if (isdigit(cin.peek(), loc))
      {
        unsigned wert;
        cin >> wert;
        cout << wert << '\n';
      }
  while (cin.ignore(1));
}

Ist das jetzt besser?

Was ich nicht verstehe ist, warum zusammenhängende Ziffern als Zahl gewertet werden.

Das liegt einfach daran, dass du nicht Zeichenweise einließt, sondern eine Sequence haben möchtest, in deinem Fall für einen Integer. Und wenn du einen Integer einlesen möchtest, dann ist der Einlesevorgang erst dann beendet, wenn man auf ein nicht-numerisches Zeichen stößt.

If you do not read character-wise, but extract an integer or a string, for example, you always read past the end of the input sequence. This is because the input operators read characters until they find a separator, or hit the end of the input sequence. Consequently, if the input contains the sequence ... 912749<eof> and an integer is extracted, the eofbit flag (but not failbit) is set.

Separator für Integer = ein nicht-numerisches Zeichen.

redrew99 schrieb:

Jupp, das funktioniert beides. Aber wenn ich das richtig sehe, ist das doch geschummelt, da Du eine C-Bibliothek verwendest, oder?

cctype ist in Ordnung, nicht in Ordnung wäre ctype.h

Das liegt einfach daran, dass du nicht Zeichenweise einließt, sondern eine Sequence haben möchtest, in deinem Fall für einen Integer. Und wenn du einen Integer einlesen möchtest, dann ist der Einlesevorgang erst dann beendet, wenn man auf ein nicht-numerisches Zeichen stößt.

Ok.

Gugelmoser schrieb:

cctype ist in Ordnung, nicht in Ordnung wäre ctype.h

Ok. Hatte das schon oft gesehen hier, daß von der Verwendung von C-Bibliotheken abgeraten wird, sofern es irgend möglich ist. Aber egal.

Nein, das ist vom Standard so vorgesehen.

Mag sein, die Funktion läßt sich zumindest nicht wirklich verwenden, selbst dann nicht, wenn man negative Zahlen extrahieren lassen möchte.

#include <iostream>
#include <locale>

using namespace std;

int main()
{
  locale loc;
  do
    if (isdigit(cin.peek(), loc))
      {
        unsigned wert;
        cin >> wert;
        cout << wert << '\n';
      }
  while (cin.ignore(1));
}

SeppJ schrieb:

Ist das jetzt besser?

Sry, aber der Code funktioniert leider nicht.
Aber macht nichts, wir haben 2 funktionierende Versionen.

Gugelmoser schrieb:

cctype ist in Ordnung, nicht in Ordnung wäre ctype.h

Ok. Hatte das schon oft gesehen hier, daß von der Verwendung von C-Bibliotheken abgeraten wird, sofern es irgend möglich ist. Aber egal.

Das ist richtig, nur hast du es falsch interpretiert: Header, die auf .h enden, sind für C. Für C++ gibt es eine Neuauflage für solche Header, die nicht auf .h enden, sondern mit c vorne anfangen. D.h. cctype ist richtig, ctype.h ist falsch.

Sry, aber der Code funktioniert leider nicht.
Aber macht nichts, wir haben 2 funktionierende Versionen.

Sehr mitteilsam oder gar selbstständig bist du nicht gerade, oder?

if (isdigit(static_cast<char>(cin.peek()), loc))

Und jetzt verstehst du auch vielleicht so langsam, wieso man nicht aus Prinzipientreue gegen schöne gute Standardfunktionen ist, bloß weil es sie in C auch gibt.

Sehr mitteilsam oder gar selbstständig bist du nicht gerade, oder?

Berechtigte Frage. Schauen wir doch mal.
Nach Deinem Post

SeppJ schrieb:

Im Moment sieht das nach einer unendlich umständlichen Art und Weise aus, (bis auf den Fehler) alle Zahlen aus einer Datei auszugeben.

(man beachte das "unendlich") habe ich mich hingesetzt und eine funktionierende Version gebastelt.

Sry, aber wer Kritik in der Form wie "unendlich umständlich" äußert, steht in der moralischen Pflicht, es besser zu machen. Interessanterweise gestaltete sich das
"besser machen" doch schwieriger als erwartet.

Davon ab, vielen Dank für das Coaching und die Geduld, an Dich und natürlich an
Gugelmoser.

wenn ich das richtig verstanden habe, so geht es doch darum, alles zu überlesen, was keine Zahl ist und anschließend die Zahl zu lesen. Unter der Voraussetzung, dass keine isolierten '-' (und '+'?) Zeichen in der Datei stehen, sollten auch Vorzeichen erlaubt sein, und das ganze sollte von außen schaltbar sein.
Hier mal ein Manipulator, der direkt an der streambuf-Schnittstelle die Zeichen abgreift. In Summe ist das natürlich mehr Code, aber in der Anwendung wird's dann wieder schnuckelig einfach.

#include <fstream>
#include <iostream>
#include <locale>

template< typename E, typename Traits >
std::basic_istream< E, Traits >& skip_until_number( std::basic_istream< E, Traits >& in )
{
    std::basic_istream< E, Traits >::sentry ok( in );
    if( ok )
    {
        std::ios_base::iostate state = std::ios_base::goodbit;
        try
        {
            const std::ctype< E >& ctype_ = std::use_facet< std::ctype< E > >( in.getloc() );
            for( Traits::int_type m = in.rdbuf()->sgetc(); ; m = in.rdbuf()->snextc() )
            {
                if( Traits::eq_int_type( m, Traits::eof() ) )
                {
                    state |= std::ios_base::eofbit;
                    break;
                }
                const E c = Traits::to_char_type( m );
                if( ctype_.is( std::ctype_base::digit, c ) || (in.flags() & std::ios_base::showbase && (c == E('+') || c == E('-'))) )
                    break;
            }
        }
        catch(...)
        {
            state |= std::ios_base::badbit;
            if( in.exceptions() & std::ios_base::badbit )
                throw;
        }
        in.setstate( state );
    }
    return in;
}

int main()
{
    using namespace std;
    ifstream filestream("test.txt");
    filestream >> showbase; // mit showbase ist Vorzeichen erlaubt, ohne nicht
    for( int wert; filestream >> skip_until_number >> wert; )
        cout << wert << endl;
    cin.get();
    return 0;
}

Das 'showbase'-Flag habe ich zweckentfremdet, um mit/ohne Vorzeichen schaltbar zu machen.

Gruß
Werner

Hallo redrew99,
wenn ich das richtig verstanden habe, so geht es doch darum, alles zu überlesen, was keine Zahl ist und anschließend die Zahl zu lesen. Unter der Voraussetzung, dass keine isolierten '-' (und '+'?) Zeichen in der Datei stehen, sollten auch Vorzeichen erlaubt sein, und das ganze sollte von außen schaltbar sein.

Ja, genau. Wenn man schon so ein Programm schreibt, gehört meiner Ansicht nach ein "Schalter" für die Vorzeichen unbedingt mit rein, schließlich weiß man ja nie, ob man negative Zahlen braucht/nicht braucht.Vorstellbare Anwendungen für beides gibt es genug, z.B. Kontenstände(ja) oder Geburtsjahre(nein) auslesen.

Was ich überhaupt nicht verstehe ist, warum die Standardfunktion so gehalten ist, daß bei

#include <iostream>

using namespace std;

int main()
{
  int wert;
  while (!(cin >> wert).eof())
    if (cin)
      cout << wert << '\n';
    else
      {
        cin.clear();
        cin.ignore(1);
      }
}

einer Eingabe von z.B. "+-798" "798", aber bei einer Eingabe von "++-798" "-798" ausgegeben wird. Imho ergibt das keinen Sinn.

Werner Salomon schrieb:

Hier mal ein Manipulator, der direkt an der streambuf-Schnittstelle die Zeichen abgreift. In Summe ist das natürlich mehr Code, aber in der Anwendung wird's dann wieder schnuckelig einfach.[cpp]

Autsch. Ganz schöner Brocken.
Davon verstehe ich so gut wie nichts(wegen der Templates), dass muss ich mir erstmal in Ruhe anschauen.
Danke für den Code.
Bin dann erstmal off, muss morgen früh raus.

Was ich überhaupt nicht verstehe ist, warum die Standardfunktion so gehalten ist, daß bei

#include <iostream>

using namespace std;

int main()
{
  int wert;
  while (!(cin >> wert).eof())
    if (cin)
      cout << wert << '\n';
    else
      {
        cin.clear();
        cin.ignore(1);
      }
}

einer Eingabe von z.B. "+-798" "798", aber bei einer Eingabe von "++-798" "-798" ausgegeben wird.

Ich denke, es wird alles klarer, wenn du das Ganze mal so umschreibst und dann +-798 eingibst:

int main()
{
	int wert;
	while( !(cin >> wert).eof() )
	{
		if( !cin ) // !cin entspricht cin.fail()
		{
        	cin.clear();
        	cin.ignore(1);
        }
        cout << "Inhalt der Variablen = " << wert << '\n';
	}

	/*
		Schritt 1:
			Du willst einen int einlesen.

		Schritt 2:
			Du gibst +-798 ein.

		Schritt 3:
			Das erste Zeichen der Sequence ist ein +. Alles OK, eine Zahl darf ein Vorzeichen haben.

		Schritt 4:
			Das zweite Zeichen der Sequence ist ein -. What? Eine Zahl kann immer nur 1 Vorzeichen haben. D.h. das - ist
			ein nicht-numerisches Zeichen. Nun wird der Einlesevorgang abgebrochen, cin geht in einen Fehlerzustand über,
			und die restlichen Zeichen (-798) bleiben im Puffer stecken. Es wurde also nur das + gelesen, und einfach nur + wird als +0 gehandhabt.
			Die Variable hat also nun den Wert 0.

		Schritt 5:
			!cin ergibt nun true. Mit clear wird cin in seinen gültigen Zustand zurückgeführt und dann wird ein
			im Puffer steckendes Zeichen (-) ignoriert. (ignorieren = das Zeichen lesen und verwerfen)

		Schritt 6:
			Die Variable mit dem Inhalt 0 wird ausgegeben.

		Schritt 7:
			Du willst einen int einelsen.

		Schritt 8:
			Im Puffer befinden sich noch die Zeichen 798. Alles OK, das ist eine positive Ganzzahl. Die Sequence wird gelesen und in der Variable abgespeichert.
			Ein nicht-numerisches Zeichen gab es nicht, cin befindet sich also in keinem Fehlerzustand.

		Schritt 9:
			!cin ergibt false, da sich cin in keinem Fehlerzustand befindet.

		Schritt 10:
			Die Variable mit dem Inhalt 798 wird ausgegeben.

		Nun geht es wieder bei Schritt 1 los.
	*/

    return 0;
}

Ich hoffe, meine Erklärung hat dir geholfen.