membre const et opérateur d'affectation. Comment éviter le comportement indéfini?

Premièrement: lorsque vous créez un membre de données const, Vous dites au compilateur et au monde entier que ce membre de données ne change jamais. Bien sûr alors vous ne pouvez pas lui attribuer et vous certainement ne doit pas tromper le compilateur en acceptant le code qui le fait, peu importe à quel point l'astuce est intelligente.
Vous pouvez avoir un const membre de données ou un opérateur d'affectation l'affectation à tous les membres de données. Vous ne pouvez pas avoir les deux.

Quant à votre "solution" au problème:
Je suppose que appelant le destructeur sur un objet dans une fonction membre appelée pour que les objets invoqueraient UB tout de suite. invoquer un constructeur sur des données brutes non initialisées pour créer un objet à partir d'une fonction membre qui a été invoquée pour un objet qui résidait où maintenant le constructeur est appelé sur des données brutes... aussi très beaucoup de sons comme UB pour moi. (L'enfer, juste l'orthographe fait que mes ongles se courbent.) Et, non, je n'ai pas de chapitre et le verset de la norme. Je déteste lire la norme. Je pense que je ne peux pas supporter son compteur.

Cependant, les aspects techniques mis à part, j'admets que vous pourriez vous en tirer avec votre "solution" sur à peu près toutes les plates-formestant que le code reste aussi simple que dans votre exemple. Pourtant, cela n'en fait pas une bonne solution . En fait, je dirais que ce n'est même pas une solution acceptable , parce que le code IME ne reste jamais aussi simple que cela. Au fil des ans, il sera étendu, changé, muté et tordu, puis il échouera silencieusement et nécessitera un changement de débogage de 36 heures pour trouver le problème. Je ne sais pas pour vous, mais chaque fois que je trouve un morceau de code comme celui-ci responsable de 36 heures de débogage amusant, je veux étrangler le misérable idiot qui m'a fait ça.

Herb Sutter, dans son GotW #23, dissèque cette idée pièce par pièce et conclut qu'il "est plein de pièges, c'est souvent à tort, et il rend la vie un enfer pour les auteurs de classes dérivées... n'utilisez jamais l'astuce d'implémenter l'affectation de copie en termes de construction de copie en utilisant un destructeur explicite suivi du placement new , même si cette astuce apparaît tous les trois mois sur les newsgroups "(soulignez le mien).

Comment Pouvez-vous attribuer à un A s'il a un membre const? Vous essayez d'accomplir quelque chose qui est fondamentalement impossible. Votre solution n'a pas de nouveau comportement par rapport à l'original, ce qui n'est pas nécessairement UB mais le vôtre l'est certainement.

Le simple fait est que vous changez de membre const. Vous devez soit détacher votre membre, soit abandonner l'opérateur d'affectation. Il n'y a pas de solution à votre problème - c'est une contradiction totale.

Modifier pour plus clarté:

Const cast n'introduit pas toujours un comportement indéfini. Vous, cependant, très certainement fait. En dehors de toute autre chose, il est indéfini de ne pas appeler tous les destructeurs - et vous n'avez même pas appelé le bon - avant de le placer à moins que vous ne sachiez avec certitude que T est une classe POD. En outre, il y a des comportements indéfini owch-time impliqués dans diverses formes d'héritage.

Vous invoquez un comportement indéfini, et vous pouvez éviter cela en n'essayant pas d'assigner à un objet const.

Si vous voulez vraiment avoir un membre immuable (mais assignable), alors sans UB vous pouvez disposer les choses comme ceci:

#include <iostream>

class ConstC
{
    int c;
protected:
    ConstC(int n): c(n) {}
    int get() const { return c; }
};

class A: private ConstC
{
public:
    A(int n): ConstC(n) {}
    friend std::ostream& operator<< (std::ostream& os, const A& a)
    {
        return os << a.get();
    }
};

int main()
{
    A first(10);
    A second(20);
    std::cout << first << ' ' << second << '\n';
    first = second;
    std::cout << first << ' ' << second << '\n';
}

Avoir une lecture de ce lien:

Http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=368

En particulier...

Cette astuce empêche le code la réduplication. Cependant, il a quelques de graves lacunes. Pour le travail, C est destructor doit assigner annuler chaque pointeur qu'il a supprimé parce que l'appel du constructeur de copie suivant peut supprimer les mêmes pointeurs à nouveau quand il réaffecte une nouvelle valeur à char tableau.

En l'absence d'autres membres (non-const), cela n'a aucun sens, quel que soit le comportement indéfini ou non.

A& operator=(const A& assign) 
{ 
    *const_cast<int*> (&c)= assign.c;  // very very bad, IMHO, it is UB
    return *this; 
}

AFAIK, ce n'est pas un comportement indéfini qui se passe ici parce que c n'est pas une instance static const, ou vous ne pouvez pas appeler l'opérateur d'affectation de copie. Cependant, {[6] } devrait sonner une cloche et vous dire que quelque chose ne va pas. const_cast a été principalement conçu pour contourner les API non const correctes, et cela ne semble pas être le cas ici.

Aussi, dans le extrait suivant:

A& operator=(const A& right)  
{  
    if (this == &right) return *this;  
    this->~A() 
    new (this) A(right); 
    return *this;  
}

Vous avez deux risques majeurs, le 1er qui a déjà été souligné.

1. En présence de deux une instance de la classe dérivée de A et un destructeur virtuel, cela ne mènerait qu'à la reconstruction partielle de l'instance d'origine.
2. Si l'appel du constructeur dans new(this) A(right); lève une exception, votre objet sera détruit deux fois. Dans ce cas particulier, ce ne sera pas un problème, mais si vous arrivez à avoir un nettoyage important, vous allez le regretter.

Edit : si votre classe A ce membre const qui n'est pas considéré comme "état" dans votre objet (c'est-à-dire qu'il s'agit d'une sorte D'ID utilisé pour le suivi des instances et ne fait pas partie des comparaisons dans operator== et autres), alors ce qui suit peut avoir du sens:

A& operator=(const A& assign) 
{ 
    // Copy all but `const` member `c`.
    // ...

    return *this;
}