Discussion :

[Aleph69]

Bonjour,

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

Code :

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

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 :

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

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

[atttchoum]

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 :

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
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 :

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

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

[Aleph69]

Bonjour,

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

[Aleph69]

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

[3DArchi]

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 :

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

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.

[Aleph69]

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 :

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

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 :

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

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 :

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

a=2.0;

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

Si je lis correctement

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 :

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

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 :

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

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 :

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

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 :

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

1
2
3
4
5
6
 
AnotherClass::AnotherClass(AnotherClass const& param)
:Number<double>(param)
{
    ;
}

[Goten]

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).

[3DArchi]

Salut,

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).