Comment copier un objet et son contenu dans un autre objet

Tout est dans le titre.

Code:

---

1 2 3 4

void Menu::SetTextStyle(Text ptext) { text = ptext; }

---

Code:

---

1 2 3 4 5 6 7

||=== Build: Debug in THELAST (compiler: GNU GCC Compiler) ===| include\Menu.h|10|warning: direct base 'Window' inaccessible in 'Menu' due to ambiguity| C:\Users\sophie\Desktop\THELAST\src\Menu.cpp||In member function 'void Menu::SetTextStyle(Text)':| C:\Users\sophie\Desktop\THELAST\src\Menu.cpp|11|error: use of deleted function 'Text& Text::operator=(const Text&)'| include\Text.h|9|note: 'Text& Text::operator=(const Text&)' is implicitly deleted because the default definition would be ill-formed:| include\Text.h|9|error: non-static const member 'const char Text::fontname', can't use default assignment operator|

---

Bonjour,

Tout est dans le message d'erreur.

La classe Text contient un membre 'fontname' qui est constant. Par conséquence, le compilateur refuse de générer l'opérateur d'assignation par copie car il ne sait pas copier une chose dans une autre chose qui est constante. Il faut donc définir soi-même l'opérateur en question et décider comment faire pour ce membre constant...

ok cool merci pour l'aide c'est bon j'ai trouver mon problème ;)

On peut aussi effectuer une copie avec un constructeur de copie. Cela présente l'avantage de permettre la copie d'une classe qui possède des données membres constantes. La différence fondamentale entre T(const T& Original) et l'opérateur = est que dans le premier cas, l'objet n'existe pas encore et que tous ses attributs peuvent être initialisés tandis que dans le second cas, il faut respecter la constance des membres constants de ce qui se trouvent à gauche de l'opérateur =. On peut surcharger l'opérateur = pour une classe qui comporte un membre constant, mais la sémantique d'un tel opérateur pourrait causer problème. En fait, ce code pourrait imprimer "Gros problème"

Code:

---

1 2 3 4 5 6 7 8 9 10 11

T T1,T2;   //initialiser T1 et T2 à des valeurs distinctes du membre constant.   T1=T2; IF (T1 != T2) { std::cout<<"Gros problème"<<std::endl; }

---

Étant donné qu'après l'affectation, les membres constants ne seront pas identiques des deux côtés, T1 et T2 seront différents sauf si l’opérateur != ne prend pas en compte la portion constante. Comme != est toujours implémenté en utilisant == de cett manière return !(T1==T2). Si on ajoute #include <utility> à son code, une template function établira cette identité pour tous les types T.

Code:

---

1 2 3 4 5 6

namespace rel_ops { template <class T> bool operator!= (const T& x, const T& y) { return !(x==y); } template <class T> bool operator> (const T& x, const T& y) { return y<x; } template <class T> bool operator<= (const T& x, const T& y) { return !(y<x); } template <class T> bool operator>= (const T& x, const T& y) { return !(x<y); } }

---

Dans ce cas, l'opérateur == définit des classes d'équivalences: indépendamment de la valeur de ce qui est constant, si la partie non-constante est identique, on considérera que les instances sont identiques. Si on met en gras la partie constantes, toutes ces instances seraient équivalentes.

Code:

---

1 2 3 4

(1,2) (1,-100) (1,25000)

---

On pourrait utiliser un const_cast pour éliminer la constance, mais le standard C++ nous apprend que le retrait de la constance de cette manière entraînerait un comportement indéterminé de l'application (undefined behaviour).