Richtigen Weg zuweisen Zeiger in c++

Wenn Sie müssen freigeben der alten Instanz und weiteres erstellen, sollten Sie zuerst sicherstellen, dass die Schaffung der neuen Sache gelingt:

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

Wenn Sie den Anruf löschen zuerst, und dann eine neue erstellen eine exception wirft, dann wird die Instanz der Klasse wird ein dangling pointer. E. g, wird Ihr Destruktor am Ende vielleicht bis löschen möchten Sie den Zeiger wieder (Undefiniertes Verhalten).

Könnte man auch vermeiden, dass durch die Einstellung der Zeiger auf NULL dazwischen, aber der obige Weg ist noch besser: wenn das zurücksetzen fehlschlägt, wird das Objekt behält seine ursprüngliche Wert.

Als die Frage im code Kommentar.

*str = _str;

Wäre dies die richtige Sache zu tun. Es ist normale string-Zuweisung.

str = &_str;

Wäre dies die Zuordnung von Zeigern und völlig falsch. Sie würde Auslaufen der string-Instanz, die zuvor gezeigt, durch str. Schlimmer noch, es ist sehr wahrscheinlich, dass der string an die Funktion übergeben ist nicht zugeordnet mit new im ersten Ort (sollten Sie sich nicht mischen Zeiger auf dynamisch reservierten und automatische Objekte). Darüber hinaus könnten Sie speichern die Adresse einer string-Objekt, dessen Lebensdauer endet mit dem Aufruf der Funktion (wenn die const-Referenz gebunden ist, um eine vorübergehende).

Nur pinpointing hier, aber

str = _str;

würde nicht kompiliert (die Sie versuchen zu ordnen _str, das ist der Wert, der ein string übergeben durch Verweis auf str, das ist die Adresse der Zeichenkette). Wenn Sie das tun wollten, würden Sie schreiben :

str = &_str;

(und das hätte man ändern können _str oder str, so dass die constnest entspricht).

Aber dann, wie Sie Ihre intuition sagte Ihnen, Sie würden zugespielt haben, die Erinnerung an was auch immer string-Objekt wurde bereits gezeigt, durch str.

Wie bereits erwähnt, wenn Sie eine variable hinzufügen, um eine Klasse in C++, Sie müssen denken, ob die variable ist im Besitz des Objektes, oder durch etwas anderes.

Wenn es im Besitz des Objekt -, als Sie wahrscheinlich besser dran mit speichern Sie es als einen Wert und kopieren von Sachen um (aber dann müssen Sie sicherstellen, dass Kopien passieren nicht im Rücken).

Es ist nicht im Besitz, dann speichern Sie es als ein Zeiger, und Sie müssen nicht unbedingt kopiert werden muss, um die Dinge die ganze Zeit.

Anderen Menschen erklären das besser als ich, denn ich bin nicht wirklich komfortabel mit es.
Was ich am Ende tun eine Menge schreiben Sie code wie diesen :

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;
   }

Ist, dass, wenn ein Objekt hängt etwas in der 'Java' /'Ioc' Sinn (die Objekte, die anderswo existiert, sind Sie nicht erstellen Sie es, und Sie will nur das call-Methode), würde ich speichern, die Abhängigkeit als eine Referenz, mit dep_xxxx.

Wenn ich das Objekt erstellen, würde ich einen Zeiger, der mit einem Präfix p_.

Dies ist nur um den code mehr "sofort". Nicht sicher, ob es hilft.

Nur meine 2c.

Glück mit dem memory-mgt, du hast Recht, dass es ist der schwierige Teil kommen, von Java ; nicht mit dem schreiben von code, bis Sie sind komfortabel, oder du wirst Stunden damit verbringen, zu jagen segaults.

In der Hoffnung, das hilft !

Werde ich nur schreiben Klasse.

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; }
}

Für Klassen, die die Ressourcen enthalten, wie diese, die Kopie-Konstruktor, Zuweisungsoperator und Destruktor sind alle notwendig. Der schwierige Teil der copy-Konstruktor und Zuweisungs-operator ist, dass Sie brauchen, um zu löschen Foo genau einmal. Wenn der copy-Konstruktor-Initialisierung hatte, sagte :foo(a.foo), insbesondere dann, dass Foo würde gelöscht, wenn das Objekt initialisiert wurde zerstört und einmal, wenn das Objekt initialisiert (a) zerstört wurde.

Die Klasse, die Art, wie ich geschrieben habe, es muss dokumentiert werden, wie die Eigenverantwortung der Foo pointer wird übergeben, weil Foo * f = new Foo(); A a(f); delete f; wird auch dazu führen, doppelte löschen.

Anderen Weg, das zu tun, wäre die Verwendung von Boost smart-Pointer (die waren der Kern der nächste standard ist smart Pointer) und haben boost::shared_ptr<Foo> foo; statt Foo * f; in der definition der Klasse. In diesem Fall wird der copy Konstruktor sein sollte A(const A &a):foo(a.foo) {}, da die smart-pointer kümmert löschen der Foo wenn alle Kopien der shared pointer auf ihn hinweisen, sind zerstört. (Es gibt Probleme, man kann in hier auch, besonders wenn Sie mischen shared_ptr<>s mit jeder anderen form der Zeiger, aber wenn man sich an shared_ptr<> während Sie sollten OK sein.)

Anmerkung: ich Schreibe dies, ohne läuft es durch einen compiler. Ich bin mit dem Ziel für Genauigkeit und gutem Stil (wie die Verwendung von Initialisierungen im Konstruktor). Wenn jemand ein problem findet, bitte kommentieren.

Wenn Sie neu zuordnen, die einen Zeiger auf ein neues Objekt werden müssen, rufen Sie löschen auf das alte Objekt zunächst um Speicherlecks zu vermeiden? Meine intuition sagt mir ja, aber ich will eine konkrete Antwort, bevor Sie fortfahren.

Ja. Wenn es ein raw-pointer, müssen Sie löschen Sie das alte Objekt zunächst.

Gibt es smart-pointer-Klassen, die dies für Sie tun, wenn Sie einen neuen Wert zuweisen.