Wenn ich jetzt ein zuvor angelegtes Objekt dieser Klasse lösche
muss ich dann in der Kasse einen Destruktor einbauen,

der mittels erase() alle elemente einzeln aus dem vektor löscht?

int a[10];

Hier reicht der Standartdestructor der einfach alles freigibt.
Hast du jedoch einen Zeiger auf int und erstellst das Array mit new[] dann mußt du einen Destructor Basteln der über delete[] den Speicher freigibt.
Bsp:

int *a;
Konstruktor(int größe)
{
a=new int[größe]
}
~Destructor()
{
delete[] a;
}

Wenn du einen std::vector hast, brauchst du nix in den D'tor schreiben.

chrische

Wenn du einen std::vector hast, brauchst du nix in den D'tor schreiben.

Gilt aber auch nur, wenn man z.B. einen std::vector<Foo> hat und nicht einen std::vector<Foo*>, bei dem jedem Element mit new Speicher zugewiesen wurde. Den muss man schon vorher auch killen.

MfG

GPC

Klar, aber er schrieb, dass er einen vector mit ints hat. Meine Aussage war aber wirklich zu allgemein.

chrische

class A1{

 User* u1;

 private: 
 vector<User> liste;

 public:
 A1();
}

A1::A1(){

 u1 = new User(a,b,c); 
 liste.push_back(*u1);

 u1 = new User(d,e,f); 
 liste.push_back(*u1);

 u1 = new User(g,h,i); 
 liste.push_back(*u1);

 usw..

}

Wenn ich jetzt in Klasse B ein objekt von A Anlege nud es wieder lösche
brauche ich dann einen Desrutktor in A der den Vektor durchgeht und löscht?

Diese Codesequenz:

u1 = new User(a,b,c); 
 liste.push_back(*u1);

 u1 = new User(d,e,f);

erzeugt einen Memory-leak unabhängig davon, ob er im Konstruktor steht oder woanders.

Du erzeugst dynamisch eine Instanz der Klasse User. Den Zeiger darauf speicherst Du in einer Variablen u1. Mit diesem push_back steckst Du eine Instand der Klasse User in den Vektor, indem Du deinen Zeiger dereferenzierst. Der Compiler ruft daraufhin den Copy-Konstruktor von User auf, um eine Instanz von User zu erzeugen. Du hast also jetzt 2 Instanzen der Klasse User: einen im Vektor und einen, den du mit dem Zeiger referenzierst. Als nächstes überschreibst Du den Wert des Zeigers u1. Damit verlierst Du die Möglichkeit, deine dynamisch angelegte Instanz zu referenzieren, um sie beispielsweise mit delete frei zu geben.

Ein kleinere Unschönheit ist, daß Du die Variable u1 als Klassenvariable, statt als lokale Variable definierst.

Also besser wäre:

class A1
{
    vector<User> liste;

  public:
    A1();
};

A1::A1(){

 liste.push_back(User(a,b,c));
 liste.push_back(User(d,e,f));
 liste.push_back(User(g,h,i));

 usw..

}

Sieht auch viel kompakter aus und es kommen keine Zeiger mehr vor.

Die Moral von der Geschichte ist, daß man Zeiger nicht verwenden sollte, wenn sie denn nicht unbedingt notwendig sind (was relativ selten der Fall ist).

Tntnet