istream vs. scanf

[nn]

Ich denke je öfter und regelmäßiger man z.B. mit solchen IO-Sachen zu tun hat, desto mehr wird man solch elegante Lösungen zu schätzen wissen.

Wenn man aber nur selten damit zu tun hat, kommt sicher eher eine Lösung mit den Sprachmitteln heraus, mit denen man hauptsächlich arbeitet. Was aber nicht schlecht sein muss. Wenn man eigenen Code nach ein paar Jahren wieder ändern muss, fällt die Arbeit am Eigengewächs sicher leichter, als die an einer "Perle" die man mal im Netz gefunden hat, aber später nicht mehr versteht.

Übrigens neigen Programmierer in anderen Sprachen anscheinend auch zu komplexen Konstrukten zum Einlesen von INI-Dateien:

Dictionary<string, Dictionary<string, string>> InIFile
= ( from Match m in Regex.Matches( data, pattern, RegexOptions.IgnorePatternWhitespace | RegexOptions.Multiline )
 select new
 {
  Section = m.Groups["Section"].Value,

  kvps = ( from cpKey in m.Groups["Key"].Captures.Cast<Capture>().Select( ( a, i ) => new { a.Value, i } )
     join cpValue in m.Groups["Value"].Captures.Cast<Capture>().Select( ( b, i ) => new { b.Value, i } ) on cpKey.i equals cpValue.i
     select new KeyValuePair<string, string>( cpKey.Value, cpValue.Value ) ).ToDictionary( kvp => kvp.Key, kvp => kvp.Value )

  } ).ToDictionary( itm => itm.Section, itm => itm.kvps );

[Werner Salomon]

f.-th. schrieb:

.. Aber ich befürchte nur wenige haben C++ so drauf wie ihr. Der Beitragsersteller hat wahrscheinlich schon kapituliert und wird weiter sein "C mit cout" - Stil folgen. Selbst in "C mit cout" erschien mir sein Quelltext noch ein wenig zu umständlich

Kann man da einen C++ Einsteiger freundlicheren Weg finden?

Kann man sicher, in diesem Fall sollte es kein Problem sein. Angenommen Du kannst die Basics, string & vector und ein wenig IO. Dann kann man sicher eine Funktion schreiben, mit folgender Signatur:

bool check_muster( std::istream& in, const std::string& muster_text );

Dazu muss man noch wissen, dass sowohl std::cin, als auch ifstream beides std::istream's sind, auch wenn std::ifstream nochmal abgeleitet ist. Das wissen viele Anfänger nicht, aber viele Anfänger wissen schon dass man mit std::istream::get() Zeichen einlesen kann.
Die obige Funktion soll jetzt die Zeichen aus 'muster_text' aus dem istream lesen und dann ein true liefern, wenn alle Zeichen passen. Ansonsten soll die Funktion false zurückgeben und mit dem Lesen aufhören, wenn ein Zeichen nicht übereinstimmt.

bool check_muster( std::istream& in, const std::string& muster_text )
{
    for( unsigned i = 0; i < muster_text.size(); ++i )
    {
        char c = in.get();
        if( c != muster_text[i] )
        {
            return false; // keine Übereinstimmung -> Fehler
        }
    }
    return true; // jedes Zeichen des inputs stimmte mit 'muster_text' überein
}

ist das schon schwer - nee oder?

Wenn man diesen ersten Entwurf jetzt auf meinen Test loslassen würde - ich weiß, es geht nicht, Schnittstelle passt nicht, aber nur mal für Spaß angenommen - dann knallt es in Zeile 29. Das liegt daran, dass der erste Entwurf keine führenden Leerzeichen überliest. Das sollte er tun, denn die Funktion soll sich ähnlich verhalten, wie wenn man z.B. ein Wort oder eine Zahl einliest.

Das kann auch jeder ausprobieren, wenn er hinter der Funktion check_muster einfach noch dies einfügt:

// -- Black Magic - nicht angucken ;-)
struct muster { explicit muster( const std::string& t ) : t_(t) {} std::string t_; };
std::istream& operator>>( std::istream& in, muster m ) { if( !check_muster( in, m.t_ ) ) in.setstate( std::ios_base::failbit ); return in; }

.. und nicht vergessen, die notwendigen includes (die aus meinem Test).
Zu dem 'black magic' komme ich heute nicht - im Augenblick dient das nur dazu, die geforderte Schnittstelle herzustellen. man könnte natürlich auch den Anwender-Code (z.B. den Test) so ändern, dass er nur mit der Funktion oben arbeiten kann.

Überlesen von Leerzeichen geht ganz einfach mit std::ws. Einfach hinzufügen:

bool check_muster( std::istream& in, const std::string& muster_text )
{
    in >> std::ws; // führende white space character überlesen
    for( unsigned i = 0; i < muster_text.size(); ++i )
    {
        char c = in.get();
        if( c != muster_text[i] )
        {
            return false; // keine Übereinstimmung -> Fehler
        }
    }
    return true; // jedes Zeichen des inputs stimmte mit 'muster_text' überein
}

phyax hat das in seinem Code ganz geschickt mit dem std::istream::sentry-Objekt (Zeile gemacht; würde ich aber schon als fortgeschritten bezeichnen.

Über die obige Hürde kommen wir drüber, dummerweise knallt es nun in Zeile 56 des Tests. Das Wieder-Aufsetzen funktioniert nicht.
Wenn ein Zeichen gelesen wurde, so ist es natürlich für spätere Leser nicht mehr zugänglich, auch wenn der erste damit nichts anfangen kann. Das Zeichen sollte also wieder zurück in den Stream - das geht mit std::istream::putback. Ich hatte mich ja an anderer Stelle schon mal über putback ausgelassen, finde aber gerade den Thread nicht wieder.

Man kann putback nicht bedenkenlos aufrufen, aber man kann in 99% aller Fälle putback genau einmal rufen, wenn man vorher genau ein Zeichen gelesen hat. Man stelle sich vor, dass das Input-Device eine Serielle-RS232-Schnittstelle ist (die älteren unter uns kenne das noch ) Die Hardware diese Device kann i.A. genau 1 Zeichen halten. Mit dem Lesen dieses Zeichens erkläre ich nur das aktuelle Zeichen als ungültig - also bereits gelesen, aber man muss nicht schon das nächste Zeichen empfangen. Mit dem einmaligen(!) putback geschieht jetzt nichts anderes als diese Zeichen wieder als 'ungelesen' zu markieren. Damit steht es dem nächsten Leser wieder zur Verfügung.

Kommt ein falsches Zeichen, so put'te man es 'back' und verlasse die Funktion mit false .

bool check_muster( std::istream& in, const std::string& muster_text )
{
    in >> std::ws; // führende white space character überlesen
    for( unsigned i = 0; i < muster_text.size(); ++i )
    {
        char c = in.get();
        if( c != muster_text[i] )
        {
            in.putback( c ); // das erste nicht übereinstimmende Zeichen zurück
            return false; // keine Übereinstimmung -> Fehler
        }
    }
    return true; // jedes Zeichen des inputs stimmte mit 'muster_text' überein
}

.. und schon läuft zumindest der Test durch.

Es gibt aber noch zwei Punkte zu diskutieren. Der erste Punkt betrifft die führenden Leerzechen. std::ws liest immer(!) die Leerzeichen. Ein Benutzer hat aber die Möglichkeit, das skipws-Flag im Stream rückzusetzen, d.h. er möchte die führenden Leerzeichen gar nicht überlesen, vielleicht weil sie Teil der Muster-Textes sind.
Das ist einfach, wenn man weiß, wie man dieses Flag abfragt.

if( in.flags() & std::ios_base::skipws )
        in >> std::ws; // führende white space character nur überlesen, wenn 'skipws' gesetzt

Der zweite Punkt ist wesentlich subtiler, und betrifft den Fall, wenn das Einlesen des Zeichens mit in.get() schief geht. Natürlich wird ein Character zurück gegeben und da das ein char(EOF) (in der Praxis meist ein char(-1)) ist, wird das in den seltensten Fällen mit dem Mustertext übereinstimmen. Zu Problemen kommt es erst dann, wenn das Zeichen zufällig mit den letzten Zeichen in Mustertext übereinstimmt. So ein Fehler tritt gegebenenfalls sehr spät auf, und kann sehr ärgerlich werden.
Nun die Lösung ist einfach - man fragt den Stream ab, ob noch alles ok ist. Das geht genauso wie nach dem Einlesen von einer Zahl oder sonstwas. Schreibt man dann:

int zahl;
    if( in >> zahl ) { // alles gut

so fügt man hier nur die entsprechende Abfrage ein:

bool check_muster( std::istream& in, const std::string& muster_text )
{
    if( in.flags() & std::ios_base::skipws )
        in >> std::ws; // führende white space character überlesen, wenn 'skipws' gesetzt
    for( unsigned i = 0; i < muster_text.size(); ++i )
    {
        char c = in.get();
        if( !in )
            return false; // EOF oder Fehler
        if( c != muster_text[i] )
        {
            in.putback( c ); // das erste nicht übereinstimmende Zeichen zurück
            return false; // keine Übereinstimmung -> Fehler
        }
    }
    return true; // jedes Zeichen des inputs stimmte mit 'muster_text' überein
}

und gut ist!

f.-th. schrieb:

Oder passt das nicht zum Stil dieses Forums?

es sollte sicher nicht 'Stil des Forums' sein, hier nur 'Hi-Tech'-Lösungen zu posten, oder noch schlimmer posten zu dürfen. Ich find's auch nicht gut, wenn mancher, der hier mutig (oder naiv) seine ersten Versuche postet, gleich zum Volltrottel erklärt wird.
Letztlich vergrault man sich dadurch den Nachwuchs - und jeder hat mal klein angefangen.

Gruß
Werner

[Skym0sh0]

respekt werner und dickes +1

[Sone]

Werner, kann man in deiner Version nicht statt get() + putback() einfach peek() + ignore() verwenden?
Fände ich persönlich schöner.

[Werner Salomon]

Sone schrieb:

kann man in deiner Version nicht statt get() + putback() einfach peek() + ignore() verwenden?

Hallo Sone,

ja - kannst Du machen. Zu beachten ist, dass peek den istream nicht auf fail sondern nur auf EOF setzt, falls EOF erreicht wird. Die anschließende Abfrage sollte also sein

char c = in.peek();
    if( !in.good() ) // ist in.eof()==true, dann ist in.good()==false
        return false;

Dieses Vorgehen ist auf streambuf-Ebene sogar das übliche (also sgetc() und anschließend snextc()), auf Stream-Ebene eher nicht, was ich bisher gesehen habe.

Gruß
Werner