Bonsoir ami(e)s devellopeur(se),

je rencontre quelques petit probleme quand a la destruction de mes objets.

j'ai trois classes A, B et C decritent ci dessous:

classA{
  public:
    A(){ tableau=newint[nb];}
    ~A()
  private:
    int* tableau;
};

classB{
  public:
    B(){ tableau=new A*[nb];}
    ~B()
  private:
    A**  tableau;
};

classC{
  public:
    C() { tableau=new B*[nb];}
    ~C()
  private:
    B** tableau;
};

A possede un tableau d'entier;
B possede un tableau de pointeur pointant sur des objet de type A
C possede un tableau de pointeur pointant sur des objet de type B

la création et la manipulation des mes objet se fait sans probleme celon mes souhaits.
cependant la destruction pose probleme;
j'ai essayé plein de façon differentes (en desespoir de cause) mais pas moyen de les detruire
en effet j ai une partie de mon programme qui resemble a ceci:

for(int i=0;i<NB;i++){
    C* toto=new C();
    for(int j=0;j<NB;j++){
        C* tata=newC();
        if(toto->fonction(tata)){
            //traitement
            delete tata;
            break;
        }
        delete tata;
    }
    delete toto;
}

le but de ce code est de conparer 2 à 2 tous les element d'un même ensemble (en s'arrétant au premier element répondant vrai au test (break) )
NB peut etre tres grand et donc comme je crée des objets a la volée il faut que je les detruise des que je n'en est plus besoins
sous peine de voir ma memoire saturée vitesse grand V;
et donc bien entendu je n'arrive pas a les detruires correctemnt ;

donc si quelqu un avait des destructeurs libérant bien la memoire aloué lors de la création de C (entrainant celles de B entrainant celles de A)  cela me sauverrai la vie!

merci a vous si vous avez deja pris la peine de lire ce post.

Mais c'est très simple, suffit d'isoler chaque classe et de détruire ce qu'elle a créée:

classA{
  public:
    A(){ tableau=newint[nb];}
    ~A(){ delete[] tableau; }
  private:
    int* tableau;
};

classB{
  public:
    B(){ tableau=new A*[nb];}
    ~B() { delete[] tableau; }
  private:
    A**  tableau;
};

classC{
  public:
    C() { tableau=new B*[nb];}
    ~C() { delete[] tableau; }
  private:
    B** tableau;
};

Quand tu créés un tableau de pointeur de B,  aucu object B n'est créé.

En fait, je crois que j'ai pas bien compris. Si toi tu initialises les pointeurs des tableaux que tu créés (et non la classe), c'est a toi de les détruire, pas a la classe.

class C {
  public:
    C() { tableau=new B*[nb];}
    ~C() { delete[] tableau; }
  private:
    B** tableau;
};


une fois le tableau du pointeur créé je crée mes objet B dans ma classe C

tableau[i]=new B(/*divers parametres*/)
 
est ce que delete [] tableau appellera le destructeur de mes B ou est ce que je doit les detruires
avec un destructeur du genre:

~C(){
    for(int i=0;i<nb;i++){
        delete tableau[i];
    }
    delete [] tableau;
}

??

C'est le but de delete[] d'appeler les destructeurs des objets du tableau alloué
par new ..[]
Tu n'as donc rien à faire que ce que t'as donné luthor.
( bon il rester les bugs de copie et d'assignation mais tu le découvriras plus tard ;) )

~C(){
    for(int i=0;i<nb;i++){
        delete tableau[i];
    }
    delete [] tableau;
}

NON ! :) car ce n'est pas la classe qui a créer les objets B de ta classe C. la classe  C n'a fait que créer un tableau de pointeur, donc ne détruit que ce tableau. Donc QUESTION: qui a créer les pointeurs du tableau ?

"est ce que delete [] tableau appellera le destructeur de mes B ou est ce que je doit les detruires
avec un destructeur du genre:" => surement pas, delete[] détruit le tableau de pointeur, mais pas les objets pointés par les pointeurs du tableau.

Pour vérifier que tous tes objets sont bien détruits, tu peux surchargé les opérateurs (mais c'est compliqué) ou deuxième solution très simple, tu ajoutes un compteurs static dans chaque classe:

classA{
  public:
    A(){ tableau=newint[nb]; reference_counter++; }
    ~A() { delete[] tableau; reference_counter--; }
  private:
    int* tableau;

static unsigned int reference_counter;
};

unsigned int A::reference_counter = 0;

Par contre, j'espère que tu n'utilise pas le constructeur de copie. Suffit de vérifier avant la fermeture du programme que (A::reference_counter == 0), auquel cas tous les objets ont bien été détruits.

Un ENORME MERCI à vous!!!
pendant que je tapais une autre question pour j'ai trouver d'ou venait ma fuite memoire.

encore 10000*merci;

oups, en effet, luthor, je me suis laissé aller.
delete[] appelle en effet les destructeurs des éléments du tableau (contrairement à malloc) mais le tableau contient des pointeurs, et le destruceur des pointeurs ne va pas appeler le destructeur des objets.

Fallait dormir plus tôt