Discussion :

[BBric]

Bonjour, je voudrais savoir si l'on pouvait assigner un nouvel objet via la surcharge de l'opérateur =

Si je fait par exemple :

Code :

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

1
2
A a(1);
a = 2;

Le comportement que j'attends est que a soit égal à un nouvel objet A (et que le précédent soit perdu ici), mais dans l'opérateur =, le pointeur this représente l'objet a, donc je ne peux que modifier a, et si je fait un 'return A(2)' un nouvel objet est bien crée mais il est ignoré, et mon objet a est toujours le premier instancié.

[Astraya]

Tu peux surcharger l'opérateur = avec en paramètre un entier au lieu d'un A.

Code :

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

1
2
3
4
5
 
A& A::operator=(int i)
{
     //Affecte ton i dans ton A ici.
}

[BBric]

Oui mais ça ne change rien, puisque this est toujours l'objet à gauche du = et non un nouvel objet.

[Médinoc]

Si tu veux vraiment changer complètement la sémantique de l'opérateur=, tout le monde va te détester mais tu peux:

Code horrible :

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

1
2
3
4
5
6
7
8
9
A A::operator=(int i)
{
     return A(i);
}
 
ostream& A::operator<<(ostream& output)
{
     //Afficher le nombre contenu
}

Ceci peut s'utiliser comme cela:

Code horrible :

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

1
2
3
4
A a(1);
A b = (a=2);
cout << a << endl; //Affiche 1
cout << b << endl; //Affiche 2

Mais c'est vraiment quelque chose à ne pas faire. La surcharge de opérateurs est faite pour faire marcher la sémantique des opérations dans les classes, pas pour la changer.

C'est comme implémenter un operator+ qui aurait la sémantique d'un operator+=...

[BBric]

Dans ton exemple tu crée une deuxième variable sur la base de la première, mais dans ce cas un b(2) suffit pour créer un autre objet, et un a = (a=2) pose le même problème.
C'est vraiment l'opérateur = que je ne comprends pas, si ce mode de fonctionnement est courant ça signifie quelque part que :

Code :

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

1
2
3
4
5
monObjetA = valeur;
monObjetA = monObjetB;
// équivaut respectivement à
monObjetA.setValue(valeur);
monObjetA.setValue(monObjetB.getValue());

Alors qu'à mon sens la première ligne représente l'objet dans sa globalité, et donc attendrait davantage une nouvelle instance, plutôt que de manipuler ses membres/méthodes, ce qui n'est pas du tout la même chose.

[Bousk]

Je ne comprends pas ce que tu racontes.
Mais ce que tu crois "normal" me fait penser à du scripting.

Il n'y a pas de A(1) ou de A(2), tu as une variable a qui (peut) prend(re) une valeur.
Par chance on a un opératuer = qui permet de donner une nouvelle valeur à cette variable, sur la base d'une autre via l'opération.

Je ne vois franchement pas ce que tu ne comprends pas, ni ce que tu espères. C'est comme ça, c'est tout. Tu "t'adaptes" et tu appliques.

[Médinoc]

Ce que tu cherches en gros, ce sont les types valeur de .Net: Un = écrase directement le contenu du type, même si ses variables membres sont readonly (ce qui signifie que a=b en .Net marche là où a.setValue(b.getValue()) ne marcherait pas).
En revanche, un type valeur en .Net ne peut pas avoir de destructeur, ni même de constructeur par défaut.

Il n'y a rien de tout ça en C++. Pour permettre aux couples constructeur/destructeur de marcher correctement, il n'y a aucune opération de "blit" aveugle, que ce soit en copie ou affectation.

[BBric]

Je suis clairement habitué aux langages de plus haut niveau.