Construire un objet avec l'opérateur d'assignation

Bonjour,

Jusqu'à maintenant voilà comment je procédais pour instancié mes objets :

Code:

---

1 2 3 4 5 6 7 8

// sur la pile, statique MyObject instanceA; MyObject instanceB(42, "cpp_qt_lover");   // sur le tas, dynamique MyObject* instanceA = new MyObject(); MyObject* instanceB = new MyObject(42, "cpp_qt_lover");

---

Voilà, comme j'étais un peu fatigué et que je voulais ne plus utilisé d'allocation dynamique, j'ai transformé le code suivant :

Code:

---

1 2 3

MyObject* instanceA = new MyObject();// original MyObject instanceA = MyObject();// retiré le new et l'opérateur*

---

Et surprise, là ou je m'attendais à une erreur du compilateur, et bien tout fonctionnait... Je voulais savoir si c'était une autre façon de faire ou si sa signifiait autre chose... Merci d'avance pour vos réponses.

Citation:

---

Envoyé par Abdelite

Code:

---

1 2 3

MyObject* instanceA = new MyObject();// original MyObject instanceA = MyObject();// retiré le new et l'opérateur*

---

Et surprise, là ou je m'attendais à une erreur du compilateur, et bien tout fonctionnait... Je voulais savoir si c'était une autre façon de faire ou si sa signifiait autre chose... Merci d'avance pour vos réponses.

---

Non non, il n'y a aucuns problèmes... du moment que tu as un constructeur de copie: cela revient alors à faire:

Code:

---

1 2 3

MyObject* temp = new MyObject(); MyObject instanceA(temp); delete temp;

---

Bonjour,

ce que je ne comprends pas, c'est que ce code ne devrait pas compiler normalement. Il est interdit, en c++, de déclarer deux variables du même nom mais de types différents dans le même scope.

Salut,

outre le fait que le compilateur te jetterait normalement du fait de la re déclaration d'une variable, il n'y a strictement aucune raison pour que cela ne fonctionne pas...

Si tu ne prend pas la précaution de les désactiver explicitement (soit en les déclarant sans les définir dans l'accessibilité privée, soit (merci la nouvelle norme) en les spécifiant delete), toute classe/structure dispose systématiquement d'un constructeur par copie et d'un opérateur d'affectation (en plus du destructeur et du constructeur par défaut si tu ne déclare pas de constructeur perso): cela fait partie des fameux Big Four :D.

Code:

---

MonType var = MonType(); //affectation explicite

---

est donc presque similaire à

Code:

---

MonType var // appel implicite du constructeur par défaut

---

et, NRVO aidant, il y a même de fortes chances pour que le binaire soit strictement identique :D

Citation:

---

Envoyé par r0d

Bonjour,

ce que je ne comprends pas, c'est que ce code ne devrait pas compiler normalement. Il est interdit, en c++, de déclarer deux variables du même nom mais de types différents dans le même scope.

---

probable que ce soit un copier/coller mal placé ;)

Merci pour vos réponses. Désolé pour le code présenté, quelques copier/coller qui ont mal tourné... Je remets le code ci-dessous :

Code:

---

1 2 3 4 5 6 7 8

// sur la pile, statique MyObject instanceA; MyObject instanceB(42, "cpp_qt_lover");   // sur le tas, dynamique MyObject* instanceC = new MyObject(); MyObject* instanceD = new MyObject(42, "cpp_qt_lover");

---

et

Code:

---

1 2 3

MyObject* instanceC = new MyObject();// avant de modifier MyObject instanceC = MyObject();// retiré le new et l'opérateur*

---

Il s'agit bien de 4 instances différentes...

méphistopheles> Merci, donc c'est bien dans l'exemple que j'avais présenté le constructeur de copie qui est appelé.

koala01> Pour ce code d'exemple :

Code:

---

1 2	MonType var = MonType();//affectation explicite

---

Tu parles d'affectation, mais dans le cas ou var n'est pas déjà déclaré, est-ce que cette ligne qui déclare var est valide ? Je viens de tester, ça fonctionne.

Oui cette ligne est valide.
En fait, cette ligne fait deux chose distinctes en même temps: une déclaration et une affectation (ou initialisation). Et c'est parfaitement valide en C++, et même conseillé en fait.

Mais il est tout de même plus propre de faire ainsi:

Code:

---

MonType var(/* paramètres éventuels */);

---

Citation:

---

Tu parles d'affectation, mais dans le cas ou var n'est pas déjà déclaré, est-ce que cette ligne qui déclare var est valide ? Je viens de tester, ça fonctionne.

---

En fait ce genre de code :

T t = T();


n'appelle pas l'op= mais le constructeur par recopie. ;).

Merci pour vos réponses ! Sujet :resolu:

Citation:

---

Envoyé par Goten

En fait ce genre de code :

T t = T();


n'appelle pas l'op= mais le constructeur par recopie. ;).

---

Et encore... si (N)RVO ( (Named) Return Value Optimisation) ne passe pas par là :aie:

Avec le phénomène (N)RVO qui est quand même implémenté par pas mal de compilateur, il se peut que le seul constructeur par défaut soit appelé:D

@Abdelite>> Ce qu'il faut comprendre, c'est que, tant que tu ne lui donne pas de raison d'agir autrement, le compilateur va systématiquement implémenter la forme canonique de Coplien pour toutes les classes / structures qu'il rencontre.

C'est à dire qu'il implémentera de manière implicite (sans que tu ne fasse quoi que ce soit) quatre fonctions particulières:

1. le constructeur par défaut (ne prenant pas d'argument)
2. le constructeur par copie
3. le destructeur
4. l'opérateur d'affectation

Il n'y a donc, a priori, aucune raison pour qu'il rechigne à copier ou à affecter une instance d'une classe à une variable dont le type est compatible :D

Pour que le compilateur renonce à fournir l'implémentation d'une de ces fonctions, il "suffit" de la déclarer, ou, pour le constructeur par défaut, de déclarer n'importe quel constructeur qui ne soit pas constructeur par copie.

Le compilateur fournira alors le code binaire de la fonction en question sur base... de l'implémentation que tu en auras (éventuellement) donnée.

C'est la raison pour laquelle, lorsque l'on crée une classe non copiable et / ou non assignable, on se contente de déclarer le constructeur par copie et / ou l'opérateur d'affectation dans l'accessibilité privée sans les implémenter.

Dans la majorité des cas (comprend: tant que l'on est dans une situation dans laquelle on n'a pas accès à la partie private de la classe) cette simple manoeuvre permet d'obtenir une erreur proche de "le constructeur par copie (ou l'opérateur d'affectation) est private dans ce contexte"

Une minorité de cas peut cependant avoir accès à cette déclaration private du constructeur par copie / de l'opérateur d'affectation: Lorsque l'on se trouve dans une fonction membre de la classe ou dans une fonction pour laquelle l'amitié avec la classe s'applique.

L'erreur sera alors reportée à l'étape d'édition de liens, l'éditeur de liens se plaignant d'un "symbole indéfini", car le symbole du constructeur par copie / de l'opérateur d'affectation existant, mais l'éditeur de liens ne trouve aucun code binaire correspondant.

La nouvelle norme ajoute la possibilité de dire de manière explicite que l'une de ces fonctions n'existe pas (NB: une classe que l'on ne pourrait pas construire ou que l'on ne pourrait pas détruire n'a strictement aucun intérêt, hein :question: cette possibilité n'a donc d'intérêt que pour le constructeur par copie ou l'opérateur d'affectation :D) en ajoutant = delete après la déclaration:

Code:

---

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

class NonCopiable { public: NonCopiable(); // constructeur par défaut NonCopiable(NonCopiable const &) = delete; // uniquement en C++1x NonCopiable & operator = (NonCopiable const &) = delete; //uniquement en C++1x /* si on ne déclare pas le destructeur, le compilateur l'ajoute   * automatiquement et le rend public et non virtuel   */ private: /* rendent la classe non copiable / non affectable   * !!! pour que ce soit effectivement le cas, on ne fournit pas   * d'implémentation pour ce qui suit :D   */ NonCopiable(NonCopiable const &); /* valide depuis toujours */ NonCopiable & operator= (NonCopiable const &); /* idem */   };

---

A noter que même si le (N)RVO s'applique il faut quand même que le constructeur par copie soit au moins déclaré et accessible pour que la compilation soit valide.

Citation:

---

Envoyé par Flob90

A noter que même si le (N)RVO s'applique il faut quand même que le constructeur par copie soit au moins déclaré et accessible pour que la compilation soit valide.

---

Oui, bien sur, autrement, on entre dans la situation d'une classe non copiable :P

La réelle différence avec / sans (N)RVO se verra au niveau du binaire généré ;)

Bonjour,

Citation:

---

Envoyé par Abdelite

Code:

---

1 2 3

MyObject* instanceC = new MyObject();// avant de modifier MyObject instanceC = MyObject();// retiré le new et l'opérateur*

---

---

Ceci dit, ces 2 lignes de codes sont différentes puisque tu as la gestion de la libération de la première à faire explicitement (delete) alors que la seconde est libérée dès que la variable sort de sa portée (implémentation tas vs pile). Il n'est donc pas anodin d'enlever * et new, ce n'est pas la même chose.

Citation:

---

Envoyé par 3DArchi

Ceci dit, ces 2 lignes de codes sont différentes puisque tu as la gestion de la libération de la première à faire explicitement (delete) alors que la seconde est libérée dès que la variable sort de sa portée (implémentation tas vs pile). Il n'est donc pas anodin d'enlever * et new, ce n'est pas la même chose.

---

Rassure toi j'en avais conscience.

koala01> Goten> Donc si mon constructeur de copie étais privé, le chose suivante aurais été impossible ? T t = T();

Citation:

---

Envoyé par Abdelite

Rassure toi j'en avais conscience.

---

C'est bien ce que je pensais, mais la lecture du fil ne m'a pas paru évidente sur ce point, c'est pour ça que j'ai préféré préciser.

Citation:

---

Envoyé par Abdelite

koala01> Goten> Donc si mon constructeur de copie étais privé, le chose suivante aurais été impossible ? T t = T();

---

Oui. Tu aurais eu une erreur disant que le constructeur de copie est privé (et idem si protégé bien sur).
De la même façon, si tu utilises =delete de C++0x sur le constructeur de copie, tu aurais une erreur indiquant que le constructeur de copie est non défini.

Citation:

---

Envoyé par Flob90

A noter que même si le (N)RVO s'applique il faut quand même que le constructeur par copie soit au moins déclaré et accessible pour que la compilation soit valide.

---

Oui c'est pour ça que j'ai pas mentionné le NRVO d'ailleurs... (pas besoin de l'encombrer avec ce genre de notion)

Petite note: je ne vois pas de (N)RVO applicable ici ((Named) Return Value Optimization). Ce qui est applicable est la permission plus générale de l'élision du constructeur de copie appliqué aux temporaires.

Quelqu'un ici pourrait m'expliquer ce qu'est NRVO/(N)RVO ? Merci.

Avant de poster -> F.A.Q C++
http://cpp.developpez.com/faq/cpp/?p...TIMISATION_RVO