Bonne façon de réaffecter les pointeurs en c++

Si vous devez libérer de l'ancienne instance et en créer un autre, vous devez d'abord assurez-vous que la création du nouvel objet réussit:

void reset(const std::string& str)
{
    std::string* tmp = new std::string(str);
    delete m_str;
    m_str = tmp;
}

Si vous appelez supprimer la première, puis la création d'une nouvelle déclenche une exception, alors l'instance de classe serez à gauche avec une balançant pointeur. E. g, votre destructeur pourrait essayer de supprimer le pointeur de nouveau (comportement indéfini).

Vous pourriez aussi éviter que par le réglage de pointeur NULL dans un entre-deux, mais la façon décrite ci-dessus est encore mieux: si la réinitialisation échoue, l'objet garde sa valeur d'origine.

---

Quant à la question dans le commentaire de code.

*str = _str;

Ce serait la bonne chose à faire. Il est normal que la chaîne de cession.

str = &_str;

Ce serait affectation de pointeurs et complètement faux. Vous serait fuite de la chaîne d'instance précédemment souligné par str. Pire encore, il est très probable que la chaîne de caractères passée à la fonction n'est pas alloué avec new en premier lieu (vous ne devriez pas être un mélange des pointeurs vers attribuées de manière dynamique et automatique des objets). En outre, vous pouvez stocker l'adresse d'une chaîne d'objets dont la durée de vie se termine avec l'appel de la fonction (si la const de référence est lié à une temporaire).

Juste pointer ici, mais

str = _str;

ne serait pas compiler (que vous essayez d'attribuer _str, qui est la valeur d'une chaîne de caractères passée par référence, à la str, qui est l'adresse d'une chaîne). Si vous vouliez faire, vous écrivez :

str = &_str;

(et vous auriez à changer _str ou str, de sorte que le constnest matches).

Mais alors, que votre intuition vous dit, vous auriez fui la mémoire de la chaã objet a été déjà souligné par str.

Comme indiqué précédemment, lorsque vous ajoutez une variable à une classe en C++, vous devez penser si la variable est la propriété de l'objet, ou par quelque chose d'autre.

Si elle est détenue par l'objet, que vous êtes probablement mieux avec les stocker en tant que valeur, et la copie de trucs autour (mais alors vous devez vous assurer que les copies ne se produisent pas dans votre dos).

Il est n'est pas la propriété, alors vous pouvez le stocker en tant que pointeur, et vous n'avez pas nécessairement besoin de faire des copies tout le temps.

D'autres personnes vous expliquera cela mieux que moi, parce que je ne suis pas vraiment à l'aise avec elle.
Ce que j'ai fini par faire un lot est de l'écriture de code comme ceci :

class Foo {

private :
   Bar & dep_bar_;
   Baz & dep_baz_;

   Bing * p_bing_;

public:
   Foo(Bar & dep_bar, Baz & dep_baz) : dep_bar_(dep_bar), dep_baz_(dep_baz) {
       p_bing = new Bing(...);
   }

   ~Foo() {
     delete p_bing;
   }

Qui est, si un objet dépend de quelque chose dans le "Java" /" Cio " du sens (l'existence d'objets d'ailleurs, vous n'êtes pas créer, et vous veut seulement appel de méthode), je voudrais stocker la dépendance comme une référence, à l'aide de dep_xxxx.

Si je crée l'objet, je voudrais utiliser un pointeur, avec un p_ préfixe.

C'est juste pour rendre le code plus "immédiate". Pas sûr que ça aide.

Juste mon 2c.

Bonne chance avec la mémoire intégrée, vous avez raison, c' est la partie la plus délicate à venir de Java ; ne pas écrire de code jusqu'à ce que vous êtes à l'aise, ou vous allez passer des heures à chasser segaults.

En espérant que cela aide !

Je vais juste écrire une classe pour vous.

class A
{
     Foo * foo;   //private by default
 public:
     A(Foo * foo_): foo(foo_) {}
     A(): foo(0) {}   //in case you need a no-arguments ("default") constructor
     A(const A &a):foo(new Foo(a.foo)) {}   //this is tricky; explanation below
     A& operator=(const &A a) { foo = new Foo(a.foo); return *this; }
     void setFoo(Foo * foo_) { delete foo; foo = foo_; }
     ~A() { delete foo; }
}

Pour les classes qui disposent de ressources comme cela, le constructeur de copie, opérateur d'affectation, et le destructeur sont tous nécessaires. La partie la plus délicate du constructeur de copie et l'opérateur d'affectation est que vous devez supprimer chaque Foo précisément la fois. Si le constructeur de copie d'initialiseur avait dit :foo(a.foo), notamment alors que Foo serait supprimé une fois l'objet en cours d'initialisation a été détruit et une fois lorsque l'objet est initialisé à partir d' (a) a été détruit.

La classe, la façon dont je l'ai écrit, doit être documentée de la prise de possession de la Foo pointeur c'est passé, parce que Foo * f = new Foo(); A a(f); delete f; entraîne également la double suppression.

Une autre façon de le faire serait d'utiliser des pointeurs intelligents de Boost (qui ont été au cœur de la prochaine norme de pointeurs intelligents) et ont boost::shared_ptr<Foo> foo; au lieu de Foo * f; dans la définition de classe. Dans ce cas, le constructeur de copie doit être A(const A &a):foo(a.foo) {}, depuis le pointeur intelligent prendra soin de la suppression de la Foo lorsque toutes les copies du pointeur partagé le montrant du doigt, sont détruits. (Il y a des problèmes, vous pouvez obtenir dans ici, trop, surtout si vous mélangez shared_ptr<>s avec toute autre forme de pointeur, mais si vous vous en tenez à shared_ptr<> à travers vous devriez être OK.)

Note: j'ai écris ce, sans procéder à un compilateur. Je vise la précision et le bon style (telles que l'utilisation des initialiseurs dans les constructeurs). Si quelqu'un trouve un problème, s'il vous plaît commentaire.

Lorsque vous réaffectez un pointeur vers un nouvel objet, vous devez appeler delete sur l'ancien objet en premier pour éviter une fuite de mémoire? Mon intuition me dit que oui, mais je veux une réponse concrète avant de passer.

Oui. Si c'est un pointeur brut, vous devez supprimer l'ancien premier objet.

Il y a de pointeur intelligent de classes qui vont le faire pour vous lorsque vous attribuer une nouvelle valeur.