Est-ce que cette réaffectation C++ est valide?

Question

Désolé pour la question de base, mais j'ai du mal à trouver la bonne chose à google.

#include <iostream> 
#include <string> 
using namespace std; 

class C { 
public: 
C(int n) { 
    x = new int(n); 
} 

~C() { 
    delete x; 
} 

int getX() {return *x;} 

private: 
    int* x; 
}; 

void main() { 
    C obj1 = C(3); 
    obj1 = C(4); 
    cout << obj1.getX() << endl; 
} 

On dirait qu'il fait correctement l'affectation, puis appelle la destructor sur obj1 laissant x avec une valeur de déchets plutôt que d'une valeur de 4. Si cela est valable, pourquoi fait-il cela?

Answer 1

S'il existe une classe C dont un constructeur prend un entier, ce code est-il valide?

C obj1(3); 
obj1=C(4); 

En supposant que C a une operator=(C) (ce qui sera par défaut), le code est valide. Ce qui va arriver c'est que dans la première ligne, obj1 est construit avec 3 comme paramètre pour le constructeur. Ensuite, sur la deuxième ligne, un objet C temporaire est construit avec 4 comme paramètre et ensuite operator= est appelé sur obj1 avec cet objet temporaire en tant que paramètre. Après cela, l'objet temporaire sera détruit. Si obj1 est dans un état non valide après l'affectation (mais pas avant), il y a probablement un problème avec operator= de C.

Mise à jour: Si x a vraiment besoin d'être un pointeur que vous avez trois options:

1. permettent à l'utilisateur au lieu du destructor décider quand la valeur de x doit être supprimée en définissant une méthode de destruction que les besoins des utilisateurs appeler explicitement. Cela causera des fuites de mémoire si l'utilisateur oublie de le faire.
2. Définissez operator= afin qu'il crée une copie de l'entier au lieu d'une copie de la valeur. Si dans votre code réel vous utilisez un pointeur vers quelque chose de beaucoup plus grand qu'un int, cela pourrait être trop cher.
3. utiliser le comptage de référence pour garder une trace nombre d'instances de C détiennent un pointeur sur le même objet et supprimer l'objet lorsque son compteur atteint 0.

Answer 2

Lorsque vous testez la valeur de obj1? Est-ce après avoir quitté la portée?

Dans votre exemple, obj1 est un objet de pile. Cela signifie que dès que vous quittez la fonction dans laquelle il a été défini, il est nettoyé (le destructeur est appelé). Essayez allouer l'objet sur le tas:

C *obj1 = new C(3); 
delete obj1; 
obj1 = new C(4);

Answer 3

NOUVEAU: Ce qui se passe est que votre destructor a deallocated la mémoire allouée par le constructeur de C (4). Ainsi, le pointeur que vous avez copié au-dessus de C (4) est un pointeur ballants-à-dire qu'il pointe encore à l'emplacement de mémoire de la mémoire désallouée

class C { 
public: 
C(int n) { 
    x = new int(n); 
} 

~C() { 
    //delete x; //Don't deallocate 
} 

void DeallocateX() 
{ 
delete x; 
} 

int getX() {return *x;} 

private: 
    int* x; 
}; 

int main(int argc, char* argv[]) 
{ 
    // Init with C(3) 
    C obj1 = C(3); 
    // Deallocate C(3) 
    obj1.DeallocateX(); 
    // Allocate memory and store 4 with C(4) and pass the pointer over to obj1 
    obj1 = C(4); 
    // Use the value 
    cout << obj1.getX() << endl; 
    // Cleanup 
obj1.DeallocateX(); 


return 0; 
} 

Answer 4

Si C contient un pointeur vers quelque chose, vous avez besoin à peu près toujours à mettre en œuvre opérateur =. Dans votre cas, il aurait cette signature

class C 
{  
    public: 
    void operator=(const C& rhs) 
    { 
     // For each member in rhs, copy it to ourselves 
    } 
    // Your other member variables and methods go here... 
}; 

Answer 5

Je ne connais pas suffisamment le C++ subtil pour expliquer le problème que vous rencontrez. Je sais, cependant, qu'il est beaucoup plus facile de s'assurer qu'un cours se comporte comme vous le souhaitez si vous suivez le Rule of Three, que le code que vous avez publié viole.En fait, il est dit que si vous définissez l'un des vous suivant devez définir les trois:

• Destructeur
• Copie constructeur
• Opérateur d'affectation

Notez également que l'opérateur d'affectation des besoins de mise en œuvre gérer correctement le cas où un objet est assigné à lui-même (soi-disant "auto-affectation"). Ce qui suit devrait fonctionner correctement (non testé):

#include <iostream> 
#include <string> 
using namespace std; 

class C { 
public: 
C(int n) { 
    x = new int(n); 
} 

C(const C &other): C(other.getX()) { } 

~C() { 
    delete x; 
} 

void operator=(const C &other) { 
    // Just assign over x. You could reallocate if you first test 
    // that x != other.x (the pointers, not contents). The test is 
    // needed to make sure the code is self-assignment-safe. 
    *x = *(other.x); 
} 

int getX() {return *x;} 

private: 
    int* x; 
}; 

void main() { 
    C obj1 = C(3); 
    obj1 = C(4); 
    cout << obj1.getX() << endl; 
} 

Answer 6

Soyez explicite au sujet de la propriété des pointeurs! auto_ptr est génial pour ça. En outre, lors de la création d'un local, ne faites pas C obj1 = C(3) qui crée deux instances de C et initialise le premier avec le constructeur de copie de la seconde.

Heed The Guru.

class C { 
public: 
    C(int n) : x(new int(n)) { } 
    int getX(){ return *x; } 
    C(const C& other) : x(new int(*other.x)){} 
    C& operator=(const C& other) { *x = *other.x; return *this; } 
private: 
    std::auto_ptr<int> x; 
}; 

int main() { 
    C obj1(3); 
    obj1 = C(4); 
    std::cout << obj1.getX() << std::endl; 
} 

Answer 7

Fondamentalement, vous essayez de redéfinir un pointeur intelligent.
Ce n'est pas trivial pour être correct pour toutes les situations.

Veuillez d'abord regarder les pointeurs intelligents disponibles dans la norme.

Une implémentation de base (qui échouera dans certaines situations (copiez l'une des normes pour en obtenir une meilleure)). Mais cela devrait couvrir les bases:

class X 
{ 
    int*  data; 

    public: 
     // Destructor obvious 
     ~X() 
     { 
      delete data; 
     } 
     // Easy constructor. 
     X(int x) 
      :data(new int(x)) 
     {} 
     // Copy constructor. 
     // Relatively obvious just do the same as the normal construcor. 
     // Get the value from the rhs (copy). Note A class is a friend of 
     // itself and thus you can access the private members of copy without 
     // having to use any accessor functions like getX() 
     X(X const& copy) 
      :data(new int(copy.x)) 
     {} 
     // Assignment operator 
     // This is an example of the copy and swap idiom. This is probably overkill 
     // for this trivial example but provided here to show how it is used. 
     X& operator=(X const& copy) 
     { 
      X tmp(copy); 
      this->swap(tmp); 
      return this; 
     } 
     // Write a swap() operator. 
     // Mark it is as no-throw. 
     void swap(X& rhs) throws() 
     { 
      std::swap(data,rhs.data); 
     } 

    };