Ich habe mir zwei eigene Klassen geschrieben mTrace und mPoint

class mTrace{
public:
	/// mTrace empty constructor
	mTrace()
		: traceID_(-1), color_(-1), numPoints_(-1) {points_.clear();}
	/// mTrace constructor
	mTrace(const int& traceID, const int& color, const int& numPoints, const std::vector<mPoint>& points)
		: traceID_(traceID), color_(color), numPoints_(numPoints), points_(points){}
	/// mTrace copy constructor
	mTrace(const mTrace &mt)
		: traceID_(mt.traceID()), color_(mt.color()), numPoints_(mt.numPoints()), points_(mt.points()){}
	/// mTrace destructor
	virtual ~mTrace() {}

//... Get-, Set-Methoden, Operatoren

	void setPoint(const mPoint &pt, const int pos){
		points_.at(pos) = pt;
	};
	/// replace points
	void setPoints(const std::vector<mPoint> vec){points_.clear(); points_ = vec;};
	/// remove a point from the trace
	void remPoint(const int &pos){std::vector<mPoint>:: iterator it = points_.begin() + pos; points_.erase(it);};

private:
	int traceID_;
	int color_;
	int numPoints_;
	std::vector<mPoint> points_;
};

class mPoint{
public:
	//Constructor
	/// mPoint empty constuctor
	mPoint()
		: x_(-1), y_(-1) {}
	/// mPoint constructor
	mPoint(const int& x, const int& y)
		: x_(x), y_(y) {}
	/// mPoint copy constructor
	mPoint(const mPoint& mp)
		: x_(mp.x()), y_(mp.y()) {}
	///mPoint destructor
	virtual ~mPoint() {}

//... Get-, Set-Methoden, Operatoren

private:
	int x_;
	int y_;
};

Nun lese ich in der Funktion nodeToTrace() meine Daten ein

mTrace nodeToTrace(TiXmlElement* e) {

	if (strcmp(e->Value(), "Trace") != 0)
		throw runtime_error(string("wrong trace ") + e->Value());

	const char *traceID, *color, *numPoints;

	traceID = e->Attribute("traceID");
	color = e->Attribute("color");
	numPoints = e->Attribute("numPoints");

	vector<mPoint> vec;
	for (TiXmlElement* element = e->FirstChildElement(); element; element = element->NextSiblingElement()) {
		vec.push_back(nodeToPoint(element));
	}

////////////hier passiert der Fehler!
	mTrace result(atoi(traceID), atoi(color), atoi(numPoints), vec);

//	result.setPoints(vec);
//	result.setPoint(vec.at(0), 0);
//	result.remPoint(0);

	for(vector<mPoint>::iterator pt = vec.begin(); pt != vec.end(); ++pt){
		cout << *pt << endl;
	}

	cout << result << endl;

	return result;
}

In meinem Vector vec stehen die Daten korrekt. In meinem element result vom Typ mTrace stimmt der erste Eintag vom Vektor nicht. Sowohl, wenn ich ihn oben über den Kontruktor erzeuge, noch wenn ich den gesamten Vektor in result überschreibe, noch, wenn ich den ersten Punkt im Vektor von Result ersetzen möchte. Ich habe ebenfalls probiert einen leeren Punkt (0,0) an den Anfang zu setzen und später wieder zu löschen, doch leider ohne Erfolg. Der erste Punkt wurde zwar gelöscht, jedoch war hat dann das neue erste Element falsche Einträge. Übergehen kann ich es nicht, da im späteren Verlauf, die Vektoren umsortiert werden. Weiss jmd. wo das Problem ist?

Deine Klassen brauchen übrigens weder Copykonstruktor noch Destruktor, wenn da nicht noch irgendwelche Member mit dynamischer Speicherverwaltung drinstecken.

Und points_.clear() ist an beiden Stellen, wo es benutzt wird, unnötig.

du übergibst den temporären rückgabewert von atoi als referenz.
das macht probleme vermute ich.

probier mal die ergebnisse von atoi in einer variable zu speichern und dann dem konstruktor zu übergeben.

@ihoernchen habe die Werte zwischengespeichert mit dem gleichen Ergebnis. Hatte ich aber auch bereits vermutet. Denn ich hatte schon eine Variante, in der ich mir erst mTrace result anlege und danach mittels Set-Methoden den Inhalt verändere.

@MFK Auch wenn ich Copyconstructor und Destuctor nicht benötige, schaden richten sie keinen an.

Unnötige Funktionen lenken vom Probem ab, machen den Code unübersichtlicher und bieten zusätzliche Fehlerquellen.

Verpass deinen Klassen doch auch noch einen Zuweisungsoperator. Wenn schon überflüssiger Code, dann richtig.

Flaut schrieb:

Mit einem kompilierbaren Code wird schwierig, da noch ein ganzer Rattenschwanz mit dran hängt (Boost-Library, TinyXML oder libpng beispielsweise).

Boost und libpng braucht man hier offensichtlich nicht. Und diesen TiXmlElement* durch ein Dummy zu ersetzen, sollte doch auch kein Problem sein.

Falls doch, dann zeig halt mal mTrace::points().

Ansonsten wie MFK schon sagte wird es schwer das ganze ohne kompilierbaren Code zu prüfen.

Fehlerquellen:
- const int Referenzen
- nodeToPoint: Was macht nodeToPoint? Bzw. was wird zurückgeliefert?
- Was passiert, wenn du in nodeToTrace vec mit Dummy-Werten füllst? Geht das immer noch schief?
- Was passiert im operator<< für mTrace?
- Wieviele Werte sind im vector (der später ja auch kopiert wird)? Passiert es bei großen wie bei kleinen Mengen? Was passiert, wenn vec genau 1 Element enthält?

void setPoints( const std::vector<mPoint> vec )
{
  points_.clear(); 
  points_ = vec;
}

Und was gibt nodeToPoint() im Fehlerfall zurück? Wenn das erste Element Tünneff ist, kann das deinen Fehler auslösen?

Gruß Kimmi

ihoernchen schrieb:

Ich rate dir die ganzen const int Referenzen zu entfernen. Die dienen eher als Fehlerquelle. Bringen im Gegenzug nichts. Unabhängig von deinem Problem.

gemacht

ihoernchen schrieb:

Ansonsten wie MFK schon sagte wird es schwer das ganze ohne kompilierbaren Code zu prüfen.

ich versuche es zu packen und nen link einzubinden

ihoernchen schrieb:

- nodeToPoint: Was macht nodeToPoint? Bzw. was wird zurückgeliefert?

liest die Datei aus und gibt einen Wert vom Typ mPoint zurück.

Bsp.
<Point num="0">4949 1751</Point>
<Point num="1">4977 1676</Point>
<Point num="2">5005 1608</Point>

ihoernchen schrieb:

- Was passiert, wenn du in nodeToTrace vec mit Dummy-Werten füllst? Geht das immer noch schief?

ja, gleiche fehler

ihoernchen schrieb:

- Was passiert im operator<< für mTrace?

inline std::ostream& operator<<(std::ostream& out, const mTrace& trace){
	out << "TraceID: " << trace.traceID() << " Color: " << trace.color()
		<< " NumPoints: " << trace.numPoints() << "\n";
	for(std::vector<mPoint>::iterator it = trace.points().begin(); it!=trace.points().end(); ++it){
		out << *it << '\n';
	}
	return out;
}

ihoernchen schrieb:

- Wieviele Werte sind im vector (der später ja auch kopiert wird)? Passiert es bei großen wie bei kleinen Mengen? Was passiert, wenn vec genau 1 Element enthält?

Das variiert, aber im Schnitt 40 Einträge.

@MFK: Was meinst Du mit mTrace::points() ?

Deine Klasse mTrace hat eine Methode namens points. Jedenfalls wird sie im Copykonstruktor benutzt.

Flaut schrieb:

ihoernchen schrieb:

- nodeToPoint: Was macht nodeToPoint? Bzw. was wird zurückgeliefert?

liest die Datei aus und gibt einen Wert vom Typ mPoint zurück.

Das ist, was die Methode tun soll. Um zu beurteilen, was sie tatsächlich tut, musst du schon den Code zeigen.

/// returns the Points from the Trace
std::vector<mPoint> points() const {return points_;};

und nodeToPoint

mPoint nodeToPoint(TiXmlElement* pt) {

	if (pt && strcmp(pt->Value(), "Point") == 0) {
		const char* c = textValue(pt);
		int x = 0, y = 0;
		for (unsigned int i = 0; i < strlen(c); ++i) {
			if (c[i] == ' ') {
				x = y;
				y = 0;
				++i;
			}
			y = 10 * y + (c[i] - 48);
		}
		return mPoint(x, y);
	} else
		throw runtime_error(string("wrong point ") + pt->Value());
}

bevor die Frage kommt textValue

const char* textValue(TiXmlElement* e) {

	TiXmlNode* first = e->FirstChild();
	if (first != 0 && first == e->LastChild() && first->Type()
			== TiXmlNode::TEXT)
		return first->Value();
	else {
		throw runtime_error(string("wrong element ") + e->Value());
	}
}

Die Iteratoren, die begin() und end() in deinem operator<< liefern, gehören daher zu unterschiedlichen Kopien des Vectors. Außerdem sind die Iteratoren sofort wieder ungültig, weil die Kopien gleich nach dem Aufruf von points() wieder zerstört werden.

Lass points() eine konstante Referenz zurückgeben.

// operator<<
for(std::vector<mPoint>::iterator it = trace.points().begin(); it!=trace.points().end(); ++it)

std::vector<mPoint> points() const {return points_;};

Du gibst eine Kopie des Vectors zurück. Das passt nicht.
Hier solltest du eine Referenz zurückgeben.

const std::vector<mPoint>& points() const {return points_;};

Macht Sinn damit der Vector nicht immer kopiert wird.

Das ist auch das Problem an der Schleife oben. Warum das überhaupt funktioniert ist komisch

Edit: zu langsam

Super danke.

// böse
MyClass& Funktion()
{
  MyClass m;
  return m;
}
MyClass* Funktion()
{
  MyClass m;
  return &m;
}

// ok
MyClass& Funktion()
{
  static MyClass m; // statische Variablen bleiben bis zum Programmende
  return m;
}
MyClass* Funktion()
{
  static MyClass m; // ginge natürlich auch: MyClass* m = new MyClass; return m;
  return &m;
}

// auch ok
MyClass m;
MyClass& Funktion() // selbes für MyClass*
{
  return m;
}

// ginge natürlich auch: MyClass* m = new MyClass;

Davon würde ich sehr stark abraten, besonders wenn es anders geht. Die Wahrscheinlichkeit, dass der Aufrufer vergisst, den Speicher freizugeben, ist einfach zu hoch. Mindestens ein Smart Pointer oder besser gleich eine Objektrückgabe wäre eine Alternative.