vector<string> gesamtT(20);

        while(!datei.eof())
	{
		datei.get(eingelesen,100,'|');
		cout <<eingelesen;
		datei.get(eingelesen,2);
		cout<<eingelesen;
		datei.get(eingelesen,100,'|');
		cout <<eingelesen;
		datei.get(eingelesen,2);
		cout<<eingelesen;
		datei.get(eingelesen,100,'|');
		cout <<eingelesen;
		datei.get(eingelesen,2);
		cout<<eingelesen;
		datei.get(eingelesen,100,'|');
		cout <<eingelesen;
		datei.get(eingelesen,2);
		cout<<eingelesen;
		datei.get(eingelesen,100,'|');
		cout<<eingelesen;

		if(i>19)
		{
			gesamtT.push_back(eingelesen);
		}
		else
		{
		gesamtT[i]=eingelesen;
		}

		datei.getline(eingelesen,100);
		cout<<eingelesen<<endl;

		++i;

	}

wäre auch hilfreich wenn ihr mir den Vorgang erläutern könntet warum die schleife dennoch etwas leeres einliest obwohl es doch eigentlich abbrechen sollte wenn das dateiende erreicht ist
Danke schonmal

Bei deiner Schreibweise ist das natürlich ein bisschen umständlich, da du nach dem letzten Lesen prüfen musst, ob der Stream noch gut ist (und dann prüf doch gleich alles, anstatt nur eof, du willst schließlich alle Fehler abfangen). Besser geht es, wenn du für deinen Datensatz einen eigenen Leseoperator definierst, dann könntest du schreiben:

datansatz data;
while ((datei >> data).good())  // Der Leseoperator sollte den Stream selbst zurückliefern
 speichere(data);

Oder kurz durch implizite Umwandlung des Streams in einen bool'schen Ausdruck:

datansatz data;
while (datei >> data)  // Der Stream liefert 0 bei fail(), sonst etwas ungleich 0
 speichere(data);

Oder damit man den datensatz schön lokal hat:

for (datensatz data; datei >> data; speichere(data));

So nun zum Problem, könntest du mir genauer erklären wie das mit dem leseopertator funktioniert? denn wenn ich das so eingeben wie du bekomm ich nur fehlermeldung das irgendwo n semikolon fehlt, was aber nicht fer fall ist.
Denn wie du sicherlich gemerkt hast bin ich noch in der lernphase.^^

Ahhh....okay nach etwa zwanzigmal lesen deiner antwort hab ich nun kapiert wie ichs machen kann, da du aber meintest dass das falsch ist und ich mich mit erlernen von c++ ja auf mein Studium vorbereiten möchte und mir keinen schlechten Stil angewöhnen möchte könntest du mir vlt. nochn Tipp geben oder ein Buch empfehlen oder irgendwas ?

Danke erstmal für deine Hilfe
Lg Sc0rpe

class example
{
  int a, b;
  friend std::istream &operator>>(std::istream &in, example &ex)
  {
    return in >> ex.a >> ex.b;
  }
};

Hier geben wir fein hübsch die Referenz auf den Stream selber zurück, genau so wie es (fast) alle Lesefunktionen der Standardbibliothek aus gutem Grund machen. Daher kann man auch so hübsch return in >> ex.a; schreiben anstatt gleichbedeutend aber länger:

in >> ex.a;
return in;

Denk dir Operatorüberladung als ganz normale Funktion mit komischem Namen. Der einzige Unterschied zu normalen Funktionen ist, dass man sie anstatt
mit operator>>(stream, ex); auch mit der schöneren und konsistenteren, aber gleichbedeutenden, Schreibweise stream >> ex; aufrufen kann. Das erste kann man aber auch!

Dann macht man eine Schleife wie in meiner ersten Antwort schon beschrieben, die so lange läuft, wie der Fehlerstatus des Streams nicht gesetzt ist. Ein Objekt wird nur dann abgespeichert, wenn das Lesen auch erfolgreich war, was man erreicht, indem man den Lesevorgang in die Schleifenbedingung packt und das Abspeichern in den Schleifenkörper. Ich habe dir oben schon erklärt wie man das kompakt als for-Schleife schreiben kann, aber ich benutze mal das anfängerfreundlichere while:

std::vector<example> examples;
 example ex;
 while(datei >> ex)   // Der obige Operator, liefert den Dateistream selber zurück. Ging das Lesen gut, wird dieser zu true, ansonsten zu false
  examples.push_back(ex); // Wenn es gut ging, abspeichern

Alles in allem, noch mit einem Ausgabeoperator der Symmetrie wegen:

#include <iostream>
#include <sstream>
#include <vector>

class example
{
  int a, b;
  friend std::istream &operator>>(std::istream &in, example &ex)
  {
    return in >> ex.a >> ex.b;
  }
  friend std::ostream &operator<<(std::ostream &out, const example &ex)
  {
    return out << ex.a << ' ' << ex.b;
  }
};

int main()
{
  std::stringstream datei("1 2 3 4 5 6 7 8 9 0");
  std::vector<example> examples;
  for(example ex; datei >> ex; examples.push_back(ex));

  std::cout << "Gelesene Wertepaare:\n";
  for (std::vector<example>::iterator it = examples.begin(), end = examples.end();
       it != end; ++it)
    std::cout << *it << '\n';
}

Hier nochmal mit den gleichen Sprachmitteln die Schleife in der Form wie du sie hattest:

int main()
{
  std::stringstream datei("1 2 3 4 5 6 7 8 9 0\n"); // Hier habe ich den letzten Wert mit einem Zeilenumbruch abgewschlossen
  std::vector<example> examples;

  while (!datei.eof())
    {
      example ex;
      datei >> ex;
      examples.push_back(ex);
    }

  std::cout << "Gelesene Wertepaare:\n";
  for (std::vector<example>::iterator it = examples.begin(), end = examples.end();
       it != end; ++it)
    std::cout << *it << '\n';
}

Beobachte, wie nun der letzte Wert doppelt eingefügt wird, wie ich oben erklärt habe. Dies passiert nur, wenn auf den letzten Wert noch irgendetwas folgt, wie hier der Zeilenumbruch. Was aber ziemlich normal ist in einer Datei, dass diese auf einen Zeilenumbruch endet. Erklärung warum das so ist, findest du in meiner ersten Antwort.

Und noch etwas wichtiges: Besorg dir ein gutes Buch: Lieber nichts lernen, als schlecht lernen! Denn etwas falsch gelerntes vergisst man so leicht nicht. Es wird zu schlechten Angewohnheiten, die man nicht mehr los wird. Siehe zweiter Link in meiner Signatur.

Vielen Dank für die nette, schnelle und ausführliche Hilfe
Ich Liebe diese Forum
Lg Sc0rpe

Thema kann geschlossen werden