Bin grad ein bisschen am verzweifeln.
Dieser Code produziert aus irgendeinem Grund einen Stack overflow.
Konnte die letzten 2 Wochen ned an dem Code arbeiten, da ich auf Daten dafür gewartet habe (Zugansdaten für ne xml abfrage, da die alten zugansdaten ned mehr gingen). Jetz hab ich heute eben die neuen Zugansdaten eingegeben, passt auch alles was er an Daten runterläd, jedoch bekomm ich an einer anderen stelle einen Stack overflow. Hier mal der Code:

struct Saved_Quanty{
	ulong locationID;
	ulong typeID;
	llong min;
	llong max;

	Saved_Quanty(){};
	~Saved_Quanty(){};

	Saved_Quanty(ulong locID, ulong typID, llong mi, llong ma){
		locationID = locID;
		typeID = typID;
		min = mi;
		max = ma;
	};

	bool operator == (Saved_Quanty rhs){
		return(locationID == rhs.locationID && typeID == rhs.typeID);
	};

	bool operator != (Saved_Quanty rhs){
		return(locationID != rhs.locationID || typeID != rhs.typeID);
	};

	Saved_Quanty(const Saved_Quanty & rhs){
		locationID = rhs.locationID;
		typeID = rhs.typeID;
		min = rhs.min;
		max = rhs.max;
	};

	Saved_Quanty & operator = (Saved_Quanty &rhs){
		if(rhs == *this){  //<--- Hier kommt ein Stack Overflow
			return *this;
		};
		Saved_Quanty to_swap(rhs);
		std::swap(to_swap,*this); //<--- Und hier
		return *this;
	};
};

bekomme die 3 Fehlermeldungen, die 2te und 3te zu unmengen (über 100x die gleiche), die 1ste nur 1 mal.

>	EVE Logistik -2-.exe!Saved_Quanty::operator=(Saved_Quanty & rhs={...})  Zeile 56 + 0x1b Bytes	C++
 	EVE Logistik -2-.exe!std::swap<Saved_Quanty>(Saved_Quanty & _Left={...}, Saved_Quanty & _Right={...})  Zeile 23	C++
 	EVE Logistik -2-.exe!Saved_Quanty::operator=(Saved_Quanty & rhs={...})  Zeile 61 + 0xd Bytes	C++

Weis grad echt ned weiter Der Code funktionierte vor 2 Wochen noch einwandfrei und hab nichts daran geändert.

Dieser Code produziert aus irgendeinem Grund einen Stack overflow...

Und vermutlich auch nicht an den genannten Stellen (Stack overflow werden in der Regel an anderen Stellen "vorbereitet" als die eigentliche Fehlermeldung). Ich würde eher die Stellen davor überprüfen.

Hier der alte Code:

bool Assets::insert_quantities(){
	for(std::list<Item>::iterator iter = mainList.begin(); iter != mainList.end(); ++iter){
		Saved_Quanty temp;
		temp = quanties.get_quant_for_item(iter->get_locationID(), iter->get_typeID());
		if(temp != Saved_Quanty(0,0,0,0)){
			iter->quantities.set_min(temp.min);
			iter->quantities.set_max(temp.max);
		};
	};

	return true;
};

Hier der neue:

bool Assets::insert_quantities(){
	for(std::list<Item>::iterator iter = mainList.begin(); iter != mainList.end(); ++iter){
		Saved_Quanty* temp = new Saved_Quanty(quanties.get_quant_for_item(iter->get_locationID(), iter->get_typeID()));
		if(*temp != Saved_Quanty(0,0,0,0)){
			iter->quantities.set_min(temp->min);
			iter->quantities.set_max(temp->max);
		};
		delete temp;
	};

	return true;
};

Eine Frage hätte ich aber noch, passt jetzt ned zum Thema.

Habe bei den Projekteinstellungen in Debug den Multi-Byte Zeichensatz, im Release den Unicode-Zeichensatz.

Ich verwende eine Funktionion, die je nach Zeichensatz entweder LPCSTR oder LPCWSTR verwendet. Es ist kein Problem einen std::string in LPCSTR zu casten, jedoch ist es ein problem ihn in LPCWSTR zu casten, auch bei std::wstring.

Kann es jetzt zu problemen kommen wenn ich im Release auch den Multi-Byte Zeichensatz verwende?

Saved_Quanty & operator = (Saved_Quanty &rhs){
		if(rhs == *this){  // normalerweise vergleicht man die Adressen, nicht die Inhalte
			return *this;
		}; // PFUI: ";" ist hier überflüssig
		Saved_Quanty to_swap(rhs);
		std::swap(to_swap,*this); // wieso überhaupt über swap? sind ja bloss 4 integers, die könntest du auch einfach zuweisen...
		return *this;
	}; // PFUI: ";" ist hier überflüssig

Rate mal was std::swap verwendet um die Werte zu tauschen. Tip: wenn du richtig rätst, weisst du, woher die Endlos-Rekursion kommt, die deinen Stack-Overflow verursacht.

Neo Gandar schrieb:

Saved_Quanty & operator = (Saved_Quanty &rhs){
		if(rhs == *this){  // normalerweise vergleicht man die Adressen, nicht die Inhalte
			return *this;
		}; // PFUI: ";" ist hier überflüssig
		Saved_Quanty to_swap(rhs);
		std::swap(to_swap,*this); // wieso überhaupt über swap? sind ja bloss 4 integers, die könntest du auch einfach zuweisen...
		return *this;
	}; // PFUI: ";" ist hier überflüssig

Rate mal was std::swap verwendet um die Werte zu tauschen. Tip: wenn du richtig rätst, weisst du, woher die Endlos-Rekursion kommt, die deinen Stack-Overflow verursacht.

Erstmal Danke für die Kommentare, werds gleich ändern und versuchen mir es anzugewöhnen es gleich so zu machen

Zum Raten: Jetzt wo dus sagst, stimmt, swap ruft ja immer den = operator auf, aber warum endet es jetzt nicht in einer endlosschleife? Was es doch eigentlich sollte, rein Theoretisch.

Ich werds jetz jedenfalls mal so lassen, dass es in der Funktion dynamisch angelegt wird, muss ja ned alles aufm stack landen

Zum Raten: Jetzt wo dus sagst, stimmt, swap ruft ja immer den = operator auf, aber warum endet es jetzt nicht in einer endlosschleife? Was es doch eigentlich sollte, rein Theoretisch.

Nur, wenn in Deiner Theorie dein Stack unendlich groß ist; denn bei einem Funktionsaufruf werden Parameter und Rücksprungadresse auf dem Stack abgelegt.

Neo Gandar schrieb:

Ich werds jetz jedenfalls mal so lassen, dass es in der Funktion dynamisch angelegt wird, muss ja ned alles aufm stack landen

Dein Code stinkt. Du brauchst in diesem Fall keinen eigenen Kopier-Konstruktor und auch keinen Zuweisungsoperator, da die Compiler-generierten Versionsn automatisch das Richtige tun. Dein Zuweisungsoperator stinkt außerdem gewaltig. Zum Beispiel nimmt er unnötigerweise den "rhs" Parameter als reference-to-non-const. Deswegen kannst Du auch manche Objekte ("rvalues") nicht zuweisen. Der Copy-and-Swap-Trick, den Du da nachmachen wolltest, geht ein bischen anders. Aber wie gesagt, der ist in diesem Fall auch überflüssig! Die Vergleichsfunktionen (operator== und operator!=) sollten freie Funktionen mit reference-to-const Parametern sein:

bool operator==(Saved_Quanty const& lhs, Saved_Quanty const& rhs)  
  {
    return .....
  }

So, wie Du sie jetzt geschrieben hast, werden die Objekte unnötig kopiert.

Gruß,
SP