3. Frage zur Funktion List.push_back()

Frage zur Funktion List.push_back()

  • N

    Hallo,

    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.

    0
  • Administrator

    push_back speichert eine Kopie im Vektor ab. Das Problem liegt hier nicht bei der push_back Methode, sondern bei deiner Klasse var .

    Ü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?

    0
  • N

    Das ist nur ein extrem vereinfachter Ausschnitt von einem Programm an dem ich grad arbeite. Wollte hier keine 600 Zeilen Code posten.

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

    Danke schonmal.

    0
  • U

    das hier bleibt allerdings:
    list<var> *varlist = new list<var>;
    wieso nicht auf den stack packen?

    bb

    0
  • N

    Entschuldigung für die Verspätete Antwort, aber hatte erst jetzt Zeit mich darum zu kümmern.

    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 😞

    0
  • D

    😮

    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.

    0
  • N

    😃 Dacht mir schon dass es so schlimm ausieht wie es ist.

    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?

    0
  • Administrator

    Neo Gandar schrieb:

    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

    0
  • N

    😮 triffts ziemlich gut...

    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.

    0
  • D

    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.)

    0
  • Administrator

    drakon schrieb:

    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

    0
  • N

    Ihr habt beide Unrecht. 😃

    A *first = new A;

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

    0
  • Administrator

    @Nexus,
    Dann sage mir, wie Neo Gandar es richtig hätte formulieren sollen. Womöglich:
    "Wohin kommt die Variable im Objekt vom Typ A?"

    Dann bist du aber ein Erbsenzähler! :p

    Grüssli

    0
  • N

    oook 🙂 hab ich das also richtig verstanden:

    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 🙂

    0
  • D

    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

    0
  • Administrator

    @Neo Gandar,
    Alles korrekt bis auf den Teil, welcher drakon zitiert hat. Die Schlussfolgerung stimmt da nicht. Die Elemente liegen dort nicht auf dem Heap, weil du die Liste auf dem Heap gesetzt hast. Die Elemente in einer Liste haben nichts gemeinsames mit Membervariablen.

    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

    0
  • N

    Ok, glaub jetz hab ich verstanden 🙂 Hab dein Beispiel auf mit deque probiert 🙂

    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.

    0
  • N

    So, hab mich entschieden das Programm als Grundlage für ein neues zu nehmen da ich viel zu viele Fehler beim schreiben des Codes gemacht habe.

    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

    0
  • D

    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.

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

    0
  • U

    Naja - ich find vieles nich so dolle - nen bissl was davon zähl ich hier mal auf:

    #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

    0
  • N

    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
    0
Anmelden zum Antworten