je suis en train de lire le tuto de christian casteyde et il y a un truc que je saisi pas, c´est la différence entre la surcharge de l´opérateur = et un transtypage implicit

par exemple :
class MaClass
{
public:
MaClass &=(const MaClass&)&
MaClass(const MaClass&);
}

les deux fonction permette la syntaxe :
MaClass truc,machin;
truc=machin;
donc quelle est la différence entre les deux. Et aussi quelle est la différence entre MaClass & et MaClass operator ( sans le & puiceque son utilisation dépend du tuto mais aucun n´explicite pourquoi il utilise ou pas le &)

merci d´avance à ceux qui prennent le temps de me répondre.

" le deux fonctions permettent la meme chose"

non.

seulement un compilo intelligent transforme un :
Foo foo1;
Foo foo2 = foo1;

en :
Foo foo1;
Foo foo2(foo1);

du coup si tu affectes un objet au moment où tu le construit, le compilofait directement une copie ( ctor par copy) et non pas une affectation ( =).

l´operator = s´applique à un objet DEJA existant, ce qui veut dire que si on considère l´exemple précédent, en ométtant les optims du compilo, on doit avoir ça :

Foo foo1;
Foo foo2;
foo2 = foo1;

là au total on a deux ctos et un opérateur d´appelés ( 3 " methodes").

alors qu´en écrivant:
Foo foo1;
Foo foo2(foo1);

on n´a qu´un default ctor et un copy ctor d´appelés.
Pour les objets couteux à construire c´est TRES important de savoir ce qui se passe...

Petit conseil pour expérimenter, écrire la forme canonique pour une classe bison, foutre des breakpoints partout, compiler en debug, et voire ce qui se passe quand on construit, on affecte, etc. des instances.

Quant au Foo & =(const Foo &), si tu ne revois pas une référence ça veut dire que tu vas dupliquer l´objet en cours ( via le return *this; ) à chaque affectation ( copy ctor appelé) ; la encore ça peut etre TRES couteux. D´autant plus que des fois tu veux que l´opération appelle le = travaille sur l´objet meme, pas sur une copie.

oops, dsl pour les fautes : je ne pense jamais qu´on ne peut pas éditer en se relisant...

+r
-s +d
-e

Au passage pour l´operator = il est interessant de tester l´auto-affectation pour éviter de faire du boulot inutile :

Foo &::operator =(const Foo &)
{
if ( & ! = this)
{
m_bar = rFoo.m_bar;
. ..
}

return *this;
}

merci,

c´était pas clair dans le tuto de castayde, où j´avais l´impression ( chap 8.3.3) qu´un constructeur qui n´est pas déclaré explicit peut être appelé n´importe où avec un =.

mais c´est vrai que dans son exemple, ça suis directement le création de l´instance.

bon, ben je vais continuer à expérimenter ça.