Verwenden intelligenter Zeiger für Klassenmitglieder

Ich habe Probleme, die Verwendung intelligenter Zeiger als Klassenmitglieder in C ++ 11 zu verstehen. Ich habe viel über intelligente Zeiger gelesen und glaube zu verstehen, wie unique_ptrund shared_ptr/ oder wie ich weak_ptrim Allgemeinen arbeite. Was ich nicht verstehe, ist die tatsächliche Verwendung. Es scheint, als würde jeder empfehlen unique_ptr, fast immer den Weg zu gehen. Aber wie würde ich so etwas umsetzen:

class Device {
};

class Settings {
    Device *device;
public:
    Settings(Device *device) {
        this->device = device;
    }

    Device *getDevice() {
        return device;
    }
};    

int main() {
    Device *device = new Device();
    Settings settings(device);
    // ...
    Device *myDevice = settings.getDevice();
    // do something with myDevice...
}

Angenommen, ich möchte die Zeiger durch intelligente Zeiger ersetzen. A unique_ptrwürde wegen nicht funktionieren getDevice(), oder? Das ist also die Zeit, in der ich shared_ptrund benutze weak_ptr? Keine Möglichkeit zu benutzen unique_ptr? Scheint mir, dass es in den meisten Fällen shared_ptrsinnvoller ist, wenn ich keinen Zeiger in einem wirklich kleinen Bereich verwende?

class Device {
};

class Settings {
    std::shared_ptr<Device> device;
public:
    Settings(std::shared_ptr<Device> device) {
        this->device = device;
    }

    std::weak_ptr<Device> getDevice() {
        return device;
    }
};

int main() {
    std::shared_ptr<Device> device(new Device());
    Settings settings(device);
    // ...
    std::weak_ptr<Device> myDevice = settings.getDevice();
    // do something with myDevice...
}

Ist das der richtige Weg? Vielen Dank!

A unique_ptrwürde wegen nicht funktionieren getDevice(), oder?

Nein, nicht unbedingt. Hierbei ist es wichtig, die geeignete Eigentumsrichtlinie für Ihr DeviceObjekt zu bestimmen , dh wer der Eigentümer des Objekts sein wird, auf das Ihr (intelligenter) Zeiger zeigt.

Wird es nur die Instanz des SettingsObjekts sein ? Wird das DeviceObjekt zerstört werden müssen , automatisch , wenn das SettingsObjekt zerstört wird, oder sollte es das Objekt überleben?

Im ersten Fall std::unique_ptrbenötigen Sie Folgendes, da es Settingsden einzigen (eindeutigen) Eigentümer des spitzen Objekts und das einzige Objekt darstellt, das für dessen Zerstörung verantwortlich ist.

Unter dieser Annahme getDevice()sollte ein einfacher Beobachtungszeiger zurückgegeben werden (Beobachtungszeiger sind Zeiger, die das spitze Objekt nicht am Leben erhalten). Die einfachste Art, einen Zeiger zu beobachten, ist ein Rohzeiger:

#include <memory>

class Device {
};

class Settings {
    std::unique_ptr<Device> device;
public:
    Settings(std::unique_ptr<Device> d) {
        device = std::move(d);
    }

    Device* getDevice() {
        return device.get();
    }
};

int main() {
    std::unique_ptr<Device> device(new Device());
    Settings settings(std::move(device));
    // ...
    Device *myDevice = settings.getDevice();
    // do something with myDevice...
}

[ ANMERKUNG 1: Sie fragen sich vielleicht, warum ich hier Rohzeiger verwende, wenn alle immer wieder sagen, dass Rohzeiger schlecht, unsicher und gefährlich sind. Eigentlich ist das eine wertvolle Warnung, aber es ist wichtig, sie in den richtigen Kontext zu stellen: Rohzeiger sind schlecht, wenn sie für die manuelle Speicherverwaltung verwendet werden , dh für das Zuweisen und Freigeben von Objekten durch newund delete. Wenn es nur als Mittel verwendet wird, um eine Referenzsemantik zu erreichen und nicht besitzende, beobachtende Zeiger weiterzugeben, gibt es in rohen Zeigern nichts an sich Gefährliches, außer vielleicht der Tatsache, dass man darauf achten sollte, einen baumelnden Zeiger nicht zu dereferenzieren. - ENDE ANMERKUNG 1 ]

[ ANMERKUNG 2: Wie in den Kommentaren festgestellt wurde , könnte (und sollte) in diesem speziellen Fall, in dem der Besitz eindeutig ist und das besessene Objekt immer vorhanden sein wird (dh das interne Datenelement devicewird es niemals sein nullptr), funktionieren getDevice()(und sollte es vielleicht). Geben Sie eine Referenz anstelle eines Zeigers zurück. Obwohl dies zutrifft, habe ich beschlossen, hier einen Rohzeiger zurückzugeben, da dies eine kurze Antwort war, die man auf den Fall verallgemeinern könnte, in dem dies devicemöglich ist nullptr, und um zu zeigen, dass Rohzeiger in Ordnung sind, solange man sie nicht verwendet manuelle Speicherverwaltung. - ENDE ANMERKUNG 2 ]

Die Situation ist natürlich radikal anders, wenn Ihr SettingsObjekt nicht das ausschließliche Eigentum an dem Gerät haben sollte. Dies könnte beispielsweise der Fall sein, wenn die Zerstörung des SettingsObjekts nicht auch die Zerstörung des spitzen DeviceObjekts implizieren sollte .

Dies können nur Sie als Designer Ihres Programms sagen. Anhand des von Ihnen angegebenen Beispiels fällt es mir schwer zu sagen, ob dies der Fall ist oder nicht.

Um dies herauszufinden, können Sie sich fragen, ob es andere Objekte Settingsgibt, die berechtigt sind, das DeviceObjekt am Leben zu erhalten, solange sie einen Zeiger darauf halten, anstatt nur passive Beobachter zu sein. Wenn dies tatsächlich der Fall ist, benötigen Sie eine Richtlinie für gemeinsames Eigentum , die Folgendes std::shared_ptrbietet:

#include <memory>

class Device {
};

class Settings {
    std::shared_ptr<Device> device;
public:
    Settings(std::shared_ptr<Device> const& d) {
        device = d;
    }

    std::shared_ptr<Device> getDevice() {
        return device;
    }
};

int main() {
    std::shared_ptr<Device> device = std::make_shared<Device>();
    Settings settings(device);
    // ...
    std::shared_ptr<Device> myDevice = settings.getDevice();
    // do something with myDevice...
}

Beachten Sie, dass dies weak_ptrein Beobachtungszeiger ist , kein besitzender Zeiger - mit anderen Worten, er hält das spitze Objekt nicht am Leben, wenn alle anderen besitzenden Zeiger auf das spitze Objekt den Gültigkeitsbereich verlassen.

Der Vorteil weak_ptrgegenüber einem normalen Rohzeiger ist , dass man sicher sagen kann , ob weak_ptrsie baumelt oder nicht (dh ob er auf ein gültiges Objekt zeigt, oder wenn das Objekt ursprünglich zeigt auf zerstört worden ist ). Dies kann durch Aufrufen der expired()Member-Funktion für das weak_ptrObjekt erfolgen.

class Device {
};

class Settings {
    std::shared_ptr<Device> device;
public:
    Settings(const std::shared_ptr<Device>& device) : device(device) {

    }

    const std::shared_ptr<Device>& getDevice() {
        return device;
    }
};

int main()
{
    std::shared_ptr<Device> device(new Device());
    Settings settings(device);
    // ...
    std::shared_ptr<Device> myDevice(settings.getDevice());
    // do something with myDevice...
    return 0;
}

week_ptrwird nur für Referenzschleifen verwendet. Der Abhängigkeitsgraph muss ein azyklisch gerichteter Graph sein. In gemeinsam genutzten Zeigern gibt es 2 Referenzzählungen: 1 für shared_ptrs und 1 für alle Zeiger ( shared_ptrund weak_ptr). Wenn alle shared_ptrs entfernt sind, wird der Zeiger gelöscht. Wenn ein Zeiger von benötigt wird weak_ptr, locksollte verwendet werden, um den Zeiger zu erhalten, falls vorhanden.