Discussion :

[Mindiell]

Bonsoir,

Souhaitant utiliser une classe (mais on pourrait imaginer un type, ou une srtucture personellee aussi) dans un vector, que me faut-il au minimum pour que le vector (et après tout les list, queue, et autres map aussi) l'accepte ?

Je pense par exemple aux constructeur et destructeur (pas obligatoire à priori), mais pour la comparaison et d'autres trucs.

En gros, quel est le minima pour pouvoir utiliser ca avec la STL ?

Merci,

[roulious]

Il faut qu'on puisse assigner une valeur à l'élément, cf. http://www.sgi.com/tech/stl/Assignable.html pour les conteneurs. Pour les set et les maps, il faut aussi que tu définisses un critère de tri pour le type de la clé.

[koala01]

Salut,

Bien que toute la réponse se trouve dans celle de roulious, je me contenterai d'apporter quelque précisions:

On parle souvent des "grands trois" ou des "grands quatre", qui sont, fatalement nécessaires:

• le constructeur "classique"
• le constructeur "par copie"
• l'opérateur d'affectation ( operator=(type&))
• le destructeur

On peut aussi signaler qu'il est plus simple (pour autant que faire se puisse) d'utiliser un objet dans les conteneurs plutot qu'un pointeur sur cet objet

Le code

Code :

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

1
2
3
4
5
 
std::vector<type> monvect;
monvect.push_back(objmtype())
//et plus loin
monvect.clear();

sera toujours plus facile à mettre au point que

Code :

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

1
2
3
4
5
6
7
 
std::vector<type*> monvect
monvect.push_back(new type())
//et plus loin
for (unsigned int i=0;i<monvect.size();i++)
    delete monvect[i];
monvect.clear();

Mais, évidemment, il faut que ce conseil, quelque peu tranché, soit applicable dans le cadre de ce que tu fais

Pour travailler avec les map et autres conteneurs triés, il est souvent intéressant de prévoir ce que l'on appelle un "predicat" permettant au minimum de savoir si un objet est "plus petit" qu'un autre.

Un prédicat compris "par défaut" est le prédicat "less" qui prend une forme du genre de

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
 
class maclass
{
    public:
       maclass();
       ~maclass();
       struct less
       {
           bool operator() (maclass& c1, maclass &c2)
           {
               return c1<c2;//à adapter, évidemment, en fonciton de la classe
           }
       }
    //la suite
};

D'autres opérateurs tels que:

• operator< (type&, type&)
• operator> (type&, type&)
• operator>= (type&, type&)
• operator<= (type&, type&)
• operator== (type&, type&)
• operator!= (type&, type&)
• et d'autres (opérateur de convertion, par exemple)

ne sont pas obligatoires, mais peuvent souvent s'avérer intéressant, en fonction du but recherché

[roulious]

On parle souvent des "grands trois" ou des "grands quatre", qui sont, fatalement nécessaires:

• le constructeur "classique"
• le constructeur "par copie"
• l'opérateur d'affectation ( operator=(type&))
• le destructeur

Ils ne sont pas forcément nécessaires. dans la mesure où ceux générés automatiquement font souvent l'affaire : si ton objet n'alloue pas de ressources à sa construction, à quoi sert un destructeur comportant juste un commentaire disant "rien à faire ici". Il en va de même pour le constructeur de copie et l'opérateur d'affectation. Si une shallow copy (je n'ai jamais croisé le terme français correspondant) suffit, autant se reposer sur le compilateur.

Pour travailler avec les map et autres conteneurs triés, il est souvent intéressant de prévoir ce que l'on appelle un "predicat" permettant au minimum de savoir si un objet est "plus petit" qu'un autre.

C'est plus qu'intéressant, c'est obligatoire, pour déclarer un conteneur trié, il faut donner le prédicat. Même si on n'en a pas l'impression, il est toujours présent, sous la forme d'un paramètre template qui vaut std::less<key_type> par défaut. Ca sera transparent pour les types de base et les std::string par exemple, mais si tu as besoin d'un set d'une classe que tu as défini, il faudra pouvoir lui donner un moyen de comparaison.

[koala01]

Je suis tout à fait d'accord que, si tu ne déclares pas de constructeur et/ou de destructeur, le compilateur en met des "par défaut"...

Si, de fait, on *peut* estimer "dans certains cas" qu'il ne sert pas à grand chose de les mettre, ca ne me dérange pourtant absolument pas de les déclarer et de les définir (quitte à ce que ce soit en "inline") systématiquement (meme si je m'appuies beaucoup sur les automatisations de mon EDI)...

Cependant, je juge personnellement plus prudent d'avoir un discours proche de

Pensez toujours à déclarer (et à définir) vos constructeurs, destructeurs et opérateurs d'affectation, y compris quand ce n'est pas "forcément indispensable"

plutot que d'avoir un discours du genre de

Il n'y aura que quelques cas où les constructeurs, destructeurs et opérateurs d'affectation fournis par le compilo ne seront pas adaptés, et il faudra alors envisager de les déclarer et de les définir...

La raison en est simple:

Dans le premier cas, on dit "faites le toujours, meme si cela ne sert à rien (ou à pas grand chose)", alors que dans le second on commence par dire "ne le faites pas"...

Le résultat final est que, dans le premier cas, on sera toujours dans le bon, alors que dans le second cas, on courre le risque, justement, d'être dans l'erreur (parce que l'un de ces constructeur/destructeur/opérateur d'affectation est, justement, dans un cas particulier, indispensable)...

Ce n'est jamais que le fait de faire prendre les habitudes les meilleures possibles à ceux qui nous demandent conseil

[Mindiell]

Merci à tous,

Je n'en attendais pas tant !
Ma liste sera bien par objet direct, pas par pointeur sur ma classe. Utilisant un vector, je vais implémenter les 4 trucs de base :
- Constructeur
- Destructeur
- Operateur =
- Constructeur par copie

Ma classe comporte elle-même une ou plusieurs listes( pas encore sur ) et d'autres petites choses.

A propos, il serait peut-être intéressant, une fois que vous êtes d'accord sur la réponse finale (constructeur, destructuer, etc... ) , de rajouter ca dans la FAQ, non ?

[loufoque]

Les conteneurs non triés nécessitent uniquement que le type soit CopyConstructible et Assignable.
Ce qui est le cas par défaut, car le compilateur génére automatiquement un constructeur de recopie et un opérateur d'affectation.
Il ne faut le réécrire que quand c'est nécessaire.

[zais_ethael]

Dans certains cas d'utilisation je suppose qu'il faut aussi un constructeur par défaut. Exemple:

Code :

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

vector<machin> vec(5);

[Laurent Gomila]

Dans certains cas d'utilisation je suppose qu'il faut aussi un constructeur par défaut

Exact.

[Mindiell]

Si vous parlez de mon cas, je vais créer les 4 fonctions (constructeur, destructeur, recopie, et assignation). Car ma classe n'a pas d'ordre de grandeur.
Pour les constructeurs avec paramètres, j'en mettrais surement.

A ce propos, on est d'accord que, quel que soit le nombre de constructeurs, je n'ai toujours qu'un et un seul constructeur par copie ?

[koala01]

Si vous parlez de mon cas, je vais créer les 4 fonctions (constructeur, destructeur, recopie, et assignation). Car ma classe n'a pas d'ordre de grandeur.
Pour les constructeurs avec paramètres, j'en mettrais surement.

A ce propos, on est d'accord que, quel que soit le nombre de constructeurs, je n'ai toujours qu'un et un seul constructeur par copie ?

Bien sur, vu que chaque classe n'a, théoriquement, qu'une et une seule liste de membres.

A partir du moment où tu sais que pour la recopie, tu dois donner la valeur du membre A au membre A et celle du membre B au membre B, on voit mal comment il pourrait en etre autrement

Evidemment, comme il y a une exception en tout, les classes template peuvent etre considérées comme exception (vue que les membres ne sont connus qu'en fonction des types que l'on déclare dans le template)...

Mais ne dit-on pas que toute regle a une exception qui vient la confirmer

[Mindiell]

Dans certains cas d'utilisation je suppose qu'il faut aussi un constructeur par défaut. Exemple:

Code :

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

vector<machin> vec(5);

Tu attendrais quoi de ce genre de constructeur zais ?
plutôt un vecteur contenant 5 machins, ou un vecteur contenant un machin initialisé avec la valeur 5 ?

Je penche pour la première solution, mais on ne sait jamais

[zais_ethael]

Ce constructeur de la classe vector initialise la taille du vecteur avec des objets dont on va appeler automatiquement le constructeur par défaut.
C'est l'une des raisons qui fait qu'une classe sans constructeur par défaut est énervante à manipuler.

[Mindiell]

C'est, effectivement, une bonne idée
A priori, mon vector initialisera les classes une par une puisque leurs données proviendront d'un fichier (au final).
Tout comme Koala, je préfère mettre mes propres constructeurs/destructeurs plutôt que de les oublier en cas de besoin.

[zais_ethael]

Moi je préfère au contraire ne jamais avoir à en mettre, à grand coup de smart pointers, de vector pour les tableaux, de strings...
Ca a l'énorme avantage que si tu modifies ta classe tu n'a pas à penser à modifier ton destructeur et ton opérateur de copie (ce qu'on oublie facilement), qui plus est c'est moins long.

[Mindiell]

zais, j'ai réussi à créer ma classe, et je peux utiliser proprement la construction par défaut :

Code :

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

vector<cRoom> v(5);

Par contre, on est bien d'accord que ma classe ne peut pas prévoir l'utilisation de v[5] ou v[6543]. Parce qu'en essayant ca, le compilo ne me dit rien et l'affichage ne correspond logiquement à pas grand chose

Pour le reste de mon projet, je vais l'avancer et si j'ai des questions objet, je reviendrais sur ce coin de forum : Merci à tous

[zais_ethael]

Ben si c'est prévu.
Si tu demandes un objet se trouvant en dehors des limites du tableau tu as droit à une lancée d'exception, mais tu ne la captes peut-être pas correctement (donc tu n'affiche pas le message d'erreur).