Discussion :

[Vitamind]

Bonjour,
Je voudrais savoir comment fait-on pour allouer et désallouer un tableau d'objet dynamique dans lesquels il y a un autre tableau d'objet dynamique aussi, sans utiliser la STL.

J'ai fais ça comme déclaration de classe:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class a {
 blablabla;
 
public:
 a();
 ~a();
}
 
class b {
 a **tab;
 blabla;
 
public:
 b();
 ~b();
}
 
class c {
 b **tab2;
 blabla;
 
public:
 c();
 ~c()
}

Merci

[Bousk]

Salut,

euh operator new et operator new[] et leurs pendants pour la libération operator delete et operator delete[] ?

[Vitamind]

Haha oui je sais Mais ce que je voulais dire c'est que j'ai fais un programme mais j'ai des erreurs segmentations partout du coup, je me tourne vers vous pour savoir comment faire:
Par exemple pour reallouer tab2; j'ai fais:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
 b** tab_aux = new b*[taille+1];
 for (int i=0; i<taille; i++)
 {
	tab_aux[i]=tab2[i];
 }
 
	 tab2= new b*[10];		        
 for (int i=0; i<taille; i++)		
	 {					
		tab2[i]=new Espace();		
	 }					
	 for (int i=0; i<taille; i++)		
	 {					
		delete tab2[i];			
	 }					
	 delete[] tab2;				
 
	 for (int i=0; i<taille; i++)		
 	 {					
		tab2[i]=tab_aux[i];		
 	 }					
 
	 tab2[taille]= new b ();

Pour désalouer tab2:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
 for (int i=0; i<taille; i++) 
 {
	delete tab2[i];
 }

Sauf qu'après quand j'essaye de manipuler tab, j'ai des erreurs segmentations de partout..

[dalfab]

Salut,
Et tu utilises ces opérateurs dans les constructeurs et destructeurs de ta classe pour la table et dans le cas de tableau de pointeurs, le contenant assure la création et la destruction des éléments

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class b {
 a **tab; // tableau de pointeurs (b alloue le tableau et initialise ou alloue les pointeurs)
 blabla;
 
public:
 b()   { tab = new (a*)[10]; for ( int i=0; i <10; ++i ) tab[i] = new a; }
 ~b()  { detruireElements(); }
 void detruireElements()  { if ( tab ) for ( int i=0; i <10; ++i ) delete tab[i];  delete[] tab; }
   // et ici il devient impératif de définir ou interdire au moins les copies
   b( const b& x ) = delete; // création par copie interdite par exemple
   b& operator=( const b& x ) {
     if ( &x != this ) {          // l'opérateur de copie, peut par exemple
        // détruire les éléments de *this
        // allouer this->tab et les éléments de this->tab[]
        // copier les éléments de x.tab[] dans this->tab[]
     } 
     return *this;
   }
// et on peut aussi facultativement optimiser les opérations de transfert
   b( b&& x ) : tab(x.tab) { x.tab=0; }
   b& operator=( b&& x ) {
      detruireElements();
      tab = x.tab;
      x.tab = 0;
      return *this;
   }
};

[ternel]

La clé de la sécurité, en C++, c'est RAII.
Ce principe consiste à encapsuler une ressource dans une classe, de façon à l'acquérir dans le constructeur et la libérer dans le destructeur.
Cela permet de garantir que cette ressource est libérée une et une seule fois.

C'est précisément ce que font std::vector (sur un tableau dynamique), std::fstream (sur un FILE*), std::unique_ptr (sur un pointeur obtenu via new), etc.

Et dalfab, ton détruire_éléments est faux, puisqu'il teste le pointeur, mais ne le mets pas à nullptr.

[dalfab]

Et dalfab, ton détruire_éléments est faux, puisqu'il teste le pointeur, mais ne le mets pas à nullptr.

Oui, en effet, un pointeur libéré doit être impérativement remis à zéro. Ainsi dans mon exemple une exception entre les lignes 22 et 23 provoquerait un beau gâchis.