Discussion :

[gountick]

Bonjour,

Je suis étudiant et je dois rendre bientôt un travail en c++.

Notre prof veut absolument que chaque classe soit équipée d'un destructeur, constructeur par recopie et d'une surdéfinition d'opérateur d'affectation (même s'ils ne sont pas nécessaires)

Je connais leur utilité quand une des variables membres est un pointeur mais dans mon cas les membres que ma classe possède sont 2 variables string (on s'en fout) ET un deque de pointeur d'objet.

Code Acteur.h :

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
#ifndef __ACTEUR_INCLUS__
#define __ACTEUR_INCLUS__
 
#include "Film.h"
#include <deque>
 
class Acteur{
private:
	string nom;
	string prenom;
	deque<Film*> listFilms;
public:
        Acteur(string,string);
	Acteur(const Acteur &);
	~Acteur();
        Acteur & operator= (const Acteur &);
//...
};
#endif

Un destructeur, un constructeur de recopie et une surdéfinition d'opérateur d'affection sont-ils utiles dans ce cas-ci ?

Si oui, comment les implémenter ?
Si non, dois-je laisser ces méthodes vides ?

Merci beaucoup

[JolyLoic]

Notre prof veut absolument que chaque classe soit équipée d'un destructeur, constructeur par recopie et d'une surdéfinition d'opérateur d'affectation (même s'ils ne sont pas nécessaires)

Telle que cette phrase est formulée, je trouve cette règle idiote. Mais le reste du post me laisse à penser que la contrainte est plutôt : Il faut les définir s'ils sont utiles, même s'ils ne sont pas utilisés à l'instant t par le programme client de la classe.

En général, j'ai trois sortes de classes :
- Celles où les opérateurs définis par défaut font tout ce qu'il faut comme il le faut, et où je n'ai rien à faire,
- Celles où je veux empêcher la copie, et pour lesquels je les déclare en private (sauf le destructeur, bien sur),
- Celle où je définis mes constructeurs de recopie/opérateur=.

Le dernier cas est de loin le plus rare, et je le réserve à des classes bas niveau.

Je connais leur utilité quand une des variables membres est un pointeur mais dans mon cas les membres que ma classe possède sont 2 variables string (on s'en fout) ET un deque de pointeur d'objet.

Code Acteur.h :

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
#ifndef __ACTEUR_INCLUS__
#define __ACTEUR_INCLUS__
 
#include "Film.h"
#include <deque>
 
class Acteur{
private:
	string nom;
	string prenom;
	deque<Film*> listFilms;
public:
        Acteur(string,string);
	Acteur(const Acteur &);
	~Acteur();
        Acteur & operator= (const Acteur &);
//...
};
#endif

Un destructeur, un constructeur de recopie et une surdéfinition d'opérateur d'affection sont-ils utiles dans ce cas-ci ?

On n'en sait rien en lisant uniquement la classe. La question à se poser est : Qui est responsable des films ?
Si par exemple ceux-ci sont placés dans une autre collection, qui en est propriétaire et qui a une durée de vie plus longue que celle des acteurs, ceux-ci faisant uniquement référence aux films, il n'y a besoin de rien.

Si ceux ci sont gérés par les acteurs eux-même, et éventuellement d'autres objets, de manière partagée (un film disparaissant dès qu'il n'y a plus personne qui le référence), utiliser un deque<shared_ptr<film> > et ne pas avoir de constructeur par recopie me semblerait pertinent.

[smashy]

note etant donne que tu definis un constructeur type Acteur(string,string) , il va bien falloir faire a la main le constructeur par copie car:

-par defaut de constructeur, le compilateur fourni un constructeur par defaut et un par copie tous deux publiques et implicites

-du moment ou tu defini un constructeur (n importe lequel) le compilateur ne te les fournis plus.

donc tu va avoir quelque chose comme:

Acteur(){}

Acteur(const string & a,const string & b) : nom(a) , prenom(b) {}

Acteur(const Acteur & a) : nom(a.nom) , prenom(a.prenom){}

note:

tu a ecris un constructeur Acteur(string,string). Mieux vaut passer des references constantes sur les string car quand ils sont poses sur la pile au moment de l'appel, il y a RECOPIE d un objet non trivial donc ALLOCATION memoire inutile

[Jean-Marc.Bourguet]

-du moment ou tu defini un constructeur (n importe lequel) le compilateur ne te les fournis plus.

Le constructeur de copie continue a etre fourni tant que les membres ou les classes de base ne l'empechent pas (par exemple parce qu'il y a un membre reference ou qu'une classe de base a le constructeur de copie prive), meme si un autre constructeur est declare explicitement.

[smashy]

Le constructeur de copie continue a etre fourni tant que les membres ou les classes de base ne l'empechent pas (par exemple parce qu'il y a un membre reference ou qu'une classe de base a le constructeur de copie prive), meme si un autre constructeur est declare explicitement.

Je n'ai pas de compilateur sous la main pour verifier , mais a priori je reste sur ma position (je verais ce soir chez moi)

[Jean-Marc.Bourguet]

Je n'ai pas de compilateur sous la main pour verifier , mais a priori je reste sur ma position (je verais ce soir chez moi)

12.8/4 est clair

If the class definition does not explicitly declare a copy constructor, one is declared implicitly.

Au fait, quand tu as acces au web, tu as acces a un compilateur pour verifier. Et pour

Code :

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

1
2
3
4
5
6
7
8
9
10
struct s {
   s(int);
};
 
void f() {
  s s1(1);
  s s2(s1);
  s s3(2);
  s3 = s3;
}

il me dit:

Code Text :

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

1
2
3
4
5
6
Comeau C/C++ 4.3.9 (Mar 27 2007 17:24:47) for ONLINE_EVALUATION_BETA1
Copyright 1988-2007 Comeau Computing.  All rights reserved.
MODE:strict errors C++ C++0x_extensions
 
"ComeauTest.c", line 7: warning: variable "s2" was declared but never referenced
    s s2(s1);

[gountick]

On n'en sait rien en lisant uniquement la classe. La question à se poser est : Qui est responsable des films ?

Dans ce cas-ci la classe Acteur est utilisée par la classe Film qui est à peu près similaire. Dans la classe Film il y a un

Code :

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

deque<Acteur*> listActeurs;

Donc voilà je voulais savoir si dans une classe où il y a un deque de pointeurs d'objets c'est nécessaire de faire un destrcuteur, contructeur par recopie et surdéfinition d'opérateur d'affectation comme ce l'est quand notre classe possède un membre tableau par exemple ?

Ou si ceux par défauts sont suffisants dans ce cas-ci ?

[loufoque]

Ou si ceux par défauts sont suffisants dans ce cas-ci ?

Tu insères tes éléments dans tes deque avec des new ?
Alors oui, il te faut un constructeur de recopie, un opérateur d'affectation, et un destructeur.

Tu n'as toujours pas dit qui était responsable de la durée de vie des Films, en fait.
C'est comme ça qu'il faut raisonner, en terme d'ownership.

A priori, je dirais que pour ton système il faudrait une "base de données" qui contient les acteurs et les films, et que donc ta liste de films pour chaque acteur ne fait que référencer les films dans lesquels il a joué.
Sauf que bon dans ce cas, il serait peut-être plus propre de ne pas mettre des pointeurs mais un identifiant de film, pour permettre éventuellement au conteneurs de films et d'acteurs de changer de taille.

[gountick]

Non mais en fait, c'est juste un petit exercice, il n'est pas question ici de rendre les données persistantes.

Je voulais juste savoir si le deque gère lui même le constructeur de recopie ou si je dois mettre dans cette classe un constructeur de recopie qui recopie les objets de mon deque ?

Quand on a un tableau dans une classe, on utilise un constructeur de recopie pour recopier chaque éléments du tableau, dois-je faire pareil quand j'ai un deque ?

[Laurent Gomila]

Je voulais juste savoir si le deque gère lui même le constructeur de recopie ou si je dois mettre dans cette classe un constructeur de recopie qui recopie les objets de mon deque ?

std::deque a un constructeur par copie bien défini et qui fait ce qu'on attend de lui.

Quand on a un tableau dans une classe, on utilise un constructeur de recopie pour recopier chaque éléments du tableau, dois-je faire pareil quand j'ai un deque ?

Pas quand tu as un tableau. Quand tu as un pointeur et que tu veux recopier ce qu'il y a au bout plutôt que bêtement la valeur du pointeur.