Assignation implicite : besoin d'explication

Bonjour,

j'ai fait une classe générique Number<T> pour avoir mes propres objets Double, Float, Integer, etc :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

template<typename T> class Number<T> { private: T _real; public: Number(T const&); Number(Number<T>const&); Number<T>& operator=(Number<T>const&); };

---

L'attribut _real permet de stocker la valeur du nombre. J'ai une question à propose de ce bout de code :

Code:

---

1 2 3

Number<double> a = 1.0; a = 2.0;

---

A la première ligne, il y a un appel implicite au premier constructeur de ma classe : je n'ai pas de problème avec ça. Par contre, je ne comprends pas pourquoi la seconde ligne fonctionne. Elle est importante car elle me permet ensuite de surcharger les opérateurs "+,-,*,/" de manière efficace (je suis aussi rapide que les opérations classiques en exploitant le tag -O3 de g++).

Voilà, si quelqu'un pourrait m'éclairer sur ce point et me dire si ce comportement est dans la norme ou si c'est propre à g++.

Merci

tu as un appelle implicite a ton premier constructeur afin de créer un Number<double>const depuis le double 2.0.

tu peux mettre des logs dans tes constructeurs pour voir ce qui ce passe:

Code:

---

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 28 29 30

template<typename T> class Number { private: T _real; public: Number(T const& n){ std::cout << "constructeur de base avec n = " << n << std::endl; _real = n; }   Number(Number<T>const& other){ std::cout << "constructeur de recopie avec other._real = " << other._real << std::endl; _real = other._real; }   Number<T>& operator=(Number<T>const&other){ std::cout << "op affect avec other._real = " << other._real << std::endl; _real = other._real; } };   int main(int argc, char* argv[]) { Number<double> a = 1.0; a = 2.0;   return 0; }

---

ce qui donne

Code:

---

1 2 3

constructeur de base avec n = 1 constructeur de base avec n = 2 operateur d'affectation avec other._real = 2

---

Bonjour,

merci pour ta réponse atttchoum.
Je vais vérifier.

Merci atttchoum c'était effectivement ce qui se passait!

Salut,
Dans ce cas, c'est l'objectif recherché, mais sinon tu as explicit qui permet d'éviter ces conversions implicites :explicit Number(T const&) qui génère ensuite une erreur lors des affectations.
Ceci dit, j'ai un peu tendance à me méfier des conversions implicites et préfère rajouter une fonction spécifique lorsque j'en ai besoin :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

template<typename T> class Number<T> { private: T _real; public: explicit Number(T const&);   Number<T>& operator=(Number<T>const&); Number<T>& operator=(T); };

---

Enfin, je ne vois pas l'intérêt d'un opérateur d'affectation (Quand dois-je définir l'opérateur d'affectation ?) et d'un constructeur de copie (Quand dois-je définir un constructeur par copie ?) qui font ce que fait celui que fait par défaut le compilateur.

Bonjour 3DArchi,

j'ai découvert le mot-clé explicit depuis peu en regardant la manière dont est implémenté Blitz++. Si ma mémoire est bonne, en testant le mot-clé explicit dans l'exemple

Code:

---

1 2 3

Number<double> a(1.0); a = 2.0;

---

l'appel au constructeur explicit Number<double>(double const &) est malgré tout effectué. Je vais vérifié pour être sûr.

Comme tu le suggères, j'ai moi aussi préféré la surcharge

Code:

---

1 2	Number<T> operator=(T const&);

---

plutôt que de laisser un appel implicite à un constructeur. J'ai pensé que l'opération

Code:

---

a=2.0;

---

serait plus rapide ainsi, peut-être à tort.

Si je lis correctement

Citation:

---

Enfin, je ne vois pas l'intérêt d'un opérateur d'affectation (Quand dois-je définir l'opérateur d'affectation ?) et d'un constructeur de copie (Quand dois-je définir un constructeur par copie ?) qui font ce que fait celui que fait par défaut le compilateur.

---

tu écris que ma classe pourrait simplement s'écrire

Code:

---

1 2 3 4 5 6 7 8 9 10

template<typename T> class Number<T> { private: T _real; public: Number(T const&); Number<T> operator=(T const&); };

---

et que je pourrais tout de même écrire

Code:

---

1 2 3 4

Number<double> a = 1.0; Number<double> b = 2.0; a = b;

---

Est-ce bien cela? Dans ce cas, si une autre classe hérite de Number<double>, pourrais-je quand même appelé les constructeurs appelés par défaut par le compilateur? Par exemple

Code:

---

1 2 3 4 5 6 7 8 9 10

#include "Number.hpp" class AnotherClass : private Number<double> { private: // ... des attributs ... public: AnotherClass(AnotherClass const&); // .... des méthodes ... }

---

et

Code:

---

1 2 3 4 5 6

AnotherClass::AnotherClass(AnotherClass const& param) :Number<double>(param) { ; }

---

Citation:

---

Est-ce bien cela? Dans ce cas, si une autre classe hérite de Number<double>, pourrais-je quand même appelé les constructeurs appelés par défaut par le compilateur? Par exemple

---

Oui et oui. Tant que c'est trivial à géré le compilateur le fait très bien. (ie pour le ctor de copie il appel les ctor de copie de tout les membres).

Salut,

Citation:

---

Envoyé par Aleph69

Est-ce bien cela? Dans ce cas, si une autre classe hérite de Number<double>, pourrais-je quand même appelé les constructeurs appelés par défaut par le compilateur?

---

Oui. Idem pour le destructeur (s'il ne fait rien, laisse le compilateur le définir). Sauf si tu veux en changer une des propriétés (par exemple, rendre le destructeur virtuelle ou protégé pour l'héritage).
Ceci dit, la classe number a probablement une sémantique de valeur ce qui s'articule mal avec l'héritage.
Enfin, héritage et sémantique de copie sont souvent incompatibles. Ce qui signifie que si ta classe sert de base à un héritage, il est probable que le constructeur par copie et l'opérateur d'affectation seront supprimés (Comment rendre une classe non copiable).