Classe avec constructeurs multiples

Bonjour à tous.

J'essaie de faire une classe qui contient 2 constructeurs.
Et je veux définir le second constructeur en faisant appel au premier comme suit :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

class A { public: A(std::vector<int> vec):_vec(vec){}; A(int x, int y){ std::vector<int> vec(2); vec[0]=x; vec[1]=y; A(vec); }; protected: std::vector<int> _vec; };

---

sauf que la ligne "A(vec)" produit l'erreur suivante :

Citation:

---

test.cxx:48:6: error: redefinition of 'vec' with a different type: 'A' vs 'std::vector<int>'
A(vec);

test.cxx:46:21: note: previous definition is here
std::vector<int> vec(2);

1 error generated.

---

Quelqu'un peut-il m'éclairé ?

Merci

Déjà ton code est bizarre :weird:
Pourquoi vouloir créer un temporaire pour initialiser son attribut en se cassant le trognon à appeler un autre constructeur? :koi: :koi:

Code:

---

1 2 3 4

A(int x, int y): _vec(2, 0) { _vec[0] = x; _vec[1] = y; };

---

Et ensuite il me semble que tu ne peux pas le faire, et il faut créer une méthode qui initialise ton vecteur et qui sera appelée dans les constructeurs :mrgreen:

Édit: Que c'est moche les tirets-bas dans les noms des attributs, et d'ailleurs il me semble que c'est déconseillé :whistle:
Moi, je suis extrémiste: je ne précède même pas le nom de mes attributs par "m_" (ni de n'importe quelle autre indication) :mouarf:

Depuis C++11 il est possible qu'un constructeur appel un autre constructeur (possible uniquement dans la liste d'initialisation)

Code:

---

1 2 3 4 5 6 7 8 9

struct S { S() :S(42) {}   S(int i) : i(i) {}   int i; };   S().i == 42

---

Mais il y a encore plus simple: fournir au vecteur les valeurs de départ.

Code:

---

1 2	A(int x, int y): _vec({x,y}) { };

---

Citation:

---

Envoyé par foetus

Déjà ton code est bizarre :weird:
Pourquoi vouloir créer un temporaire pour initialiser son attribut en se cassant le trognon à appeler un autre constructeur? :koi: :koi:

---

Même si ici ce n'est pas très bien appliqué, c'est très commode comme technique .

Citation:

---

Envoyé par foetus

Oui c'est la technique C++11 pour manipuler les temporaires
Mais a 2-3 subtilités cela revient à ce que j'ai dit :mrgreen:: à créer une autre méthode (donc ici swap) et l'appeler des constructeurs et des opérateurs

---

Pas du tout, cela existait bien avant C++11.

Même si « Code < C++11 à l'arrache non testé », ton code est "archi faux".

Citation:

---

Envoyé par foetus

Code:

---

1 2 3 4

protected:   std::vector<int> vec; };

---

---

Par convention (pas du tout obligatoire), j'utiliserais m_vector au lieu de vec.
Pourquoi mettre cette donnée membre en protected ?

Code:

---

1 2	private: std::vector<int> m_vector;

---

Et je mettrais le constructeur par défaut, qui a du sens (à partir de là tout est public) :
C++11

Code:

---

A() = default;

---

C++03

Code:

---

A() : m_vector() { } // A() { } devrait suffire

---

Citation:

---

Envoyé par foetus

Code:

---

1 2 3

A(std::vector<int> init_vec) { swap(init_vec); };

---

---

La liste d'initialisation suffit amplement.

Code:

---

A(std::vector<int> const & vector) : m_vector(vector) { }

---

Citation:

---

Envoyé par foetus

Code:

---

1 2 3 4 5

A(A& init_a) { std::vector<int> copy_vec(init_a.vec);   swap(copy_vec); };

---

---

Le constructeur de copie est généré automatiquement par le compilateur et fait la bonne chose, pas besoin de l'écrire ; mais si on devait le faire, ça serait :

Code:

---

A(A const & a) : m_vector(a.m_vector) { }

---

Là aussi, la liste d'initialisation suffit amplement, en plus si tu comptes utiliser l'idiome copy & swap, utiliser swap dans le constructeur par copie, ferait une boucle infinie (opérateur d'affectation qui appelle le constructeur par copie, qui appelle swap, qui appelle le constructeur par copie, ...)

Citation:

---

Envoyé par foetus

Code:

---

1 2 3 4 5 6 7

A(int x, int y){ std::vector<int> new_vec(2); new_vec[0] = x; new_vec[1] = y;   swap(new_vec) };

---

---

C++11

Code:

---

A(int const x, int const y) : m_vector({ x, y }) { }

---

C++03 (on pourrait faire une fonction qui prend deux entiers et retourne un vecteur avec ces deux entiers pour faire "comme en C++11")

Code:

---

A(int const x, int const y) : m_vector(2) { m_vector[0] = x; m_vector[1] = y; }

---

Citation:

---

Envoyé par foetus

Code:

---

1 2 3 4 5 6

// Parameter: neither pointer nor reference A& operator=(A other_a) { swap(other_a.vec);   return *this; };

---

---

L'opérateur d'affectation est généré automatiquement par le compilateur et fait la bonne chose, pas besoin de l'écrire ; mais si on devait le faire, ça serait :

Code:

---

A & operator =(A const & a) { m_vector = a.vector; return *this; }

---

Si on a une classe un peu plus compliquée, on peut utiliser l'idiome copy & swap

Code:

---

A & operator =(A const & a) { A tmp(a); std::swap(*this, tmp); return *this; }

---

La fonction template std::swap de la bibliothèque standard fait la bonne chose, si ce n'est pas le cas, on la spécialise. Voici une proposition :
On écrit la fonction membre.

Code:

---

1 2 3 4 5

void swap(A & a) { using std::swap; // Pas nécessaire ici, mais c'est une bonne pratique (merci Flob90) swap(m_vector, a.m_vector); }

---

Et voila la spécialisation (c'est une fonction libre).

Code:

---

1 2 3 4 5

namespace std { template <> void swap(A & a, A & b) { a.swap(b); } }

---

Et pour :

Citation:

---

Envoyé par foetus

Code:

---

1 2 3 4

// Parameter: reference void swap(std::vector<int>& other_vec) { vec.swap(other_vec); };

---

---

std::vector<int> n'a pas de fonction membre swap(). Voir ma proposition au dessus.
En fait si -_- (merci foetus).

Citation:

---

Envoyé par Ehonn

C++03

Code:

---

A() : m_vector() { } // A() { } devrait suffire

---

---

Ton constructeur est même totalement inutile : le constructeur par défaut des membres est déjà appelé implicitement.

Citation:

---

Envoyé par Ehonn

Code:

---

A & operator =(A const & a) { m_vector(a.vector); return *this; }

---

---

T'as été un peu vite là, le std::vector n'a pas d'opérateur() qui prend en paramètres un autre vecteur.

Code:

---

A & operator =(A const & a) { m_vector = a.vector; return *this; }

---

Citation:

---

Envoyé par Bousk

Ton constructeur est même totalement inutile : le constructeur par défaut des membres est déjà appelé implicitement.

---

Il est pas utilisé ici pour l'exemple mais c'est souvent pratique d'avoir un constructeur par défaut.
Oui, le constructeur par défaut des données membre est appelé automatiquement mais pas celui des types de bases (ou alors, il ne fait pas la bonne chose). Autrement dit, int i; est différent de int i = int();. C'est pour cela que je préfère écrire explicitement l'initialisation par défaut des données membre (mais cela ne dépend que de moi).

Citation:

---

Envoyé par Bousk

T'as été un peu vite là, le std::vector n'a pas d'opérateur() qui prend en paramètres un autre vecteur.

---

Oups, désolé, copier-coller :s Je corrige, merci :)

Ce que vous dites est vrai, mais vous n'avez pas expliqué pourquoi c'est impossible d'appeler un autre constructeur comme lg_53 le faisait.

La création d'une variable ou d'un pointeur se fait en deux étapes: allocation d'une zone de mémoire (sur la pile, ou sur le tas avec new), puis construction de la variable.

Pour un type primitif, une enum ou une union la construction est simple: rien du tout, c'est à dire valeur arbitraire. (Undefined behaviour pour être précis)
Pour un tableau, la règle est un peu plus subtile, selon ce qui est fourni (ou non) comme initialiseur et comme taille.
Pour un type construit (struct, class), c'est le constructeur qui est appelé (constructeur par défaut s'il n'y a pas d'argument d'initialisation)

Ce constructeur travaille sémantiquement: en deux temps, initialisation des classes parentes et variables membres, puis traitement global.
L'initialisation est faite dans la liste d'initialisation (d'où le nom), et le traitement dans le corps du constructeur.

On ne peut pas appeler un autre constructeur dans ce corps, parce que justement les variables ont déjà été initialisées (tout particulièrement les constantes et les références).

C++11 ajoute la possibilité d'appeler un autre constructeur dans certains cas mais, pour la même raison, dans la liste d'initialisation.


PS: il me semble que pour un constructeur, les types primitifs sont mis à 0.

La réponse est simple: La syntaxe la plus intuitive pour appeler un constructeur hors de la liste d'initialisation est déjà utilisée pour instancier un objet temporaire.

Exemple:

Code:

---

1 2 3 4 5 6 7 8 9 10 11

A::A(int a) { m_a = a; m_str = "def"; }   A::A(std::string str) { A(42); //Cette ligne ne fait pas ce que tu crois! m_str = str; }

---

La ligne 42 n'appelle pas un autre constructeur, mais crée un nouvel objet temporaire, immédiatement détruit!

---

Mais ce n'est pas le seul problème: Imaginons que tu réussisses à faire ce que tu veux avec un placement new

Code:

---

1 2 3 4 5

A::A(std::string str) { new(this) A(42); m_str = str; }

---

Félicitations, tu viens d'écraser des données déjà initialisées avec d'autres. Aucun destructeur ni opérateur = n'a été appelé, vu que le constructeur compte sur le fait que les données ne soient pas encore initialisées: Félicitations, tu as fait l'équivalent d'un memcpy() en C++. Très mauvais.
C'est pour ça qu'on ne peut appeler un constructeur du même objet que dans la liste d'initialisation. Ou par copy-and-swap.

Ehon, ce n'est pas fair play de chipoter sur les conventions de nommages :mrgreen: (m_vector <-> vec).

Citation:

---

Envoyé par leternel

PS: il me semble que pour un constructeur, les types primitifs sont mis à 0.

---

Que veux-tu dire par là ? Les types primitifs ne sont mis à leur valeur par défaut (zéro la plupart du temps) qui si explicitement ajoutés dans un constructeur. Exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

#include <iostream>   struct Roger { int a; int b[10]; };   int main() { Roger r; std::cout << r.a << "\n"; for(int i = 0; i < 10; ++i) std::cout << r.b[i]; std::cout << std::endl; return 0; }

---

Affiche une horreur du genre :

Code:

---

1 2	1964710984 326184197008000419652801178070192327670

---

Mais

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#include <iostream>   struct Roger { int a; int b[10]; Roger() : a(), b() {} };   int main() { Roger r; std::cout << r.a << "\n"; for(int i = 0; i < 10; ++i) std::cout << r.b[i]; std::cout << std::endl; return 0; }

---

Affiche bien:

Code:

---

1 2	0 0000000000

---

A noter, la syntaxe avec des parenthèses y compris pour l'array, qui est entièrement initialisé à zéro. En C++11, on peut utiliser des accolades à la place des parenthèses.

Citation:

---

Envoyé par jblecanard

Les types primitifs ne sont mis à leur valeur par défaut (zéro la plupart du temps) qui si explicitement ajoutés dans un constructeur.

---

Selon le draft de la norme C++14 :
int i; est une default-initialization qui, pour les types de base, n'initialise pas (§ 8.5.7)
int() est une value-initialization qui, pour les types de base, est traitée par une zero-initialization (§ 8.5.8)

Bref, la norme garantit que int() est 0.

Citation:

---

Envoyé par Ehonn

Selon le draft de la norme C++14 :
int i; est une default-initialization qui, pour les types de base, n'initialise pas (§ 8.5.7)
int() est une value-initialization qui, pour les types de base, est traitée par une zero-initialization (§ 8.5.8)

Bref, la norme garantit que int() est 0.

---

Oui, et c'est bien ce qu'explique jblecanard, si rien d'explicite n'est fait (i.e. constructeur généré par le compilateur, ou absence de l'entier dans la liste d'initialisation), l'entier à une valeur quelconque (default initialization), sinon non. Et que montre son exemple.

Citation:

---

Envoyé par gl

Oui, et c'est bien ce qu'explique jblecanard.

---

Et c'est ce que j'ai expliqué mais sans l'illustrer dans le message #8.

Citation:

---

Envoyé par jblecanard

Les types primitifs ne sont mis à leur valeur par défaut (zéro la plupart du temps) qui si explicitement ajoutés dans un constructeur.

---

Mon message était là juste pour dire que ce n'est pas « zéro la plupart du temps » mais bien « garantit à 0 lors d'une value-initialization » par la norme elle-même.

En effet, merci pour la précision, j'ai justement dit "la plupart du temps" parce que j'avais la flemme d'aller fouiller dans la norme pour voir si c'était bien zéro dans tous les cas :aie:.

Et moi je me suis dit « Attention ! si jblecanard dit « la plupart du temps » , je ferais mieux de vérifier ce que je pensais savoir » ^^

@Ehonn: La manière idiomatique d'utiliser swap c'est de faire un using std::swap; et d'utiliser un appel non qualifié. Ce n'est pas nécessaire dans l'exemple que tu donnes car ta classe n'est pas template, mais sinon ça le serait (donc autant le faire tout le temps).

PS: Faute de frappe dans ta spécialisation de swap, c'est A pas T à priori.

C'est corrigé, merci :)

Fiou, vous m'en avez donné de la lecture !

Merci pour vos réactions.
Alors pour répondre au mieux à un peu tous le monde:
1) Mon ECM est peut-être en effet trop minimaliste, puisque dans ce cas je peux effectivement procéder par liste d'initialisation du style:

Code:

---

A(int const x, int const y) : _vec(2) { _vec[0] = x; _vec[1] = y; }

---

ou

Code:

---

A(int x, int y): _vec({x,y}) {};

---

Dans mon cas le problème est plus complexe, et je ne peux pas écrire mon second constructeur en faisant seulement une liste d'initialisation...
Je vais peut-être travaillé sur un exemple un peu plus complet, qui s'approcherais un peu plus de ce que j'ai...

2) Vous avez réalisé une petite digression sur la différence entre une default-initialization et une value-initialization. Je me serais cultivé une fois de plus, mais là n'est pas le coeur du problème je pense.

3) Pour ce qui est du swap&copy, vous n'avez pas l'air tous d'accord sur la bonne manière de procéder, mais de toute façon si je travaille avec une structure plus complexe qu'un std::vector, ça semble laborieux à mettre en oeuvre.

4) Pourquoi mettre en protected plutôt qu'en private? C'est un choix personnel. Tout simplement parce que si qqn n'a pas les droits pour modifier la classe mais qu'il souhaite l'améliorer,l'étoffer pour ses propres besoins, et bien il peut faire une classe fllle et a ainsi accès aux attributs librement en lecture et écriture. Là non plus, ce n'est pas ce qui me pose problème.

Pour finir, je code en C++11.

Voici un exemple plus complet, sur lequel je l'espère vous verrez mieux mon objectif.

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 31 32

template < typename T > class Box { public: Box(const std::vector<T>& A, const std::vector<T>& B):_A(A),_B(B){}; Box(T ax, T ay, T bx, T by):_A(2),_B(2){ _A[0]=ax; _A[1]=ay; _B[0]=bx; _B[1]=by; }; Box(const Box& box):_A(box.GetA()),_B(box.GetB()){};   std::vector<T> GetA() const {return _A; }; std::vector<T> GetB() const {return _B; }; T size(int i) const { return _B[i]-_A[i]; }; T sizeX() const { return _B[0]-_A[0]; }; T sizeY() const { return _B[1]-_A[1]; };   protected: std::vector<T> _A,_B; };   class Mask { public: //Mask() {}; Mask(int sizex, int sizey, int originX=0, int originY=0):_sx(sizex),_sy(sizey),_ox(originX),_oy(originY){}; Mask(const Box<int>& box):_sx(box.sizeX()),_sy(box.sizeY()),_ox(box.GetA()[0]),_oy(box.GetA()[1]){}; //Mask(const std::vector<int>& A,const std::vector<int>& B){ // Box<int> box(A,B); // Mask(box); // }; ~Mask(){};   protected: int _sx,_sy,_ox,_oy; };

---

Voila.
Donc j'ai une classe Box.
Ensuite je définis une classe Mask. Le constructeur que je souhaite implémenté est commenté.
Le constructeur de la classe Mask a qui on fourni en paramètres deux std::vector<int>, a besoin de méthode de la classe Box pour pouvoir s'initialiser.
D'où mon envie de créer un objet Box intermédiaire et d'appeler ensuite le second constructeur...

Merci à vous

Citation:

---

Envoyé par lg_53

3) Pour ce qui est du swap&copy, vous n'avez pas l'air tous d'accord sur la bonne manière de procéder, mais de toute façon si je travaille avec une structure plus complexe qu'un std::vector, ça semble laborieux à mettre en oeuvre.

---

Si si on est bien d'accord sur la manière de procéder.
L'idiome copy & swap rend le code de l'opérateur d'affectation trivial en utilisant le constructeur par copie et swap qui sont "plus faciles" à implémenter. C'est justement lorsqu'il y a plus qu'un std::vector que ça devient interessant.

Citation:

---

Envoyé par lg_53

4) Pourquoi mettre en protected plutôt qu'en private? C'est un choix personnel. Tout simplement parce que si qqn n'a pas les droits pour modifier la classe mais qu'il souhaite l'améliorer,l'étoffer pour ses propres besoins, et bien il peut faire une classe fllle et a ainsi accès aux attributs librement en lecture et écriture. Là non plus, ce n'est pas ce qui me pose problème.

---

Dans ce cas il faut (généralement) mettre le destructeur en public et virtual.
FAQ C++ - Pourquoi le destructeur d'une classe de base doit être public et virtuel ou protégé et non virtuel ?