Assignation et constructeur de copie

Marsh Posté le 09-09-2003 à 22:20:27

Bonjour,
J'aimerai avoir votre avis sur ceci:

Dans cette exemple, est-il possible d'éviter que l'assignation "E(T)" n'appel le constructeur de copie sans que E ne soit un pointeur?

Code :

template<class Type>
class Item {
public:
Type E;
Item<Elem>* down;
Item<Elem>* up;
Item (Type &T, Item<Elem>* tdown=NULL, Item<Elem>* tup=NULL): E(T)/**/, down(tdown), up(tup) {}
};

Reply

Marsh Posté le 09-09-2003 à 22:20:27

Reply

Marsh Posté le 09-09-2003 à 22:21:35

rien comrpis

Reply

Marsh Posté le 09-09-2003 à 22:48:58

non, si Type::Type(const Type& ) est défini, il sera appelé pour construire E; sinon ce sera une recopie champ à champ.

---------------
From now on, you will speak only when spoken to, and the first and last words out of your filthy sewers will be "Sir!"

Reply

Marsh Posté le 10-09-2003 à 02:53:12

En fait ce que je voudrai c'est :

Code :

template<class Type>
class Item {
public:
Type *E;
Item<Elem>* down;
Item<Elem>* up;
Item (Type *T, Item<Elem>* tdown=NULL, Item<Elem>* tup=NULL): E(T)/**/, down(tdown), up(tup) {}
};

E(T) n'appel pas le constructeur de copie étant donné que E(T) ne correspond qu'à une assignation d'adresse.
Ma question est de savoir si il existe une autre solution sans utiliser de pointeur?
Par exemple:

Code :

template<class Type>
class Item {
public:
Type &E;
....

Je n'ai jamais vu d'exemple utilisant une référence de cette manière, c'est pour ça que cela me perturbe.
Et comme mon programme bug quand je modifie E par &E, je me demande si ça vaut la peinne de debuger ou si c'est le style d'usage à proscrire et si dans ce cas, il y'a mieux à faire??

Reply

Marsh Posté le 10-09-2003 à 08:56:54

:heink:

Je vois pas ce que tu veux faire là. Tu peux tout à fait metre une référence et l'initialiser par E(val). Si non, si t'as un objet t'as forcément appel du constructeur de recopie vu que c comme ça que ça fonctionne dans le langage [:spamafote]

Message édité par LetoII le 10-09-2003 à 08:57:14

---------------
Le Tyran

Reply

Marsh Posté le 10-09-2003 à 09:04:25

E(new Type(*T)) :??:

Reply

Marsh Posté le 10-09-2003 à 09:08:36

Taz a écrit :

E(new Type(*T)) :??:

:heink: Et double appel du constructeur de recopie c ça? :whistle:

---------------
Le Tyran

Reply

Marsh Posté le 10-09-2003 à 09:13:05

ben non

Type(*T) -> recopie de *T
new Type(*T) -> recopie de *T avec allocation dynamqiue
E(new Type(*T)) -> initialisation

tu vas nous faire de plaisir de changer tes noms de types et de varaibles, par ce que par convention seuls les types ont des identificateur avec masjucule et les noms très courts en majuscule sont réservés aux paramètres templates

Reply

Marsh Posté le 10-09-2003 à 09:24:06

Taz a écrit :

ben non

Type(*T) -> recopie de *T
new Type(*T) -> recopie de *T avec allocation dynamqiue
E(new Type(*T)) -> initialisation

tu vas nous faire de plaisir de changer tes noms de types et de varaibles, par ce que par convention seuls les types ont des identificateur avec masjucule et les noms très courts en majuscule sont réservés aux paramètres templates

Ha oui merde, je suis pas encore bien réveiller moi [:ddr555]

---------------
Le Tyran

Reply

Marsh Posté le 10-09-2003 à 12:10:40

Merci à tous,
j'ai trouvé une solution,
je ne sais plus vraiment pourquoi hier cela me semblait suspect mais avec une réference ça marche très bien (je me retrouve avec quelques bugs en échange mais en tout cas le constructeur de recopie n'est plus appelé

Code :

[cpp]template<class Type>
class Item {
public:
Type &E;
Item<Elem>* down;
Item<Elem>* up;
Item (Type &T, Item<Elem>* tdown=NULL, Item<Elem>* tup=NULL): E(T)/**/, down(tdown), up(tup) {}
};

Désolé pour la perte de temps occasionné par cette bête question, mais hier cela me semblai un peu moins trivial :sweat:

merci aussi à Taz pour ces conseils sur les noms de variables, je ne me suis encore jamais vraiment intéresser au normes dans ce domaine, ce que je vais m'empresser de faire!
:bounce:

Reply

Marsh Posté le 10-09-2003 à 12:10:40

Reply

Marsh Posté le 10-09-2003 à 12:51:17

Peak a écrit :

Merci à tous,
j'ai trouvé une solution,
je ne sais plus vraiment pourquoi hier cela me semblait suspect mais avec une réference ça marche très bien (je me retrouve avec quelques bugs en échange mais en tout cas le constructeur de recopie n'est plus appelé

Code :

[cpp]template<class Type>
class Item {
public:
Type &E;
Item<Elem>* down;
Item<Elem>* up;
Item (Type &T, Item<Elem>* tdown=NULL, Item<Elem>* tup=NULL): E(T)/**/, down(tdown), up(tup) {}
};

Désolé pour la perte de temps occasionné par cette bête question, mais hier cela me semblai un peu moins trivial :sweat:

merci aussi à Taz pour ces conseils sur les noms de variables, je ne me suis encore jamais vraiment intéresser au normes dans ce domaine, ce que je vais m'empresser de faire!
:bounce:

oue je suis d accord

---------------

Reply

Assignation et constructeur de copie

Sujets relatifs:

Leave a Replay