Wie der Titel schon sagt, ist mir einiges Unklar beim arbeiten mit Listen, Deques usw.

Hab hier mal schnell ein kleines Beispiel geschrieben, um meine Fragen zu verdeutlichen:

#include <iostream>
#include <list>

using namespace std;

class var{
private:
	int *a;

public:
	var(int b){
		a = new int(b);
	};

	~var(){
		delete a;
	};

	var(var *b){
	*a = *b->a;
	};

	void set_var(int b){
		*a = b;
	};

	int get_var(){
		return *a;
	};
};

int main(){

	list<var> *varlist = new list<var>;

	var a(12);

	var* b = new var(13);

	varlist->push_back(a);
	varlist->push_back(*b);

	delete varlist;
	delete b;

	return 0;
};

Also:

Wie genau arbeitet die Funktion push_back? Erstellt es eine Kopie des Objektes oder speichert es nur eine Referenz?
Hatte das Problem, dass wenn ich (siehe oben) *b in die Liste einfügte, und danach b löschte, der Eintrag in der List ungültig wurde, und somit einen Programmabsturzt verursachte. Wenn ich es jedoch nur mit push_back(*b) einfügte, und danach nicht "delete b" sondern gleich "b = new int" mache, kann ich nacher auf die Objekte zugreifen.

Es würde mir sehr viel Helfen zu wissen, wie genau die Funktion push_back() arbeitet, und worauf man Achten muss wenn man mit dieser Funktion mit dynamisch erzeugten Objecten arbeitet.

Besten Dank im vor raus.

Überleg mal was passiert, wenn ein Objekt vom Typ var kopiert wird. Es wird der Zeiger a kopiert. Dadurch hast du nach der Kopie zwei Objekte, welche einen Zeiger auf das gleiche Objekt besitzen. Wenn nun eines der zwei Objekte gelöscht wird, wird der Destruktor von var aufgerufen. Dieser löscht das Objekt, auf welches der Zeiger a zeigt. Du hast aber jetzt immer noch ein gültiges Objekt, welches einen Zeiger besitzt, der ins Nirvana zeigt. Über kurz oder lang kommt es hier zu einem Fehler, bzw. führt es zu undefiniertem Verhalten.

Was du hier tun musst, sind "Die Grossen Drei" zu implementieren:
http://en.wikipedia.org/wiki/Rule_of_three_(C%2B%2B_programming)

Damit kannst du dafür sorgen, dass nicht nur eine flache Kopie stattfindet, sondern eine tiefe Kopie. Also nicht der Zeiger a kopiert wird, sondern das worauf er zeigt.

Grüssli

PS: Wieso legst du eigentlich das list<var> Objekt auf dem Freestore ab?

Werd mir das mit "Die großen Drei" gleich mal ansehen.

Danke schonmal.

bb

Warum ich das ned auf den Stack packe? Ich habe mal wo gelesen, dass der Stack auch ned unbegrenzt Speicherplatz bietet. Und da in diese Liste etwa 10MB an Daten reingeladen werden, aus XML Dateien, dacht ich mir speicher ich die Liste im Heap. Bin noch am Lernen und Vertiefen von C++.

Hab "Die Grossen Drei" jetz eingebaut, bevor ich euch jedoch den Code vorlege noch eine Frage.

Wenn ich eine Klasse habe z.B:

class A{
private:
int a;
...
};

Wenn ich jetz "A *first = new A;" schreibe, wird dann die Variable in A, auf dem Heap oder dem Stack abgelegt? Wenn die auf dem Heap abgelegt wird dann kann ich mir doch eigentlich den mehr Aufwand mit Zeigern sparen.

So, hier mal der überarbeitete Ausschnitt aus der Original Klasse:

class Item{ 
private:
	//itemID,locationID,typeID,quantity,flag,singleton
	string *itemID;
	string *locationID;
	string *typeID;
	string *squantity;
	string *flag;
	string *singleton;
	string *containerID;
	bool   *contains;

	string *itemName;
	string *locationName;
	long long *quantity;
	long long *soll;
	long long *difference;
	string *groupID;
	string *group;
	string *categoryID;
	string *category;

	bool *adjusted;
public:
	Item(){
				itemID = new string("0");
				locationID = new string("0");
				typeID = new string("0");
				squantity = new string("0");
				flag = new string("0");
				singleton = new string("0");
				containerID = new string("0");
				contains = new bool(false);

				itemName = new string("0");
				locationName = new string("0");
				quantity = new long long (0);
				soll = new long long(0);
				difference = new long long(0);
				groupID = new string("0");
				group = new string("0");
				categoryID = new string("0");
				adjusted = new bool(false);
	};

	Item(string *iID,
		 string *lID,
		 string *tID,
		 string *qua,
		 string *fla,
		 string *sin,
		 string *cID,
		 bool	*con){
				itemID = new string(*iID);
				locationID = new string(*lID);
				typeID = new string(*tID);
				squantity = new string (*qua);
				flag = new string(*fla);
				singleton = new string (*sin);
				containerID = new string (*cID);
				contains = new bool(*con);

				itemName = new string("0");
				locationName = new string ("0");
				quantity = new long long(0);
				soll = new long long(0);
				difference = new long long(0);
				groupID = new string("0");
				group = new string("0");
				categoryID = new string("0");
				category = new string("0");
				adjusted = new bool(false);

	};

	Item(Item* base){
				*itemID = *base->itemID;
				*typeID = *base->typeID;
				*squantity = *base->squantity;
				*flag = *base->flag;
				*singleton = *base->singleton;
				*containerID = *base->containerID;
				*contains = *base->contains;

				*itemName = *base->itemName;
				*locationName = *base->locationName;
				*quantity = *base->quantity;
				*soll = *base->soll;
				*difference = *base->difference;
				*groupID = *base->groupID;
				*group = *base->group;
				*categoryID = *base->categoryID;
				*category = *base->category;
				*adjusted = *base->adjusted;

	};

	Item & operator = (const Item *other){

		string * new_itemID = new string(*other->itemID);
		string * new_typeID = new string(*other->typeID);
		string * new_squantity = new string(*other->squantity);
		string * new_flag = new string(*other->flag);
		string * new_singleton = new string(*other->singleton);
		string * new_containerID = new string(*other->containerID);
		bool * new_contains = new bool(*other->contains);

		string * new_itemName = new string(*other->itemName);
		string * new_locationName = new string(*other->locationName);
		long long * new_quantity = new long long(*other->quantity);
		long long * new_soll = new long long(*other->soll);
		long long * new_difference = new long long(*other->difference);
		string * new_groupID = new string(*other->groupID);
		string * new_group = new string(*other->group);
		string * new_categoryID = new string(*other->categoryID);
		string * new_category = new string(*other->category);
		bool * new_adjusted = new bool(*other->adjusted);

		delete itemID;
		delete typeID;
		delete squantity;
		delete flag;
		delete singleton;
		delete containerID;
		delete itemName;
		delete locationName;
		delete group;
		delete category;
		delete categoryID;
		delete locationID;
		delete contains, adjusted;
		delete quantity, soll, difference;
		delete groupID;

		itemID = new_itemID;
		typeID = new_typeID;
		squantity = new_squantity;
		flag = new_flag;
		singleton = new_singleton;
		containerID = new_containerID;
		contains = new_contains;
		itemName = new_itemName;
		locationName = new_locationName;
		quantity = new_quantity;
		soll = new_soll;
		difference = new_difference;
		groupID = new_groupID;
		group = new_group;
		categoryID = new_categoryID;
		category = new_category;
		adjusted = new_adjusted;

	};

	~Item(){
		delete itemID;
		delete typeID;
		delete squantity;
		delete flag;
		delete singleton;
		delete containerID;
		delete itemName;
		delete locationName;
		delete group;
		delete category;
		delete categoryID;
		delete locationID;
		delete contains, adjusted;
		delete quantity, soll, difference;
		delete groupID;
	};

....

Achja, wenn das so stimmt wie ich das eingebaut habe, dann liegt mein Problem wohl nicht daran sondern in einem anderen Teil des Programms

Das sieht nicht wirklich gesund aus..

Warum macht du alle Parameter dynamisch? - String braucht das wirklich nicht. Das sind hier ja nur einzelne Bestandteile. Wenn es nötig sein sollte dynamischen Speicher zu benutzen wegen der Grösse, dann mach das gleich mit den Item's und nicht den einzelnen Parameter..

Wenn ich jetz "A *first = new A;" schreibe, wird dann die Variable in A, auf dem Heap oder dem Stack abgelegt? Wenn die auf dem Heap abgelegt wird dann kann ich mir doch eigentlich den mehr Aufwand mit Zeigern sparen.

Hier wird durch new ein Objekt vom Typ A auf dynamisch angefordert und der Zeiger (welcher aber automatisch ( Stack ) ist).

Dann solltest du dir mal das Copy/Swap Idiom anschauen. Damit kannst du dir viel Arbeit sparen und deine Klasse sicherer machen.

EDIT:
Gerade noch aufgefallen:
Das hier macht nicht das, was du denkst:

delete quantity, soll, difference;

Da wir lediglich quantity gelöscht.

Und die Initialisierungsliste solltest du dir auch mal anschauen.

Werds nochmal überarbeiten und mir das mit dem Copy/Swap Idiom ansehen.

Danke schonmal

#Edit

Oh, ok, hab ich ned gewusst, gleich ändern.

Was meinst du das ich mir bei der Initialisierungsliste nochmal ansehen soll?

Warum ich das ned auf den Stack packe? Ich habe mal wo gelesen, dass der Stack auch ned unbegrenzt Speicherplatz bietet. Und da in diese Liste etwa 10MB an Daten reingeladen werden, aus XML Dateien, dacht ich mir speicher ich die Liste im Heap. Bin noch am Lernen und Vertiefen von C++.

Deshalb habe ich nachgefragt

#include <list>
#include <iostream>
#include <iterator>
#include <algorithm>

int main()
{
  std::list<int> first;
  std::list<int> second;

  // beide leer, ok, füllen wir eine:
  std::fill_n(std::back_inserter(first), 10000, 4);

  // Geben wir die Anzahl an Elemente aus:
  std::cout << "first count:  " << first.size() << std::endl;
  std::cout << "second count: " << second.size() << std::endl;

  // Grosser Unterschied ...
  // Nun betrachten wir mal die Bytegrösse der beiden Objekte auf dem Stack:
  std::cout << "first Bytes:  " << sizeof(first) << std::endl;
  std::cout << "second Bytes: " << sizeof(second) << std::endl;

  // Wird gleichviel sein ;)
}

Ein Objekt kann seine Grösse zur Laufzeit nicht verändern, erst recht nicht auf dem Stack. Es können nur neue Objekte angelegt werden. Eine std::list legt auch neue Objekte an, und zwar über einen Allocator. Denn kann man selber angeben oder es wird der Defaultallocator verwendet, std::allocator . Dieser allokiert die neuen Elemente per new auf dem Heap.

Neo Gandar schrieb:

Wenn ich jetz "A *first = new A;" schreibe, wird dann die Variable in A, auf dem Heap oder dem Stack abgelegt? Wenn die auf dem Heap abgelegt wird dann kann ich mir doch eigentlich den mehr Aufwand mit Zeigern sparen.

Ja, die Variable kommt auch auf den Heap. Und ja, du kannst dir die Zeiger sparen, unbedingt!

Grüssli

Warum überhaupt so viele Variablen? Würde man das Ganze ein wenig sinnvoll kapseln, käme man nur noch auf vereinzelte Member pro Klasse. Also überlege dir, welche Variablen logisch zusammengefasst werden können, und lagere diese aus.

Ja, die Variable kommt auch auf den Heap. Und ja, du kannst dir die Zeiger sparen, unbedingt!

Also das, worauf der Zeiger zeigt befindet sich auf dem "Heap", aber der Zeiger selbst befindet sich auf dem "Stack". (ich schreibe das in Anführgungszeichen, weil ja eher dynamisch und automatisch gemeint ist, aber das mal ausser Acht gelassen.)

Ja, die Variable kommt auch auf den Heap. Und ja, du kannst dir die Zeiger sparen, unbedingt!

Also das, worauf der Zeiger zeigt befindet sich auf dem "Heap", aber der Zeiger selbst befindet sich auf dem "Stack". (ich schreibe das in Anführgungszeichen, weil ja eher dynamisch und automatisch gemeint ist, aber das mal ausser Acht gelassen.)

Er redet aber nicht vom Zeiger, sondern von der Variable in A. Keine Ahnung, wie du auf den Zeiger kommst. Vielleicht weil du so viele Zeiger gesehen hast?

Grüssli

A *first = new A;

A ist hier keine Variable und kein Zeiger, sondern ein Typ. :p

Dann bist du aber ein Erbsenzähler! :p

Grüssli

bei

class A{
private:
int a;
...
}; 	

A *first = new A;

*first befindet sich auf dem Stack, und zeigt auf das Object A, das sich im Heap befindet. Und somit ist die Variable a auch im Heap.

wenn ich jetz eine Liste erstelle

list<A> *Liste = new list<A>;

Dann befindet sich *Liste auf dem Stack, und zeigt auf die list im Heap.
Dadurch befinden sich, auch alle anderen Objekte und deren Zeiger, die in die Liste eingefügt werden im Heap.

Also ist das Einzige was dabei im Stack abgelegt wird *Liste, der rest kommt in den Heap. Oder?

Weil wär nicht so passend wenn die Zeiger für 100.000 Objekte, die in der Liste sind, auf dem Stack gespeichert werden

Dadurch befinden sich, auch alle anderen Objekte und deren Zeiger, die in die Liste eingefügt werden im Heap.

Gespeichert werden die Objekte in std::list und den meisten anderen Containern ebenfalls auf dynamisch (heap). Das ist ja der Sinn davon. Eine dynamische Menge an Objekten zu verwalten. Wenn du da dann mit eigenem new Zeugs kommst ist die ganze Übung umsonst und hättest alles von vorne selbst machen können.

@Nexus & Dravere:
Ihr seit doch beide Kindsköpfe. :p

Schau auch ruhig nochmals meinen vorherigen Beitrag an und probier es aus:
http://www.c-plusplus.net/forum/viewtopic-var-p-is-1719623.html#1719623

Oder probier als Übung mal eine Double-Linked-List zu implementieren

@drakon,
So bleibt man jung

Grüssli

Muss jetz aber einen großteil des Programmes umschreiben, ich meld mich also wieder wenn das erledigt ist. Vermute aber, das ich irgendwo schlampig gerarbeitet hab, und dadurch der Fehler verursacht wird.

Hab die Klasse jetz aufgeteilt, und die erste Klasse fertig. Die Zweite sieht dann vom Aufbau her gleich aus.

Hier die data.h:

#ifndef _data_h
#define _data_h

#include <string>

using namespace std;

//Daten, die vom Programm erzeugt/ergänzt werden

class Data{

private:
	string itemName;
	string locationName;
	long long quantity;
	long long soll;
	long long difference;
	string groupID;
	string group;
	string categoryID;
	string category;

	bool adjusted;

public:
	Data();
	Data(const Data &base);	

	Data & operator = (Data const &base){
		string temp(base.itemName);
		temp.swap(this->itemName);

		temp = base.locationName;
		temp.swap(this->locationName);

		temp = base.groupID;
		temp.swap(this->groupID);

		temp = base.group;
		temp.swap(this->group);

		temp = base.categoryID;
		temp.swap(this->categoryID);

		temp = base.category;
		temp.swap(this->category);

		this->quantity = base.quantity;
		this->soll = base.soll;
		this->difference = base.difference;

		return *this;
	};
//Weitere Methoden
};

Und hier die data.cpp:

#ifndef _data_cpp
#define _data_cpp

#include <string>

#include "data.h"

using namespace std;

/* Variablen der Klasse Data:
    string itemName;
	string locationName;
	long long quantity;
	long long soll;
	long long difference;
	string groupID;
	string group;
	string categoryID;
	string category;

	bool adjusted;

*/

Data::Data(){
	itemName = "";
	locationName = "";
	quantity = 0;
	soll = 0;
	difference = 0;
	groupID = "";
	group = "";
	categoryID = "";
	category = "";
	adjusted = false;
};

Data::Data(const Data &base) 
		: itemName(base.itemName),
		locationName(base.locationName),
		quantity(base.quantity),
		soll(base.soll),
		difference(base.difference),
		groupID(base.groupID),
		group(base.group),
		categoryID(base.categoryID),
		category(base.category),
		adjusted(base.adjusted) {};

//Weitere Methoden

#endif

Hab versucht eure Vorschläge/Verbesserungen umzusetzten und hoffe dass das so jetzt auch passt

Grüße

Und warum benutzt du im default ctor die Initialisierungsliste nicht, wo du sie doch im copy-ctor benutzt?!

#ifndef _data_h
#define _data_h

Makros werden eigtl groß geschrieben und (dann) am Anfang auch keine Unterstruiche enthalten - außerdem fehlt hier das #endif...

using namespace std;
Sollte man nie im Header stehen haben!
In der Source-Date (*.cpp) ist es aber in Ordnung - lediglich noch Geschmackssache ^^

Data & operator = (Data const &base){
		string temp(base.itemName);
		temp.swap(this->itemName);

base ist nen komischer name : D
Außerdem implementiert man den op= eigtl durch Copy&Swap:

Data& operator= (Data const &rhs)
{
 Data to_swap(rhs);
 swap(to_swap);
 return *this;
}

und wenn du es schon unbedingt so lassen möchtest, dann lass bitte das this-> weg - das führt ja zu Augenkrebs

string itemName;
	string locationName;
	long long quantity;
	long long soll;
	long long difference;
	string groupID;
	string group;
	string categoryID;
	string category;

	bool adjusted;

So viele Member-Variablen sind meist ein Indiz dafür, dass man die Klasse noch weiter aufsplitten sollte....
Außerdem: Warum IDs als string speicher?
Und warum alles englisch außer "soll"? : D

#ifndef _data_cpp
#define _data_cpp

Ähmm.. Nein? Die Source-Datei braucht keine Include-Guards... Hier gabs vor kurzem auch nen Thread, wo wir ein wenig erklärt haben, wie das mit den Source-Dateien ist (in Kurzform: werden von der IDE automatisch kompiliert - genau einmal und die *.h wird immer nur included, wenn iwas benötigt wird - und genau deshalb wird sie nur einmal geparst und braucht deshalb keine Include-Guards... Die würden btw auch nichts bringen, wenn du die *.cpp iwo includen würdest ^^

/* Variablen der Klasse Data:
    string itemName;
	string locationName;
	long long quantity;
	long long soll;
	long long difference;
	string groupID;
	string group;
	string categoryID;
	string category;

	bool adjusted;
*/

Nette Idee - aber eigtl überflüssig und vor allem umständlich

Data::Data(){
	itemName = "";
	locationName = "";
	quantity = 0;
	soll = 0;
	difference = 0;
	groupID = "";
	group = "";
	categoryID = "";
	category = "";
	adjusted = false;
};

-> Initialisierungsliste
Bei mir würde das so aussehen:

Data::Data()
:  quantity(0), soll(0), difference(0), adjusted(false)
{}

Japp, das reicht - mehr brauchst du nicht hinzuschreiben...
Der Standard-CTor von std::string liefert ja (logischerweise) nen leeren String... ^^

Data::Data(const Data &base) //wieder nen komischer Name ^^
		: itemName(base.itemName),
		locationName(base.locationName),
		/*...*/
		category(base.category),
		adjusted(base.adjusted) //ich würde nur ein Tab einrücken ^^
{}; //';' ist überflüssig

bb

außerdem fehlt hier das #endif...

Habs nur nicht mitkopert, da ich die ganzen Methoden nicht mitkopieren wollte ^^ habs übersehen dass es hier im Post fehlt.

Außerdem: Warum IDs als string speicher?

Weil die IDs sowieso nur als Vergleich zwischen verschiedenen Objekten dienen und ich diese aus ner Datei als string einlese, und mir die Typenumwandlung sparen wollte ^^.

Und warum alles englisch außer "soll"? : D

Weil mir, als ich damals das erste mal diese Klasse erstellt habe, der englische Begriff für "Sollwert" ned eingefallen ist ^^ und sieht ja nacher im Programm eh keiner

So viele Member-Variablen sind meist ein Indiz dafür, dass man die Klasse noch weiter aufsplitten sollte....

Man könnte die ganzen Variablen auch mit ner struc lösen, jedoch nutze ich den vorteil von Klassen, um über Polymorphie über die gleiche Methode nen string in eine long long variable umzuwandeln usw.

Warum ich das weiter aufteilen soll geht mir nicht ein, da die Methoden ja wirklich nur max. 4 Zeilen lang sind, und sich der Aufwand durch mehrere Klassen ja nur erhöht.

Warum schiebst du bei deinem operator = alles zuerst in einen temporären String?
Du kannst alles direkt swappen und dann machst du einfach eine Kopie des gesamten Objektes (unter Benutzung des copy-ctor).
Und rufst dann swap auf.

Hab mir das aus dem Link auf der ersten Seite abgeschaut, dass das auch mit dem ganzen Objekt geht wusste ich ned.

Zum using Namespace std; :
Das ganze Prog ist eigentlich in dem Namespace, und da ich nicht einbinde das nen anderen Namensraum hat, geht es doch so schneller oder? Oder lauf ich dadurch irgendwie in Gefahr?

Hab die Klasse mal geändert:

data.h

#ifndef DATA_H
#define DATA_H

#include <string>

using namespace std;

//Daten, die vom Programm erzeugt/ergänzt werden

class Data{

private:
	string itemName;
	string locationName;
	long long quantity;
	long long soll;
	long long difference;
	string groupID;
	string group;
	string categoryID;
	string category;

	bool adjusted;

public:
	Data();
	Data(const Data &rhs);	

	Data& operator= (Data const &rhs){
		Data to_swap(rhs);
		swap(to_swap, *this);
		return *this;
	} 
        //jede menge Methoden
};
#endif

data.cpp:

#include <string>
#include "data.h"

using namespace std;

Data::Data()
:	quantity(0),soll(0),difference(0),adjusted(false)
{}

Data::Data(const Data &rhs) 
	: itemName(rhs.itemName),
	locationName(rhs.locationName),
	quantity(rhs.quantity),
	soll(rhs.soll),
	difference(rhs.difference),
	groupID(rhs.groupID),
	group(rhs.group),
	categoryID(rhs.categoryID),
	category(rhs.category),
	adjusted(rhs.adjusted) {}

//Jede Menge Methoden

void Data::swap(Data& other)
{
    std::swap(itemName, other.itemName);
    std::swap(quantity, other.quantity);
    // ...
}

Zudem kannst du noch ein globales swap() für deine Klasse anbieten. Ist zwar etwas Schreibaufwand, aber es ist gut, sich solche Dinge anzugewöhnen, auch später wegen Exceptionsicherheit. Dein Zuweisungsoperator könnte dann so aussehen:

Data& operator= (const Data& other)
{
    Data(other).swap(*this);
    return *this;
}

Brauchst du eigentlich long long ? Dieser Typ ist nicht im C++-Standard enthalten. In den meisten Fällen reichen eigentlich int bzw. long . Und IDs würde ich auch eher als Zahlen speichern...

Zum using namespace std; - ich würde mir generell abgewöhnen, using namespace in Headerdateien zu verwenden. Dadurch wird der gesamte Namensraum in allen inkludierenden Dateien ausgeschüttet, was nicht immer erwünscht ist. Die paar std:: sollten wohl noch drin liegen, soviel Aufwand ist das nicht. Ich gebe bei mir den Namensraum eigentlich immer an, auch in lokalen Funktionen.

Warum long long. Es kommt vor, dass die Zahlen bis zu einigen Milliarden groß sind (größte was ich gefunden hab waren ~150 Mrd), und das ist zuviel für ne normale long, da diese dann den Bereich überschreitet.

Warum long long. Es kommt vor, dass die Zahlen bis zu einigen Milliarden groß sind (größte was ich gefunden hab waren ~150 Mrd), und das ist zuviel für ne normale long, da diese dann den Bereich überschreitet.

Ah, dann ist es okay. Ich hatte nur irgendwie das Gefühl, du hättest mal vorsorglich grosse Typen genommen.

Du solltest dir einfach im Hinterkopf behalten, dass mit long long nicht mehr ganz standardkonform bist, solltest du zum Beispiel mal eine Portierung oder Ähnliches vorsehen.