Datei zeichenweise auslesen - newline Problem.

[Gast]

redrew99 schrieb:

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?

[redrew99]

@SeppJ
Danke, das ist wirklich superkurz

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.

[redrew99]

Ergänzung:

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.

[SeppJ]

Nimm eben unsigned int.

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.

[redrew99]

SeppJ schrieb:

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.

[SeppJ]

Ja was denn nun? Willst du Vorzeichen oder nicht?

[redrew99]

SeppJ schrieb:

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.

[SeppJ]

Ok, dieses Feature war mir bisher gar nicht so bewusst. 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));
}

[redrew99]

SeppJ schrieb:

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?

[SeppJ]

redrew99 schrieb:

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?

[Gast]

redrew99 schrieb:

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

[redrew99]

Gugelmoser schrieb:

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.

[redrew99]

SeppJ schrieb:

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.

[Gast]

redrew99 schrieb:

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.

[SeppJ]

redrew99 schrieb:

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.

[redrew99]

SeppJ schrieb:

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.

[Werner Salomon]

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.
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

[314159265358979]

Du hast echt nen... gewöhnungsbedürftigen Stil, Werner.

[redrew99]

Werner Salomon schrieb:

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.

[Gast]

redrew99 schrieb:

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.