Discussion :

[r0d]

Bonjour tout le monde,

prenons le bout de code suivant:

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
#include <set>
#include <iostream>
using namespace std;
 
struct Element
{
   Element(int n):num(n){cout<<"new"<<endl;}
   ~Element(){cout<<"delete"<<endl;}
   int num;
   bool operator < ( const Element & elt ) const { return ( num < elt.num ); }
};
 
int main()
{
   multiset<Element> theSet;
   cout << "--> insert" << endl;
   theSet.insert( Element(1) );
   cout << "--> clear" << endl;
   theSet.clear();
   cout << "--> termine" << endl;
   return 0;
}

La sortie est:

--> insert
new
delete
--> clear
delete
--> termine

Nous voyons donc que:
-> lors de l'insertion, le destructeur est appelé
-> on a, en tout, 1 new et 2 delete

Comprenez-vous ce qu'il se passe? Est-ce normal?

[JolyLoic]

A priori, rien de choquant... Quand on fait une classe instrumentée comme ça, ne pas oublier d'instrumenter aussi le constructeur de copie et l'opérateur=.

A priori :
Tu crée le temporaire => new
Il est copié dans le tableau => pas d'affichage
Puis est détruit => delete
Clear
La copie dans le tableau est détruite => delete

[r0d]

En effet, c'est bien cela. J'ai modifié mon code ainsi:

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
struct Element
{
   //constructeur
   Element(int n):num(n){cout<<"new"<<endl;} 
 
   // constructeur par copie
   Element( const Element & elt ) { cout<<"copy constr"<<endl;
      num = elt.num; } 
 
   // operateur d'affectation (je ne retourne rien, c'est voulu)
   void operator = ( const Element & elt ){ cout<<"operator ="<<endl;  
      num = elt.num; }; 
 
   // destructeur
   ~Element(){cout<<"delete"<<endl;}
 
   // operateur de comparaison
   bool operator < ( const Element & elt ) const { return ( num < elt.num ); }
 
   // donnee
   int num;
}

et effectivement, avec le même main, j'obtiens la sortie:

--> insert
new
copy constr
delete
--> clear
delete

Mais du coup, n'y a-t-il pas moyen d'éviter cette copie?

[JolyLoic]

Mais du coup, n'y a-t-il pas moyen d'éviter cette copie?

A part attendre C++0x (j'ai entendu dire que la prochaine version de gcc en implémentait une partie) ? Je ne pense pas. Mais je ne suis pas hyper à jour sur le sujet.