Wertetabelle aus Datei mit unbekannter Größe auslesen

phanlipo schrieb:

ich habe ein funktionierendes Beispiel für mein Problem, jedoch bin ich mit der Lösung nicht zufrieden.

Mir scheint Dein Code löst ein Problem, das Du gar nicht hast.

Willst Du wirklich zwei unabhängige Vektoren mit lauter Zahlen?

Mir dünkt Du willst eigentlich Positionen auslesen, oder Koordinaten, oder Tupel - jedenfalls zwei Werte, die zusammen einen Sinn ergeben.

Nennen wir's mal pos:

struct pos{ int x,y; };

Jetzt hast Du ein File, in dem in jeder Zeile ein pos beschrieben durch seine beiden Member steht.
Also schreibst Du Dir einen operator>>() der aus einer solchen Zeile ein pos zusammenbaut:

std::istream& operator>>(std::istream& in, pos& p){
  return in >> p.x >> p.y;
}

Damit kannst Du jetzt ein pos aus einem Stream extrahieren.

Und das war's auch schon.
Du kannst das Spielchen jetzt für die Ausgabe wiederholen.

Im folgenden bastel ich insgesamt vier solcher Operatoren. Nur zur Veranschaulichung - die letzten beiden finde ich reichlich überflüssig.

#include <fstream>
#include <iostream>
#include <vector>

struct pos{ int x,y; };

typedef std::vector<pos> position_table;

std::istream& operator>>(std::istream& in, pos& p){
  return in >> p.x >> p.y;
}

std::ostream& operator<<(std::ostream& out, const pos& p){
  return out << p.x << '/' << p.y;
}

std::istream& operator>>(std::istream& in, position_table& positions){
  pos p;
  while(in>>p)
    positions.push_back(p);
  return in;
}

std::ostream& operator<<(std::ostream& out, const position_table& positions){
  for( const auto& p : positions)
    out << p << '\n';
  return out;
}

int main(){
  position_table positions;
  std::ifstream file("data.txt");
  file>>positions;
  std::cout << positions;
}

Sone

Das Puffern der Zeile ist völlig überflüssig.

#include <iostream>
#include <sstream>
#include <vector>
#include <iterator>
#include <algorithm>

int main()
{
	using namespace std;

	istringstream stream{"4 8 6 5 7 1 2 8"}; // Ob die beiden Paare durch einen Zeilenumbruch getrennt sind oder nicht, ist irrelevant. 
// (Ich nehme an, die Zeilenumbrüche sind in der Datei nur der Lesbarkeit wegen?)

	vector<double> x_vector, 
	               y_vector; // Die beiden vectors.

	double x, y;
	while( stream >> x >> y )
	{
		x_vector.push_back(x);
		y_vector.push_back(y);
	}

	// Ausgabe
	copy( begin(x_vector), end(x_vector), ostream_iterator<double>{cout << "X: ", " "} );
	copy( begin(y_vector), end(y_vector), ostream_iterator<double>{cout << "Y: ", " "} );
}

Edit: Furble war schneller.

Mir dünkt Du willst eigentlich Positionen auslesen, oder Koordinaten, oder Tupel - jedenfalls zwei Werte, die zusammen einen Sinn ergeben.

Sone

std::istream& operator>>(std::istream& in, position_table& positions){
  pos p;
  while(in>>p)
    positions.push_back(p);
  return in;
}

std::istream& operator>>(std::istream& in, position_table& positions)
{
  std::copy( std::istream_iterator<pos>(in), std::istream_iterator<pos>(), std::back_inserter(positions) );
  return in;
}

(Ungetestet)

volkard

Sone schrieb:

std::istream& operator>>(std::istream& in, position_table& positions){
  pos p;
  while(in>>p)
    positions.push_back(p);
  return in;
}

std::istream& operator>>(std::istream& in, position_table& positions)
{
  std::copy( std::istream_iterator<pos>(in), std::istream_iterator<pos>(), std::back_inserter(positions) );
  return in;
}

(Ungetestet)

wozu?

Sone

wozu?

Nun, die Devise ist doch, immer die Standard-Bibliothek ausschöpfen? Nackte Schleifen vermeiden?

volkard

Sone schrieb:

wozu?

Nun, die Devise ist doch, immer die Standard-Bibliothek ausschöpfen? Nackte Schleifen vermeiden?

Nö, sicher nicht.

Mach besser den Fehler weg.

Sone

volkard schrieb:

Mach besser den Fehler weg.

Der einzige Fehler den ich sehe, ist, dass der Container nicht geleert wird.

std::istream& operator>>(std::istream& in, position_table& positions)
{
  positions.clear();
  pos p;
  while(in>>p)
    positions.push_back(p);
  return in;
}

volkard

Sone schrieb:

Der einzige Fehler den ich sehe, ist, dass der Container nicht geleert wird.

Den meinte ich auch.

Kellerautomat

Auch falsch. Ein neuer Container sollte erstellt werden und dann move-assigned werden.

Sone

Kellerautomat schrieb:

Auch falsch. Ein neuer Container sollte erstellt werden und dann move-assigned werden.

Inwiefern ist das besser?

volkard

Kellerautomat schrieb:

Auch falsch. Ein neuer Container sollte erstellt werden und dann move-assigned werden.

Jo, man wird wohl erwarten, daß wenn der op>> failt, der vector unverändert bleibt.

knivil

Auch falsch

Falsch! Ansichtsache, problemspezifisch, sollte spezifiziert warden.