ich parse gerade ein wenig herum und finde ständig unnötige Zeichen. Die parse ich weg, indem ich das Ergebnis einfach in ein dummy-char/float/string/whatever schiebe. Für einen String wie "_10.57*Test" sieht das dann etwa so aus:

char charDummy;
float floatDummy;
string actualResult;
stream >> charDummy /* blank */ >> floatDummy >> charDummy /* Star */ >> actualResult;

, um an Test zu kommen, wenn mich das davor nicht interessiert.

Erscheint mir aber nicht so ganz gescheit. Gibt es nicht auch Manipulatoren, die bestimmte Dinge ignorieren? Die machen zwar genau dasselbe, sehen aber chicer aus. Oder findet ihr das so in Ordnung?

Erscheint mir aber nicht so ganz gescheit. Gibt es nicht auch Manipulatoren, die bestimmte Dinge ignorieren?

template<typename T>
istream& ignore(istream& in)
{
	T t;
	return in >> t;
}

file >> x >> y >> ignore<int> >> z;

Wie wäre es damit ?

Okay, danke. Das führt mich dann zur nächsten Frage, ob man für eine Nicht-Typprüfung überhaupt Manipulatoren braucht. Denn mit nem char dummy und stream >> dummy spart man sich ein paar Zeilen und beim Parsen ein paar Zeichen.

Ich verstehe die Frage nicht.

Eisflamme schrieb:

Okay, danke. Das führt mich dann zur nächsten Frage, ob man für eine Nicht-Typprüfung überhaupt Manipulatoren braucht. Denn mit nem char dummy und stream >> dummy spart man sich ein paar Zeilen und beim Parsen ein paar Zeichen.

Ich verstehe die Frage nicht.

Ich auch überhaupt nicht.
Btw: Was soll eine Nicht-Typprüfung sein?

Die Frage ist: würdet ihr das in meinem Fall über nen Manipulator machen? Falls ja, welche Vorteile hat der denn gegenüber der Dummy-Variablen-Variante? Letztere erzeugt schließlich kürzeren Code. Aber selbst, falls nicht, gibt es irgendwelche Vorteile?

Sorry, ich meinte Wertprüfung.

Die Frage ist: würdet ihr das in meinem Fall über nen Manipulator machen? Falls ja, welche Vorteile hat der denn gegenüber der Dummy-Variablen-Variante? Letztere erzeugt schließlich kürzeren Code.

???
Nein, tut sie nicht!?

Es gibt überhaupt keine Vorteile, wenn dich der Wert dieser Dummy-Variablen nicht interessiert. Das in eine Funktion auszulagern ist der beste Weg.

template<typename T>
istream& ignore(istream& in)
{
    T t;
    return in >> t;
}

file >> x >> y >> ignore<int> >> z;

vs.

int dummyInt;
file >> x >> y >> dummyInt >> z;

Klare Sache. Aber bei allen möglichen Variablentypen und Mehrfachnutzung ist ignore natürlich besser. Darum auch meine Zusatzfrage, die Du bei Deinem Geschrei und den drei Fragezeichen (die ich persönlich eigentlich nur als Hörspiel und nicht als adäquates Satzzeichen in einem Fachforum kenne) vermutlich überlesen hast. Ich zitiere:

Aber selbst, falls nicht, gibt es irgendwelche Vorteile?

Mit Vorteile meine ich natürlich die der Manipulator-Variante.

Klar, tut sie das in meinem Fall.

template<typename T>
istream& ignore(istream& in)
{
    T t;
    return in >> t;
}

file >> x >> y >> ignore<int> >> z;

vs.

int dummyInt;
file >> x >> y >> dummyInt >> z;

Ich würde trotzdem den Manipulator nehmen, auch wenn das Konstrukt nur 1x benutzt wird. Grund: ignore<datentyp> ist einfach aussagekräftiger als >>dummy. Und wenn du das Konstrukt öfters brauchst, dann ist nimmst du natürlich sowieso den Manipulator. Also ich seh hier zwei Vorteile: Aussagekraft und Wiederverwendbarkeit.