private Destruktor für die singleton-Klasse

Ist es obligatorisch, um eine private Destruktor für eine singleton-Klasse.

Nein, es ist nicht. Warum fragst du? Wer würde Sie dazu zwingen? Und Fragen, die eine ja/Nein-Antwort ist nicht eine gute Idee.
Zumindest solche Fragen kann nicht geschlossen werden, um als argumentative. :)
ist eine Last von alten Müll, hab ich Recht?" 😉
wer mit C++ mehr?"
Richtige Antworten sollten mit ja/Nein. Kein Platz für Argumente. Bin ich im Recht? :)
Wenn das singelton-Objekt gibt einen Verweis von getInstance(). Dann warum würden Sie sogar versuchen, es zu löschen? Somit Annullierung des Problems: stackoverflow.com/questions/1008019/c-singleton-design-pattern/...

InformationsquelleAutor KhanS | 2010-04-01

6

Dies ist möglicherweise nicht das was du suchst.. Aber als Referenz, verwende ich es wie folgt:
```
//.h
class Foo {
public:
    static Foo* getInstance();
    static void destroy();
private:
    Foo();
    ~Foo();

    static Foo* myInstance;
};

//.cpp
Foo* Foo::myInstance = NULL;

Foo* Foo::getInstance(){
    if (!myInstance){
        myInstance = new Foo();
    }
    return myInstance;
}
void Foo::destroy(){
    delete myInstance;
    myInstance = NULL;
}
```
Dann am Ende von meinem Programm, ich nenne zerstören Sie das Objekt. Als Péter Punkte aus das system wieder den Speicher, wenn das Programm beendet wird, so gibt es keinen wirklichen Grund. Der Grund, warum ich ein vernichten ist, wenn Oger beschwert, dass ich noch nicht veröffentlicht, die Erinnerung, die ich zugeordnet. Danach habe ich es einfach verwenden, als "gute Art", da ich gerne Aufräumen nach mir selbst.
- Wenn Sie explizit eine destroy Sie bieten auch eine undichte Abstraktion. Sie sollten nachschlagen von Alexandrescu "Modern C++ Design" und nehmen Sie inspiration in Loki::Singleton.
- Möchten Sie vielleicht, um sich registrieren zu zerstören, die mit atexit.
- Was bekomme ich von books.google.com ist, daß , wenn die Zerstörung der singleton-ich sollte es entfernen bei Anwendung Herunterfahren. Aber ich bin neugierig, was du damit meinst leaky abstraction. Sollte ich eine neue Frage, vielleicht..? 🙂 Würde es immer noch undicht, wenn ich es tun, wie Michael Aaron schlägt?
- Das problem ist, dass Sie öffnen, bis der code auf ein Leck.Die Benutzer des singelton müssen wissen, dass Sie benötigen, um es zu zerstören und fügen Sie den code an der richtigen Stelle. Im Gegensatz zu Java, C++ ermöglicht ein guter Entwickler zu, die Verantwortung zu übernehmen von der Gestaltung der Klasse, so ist es schwer zu missbrauchen (ein feature von RAII). Als Entwickler solltest du versuchen, diesen mantel zu versuchen und bauen ein singelton, die nicht erfordern, dass der Benutzer zu verstehen, die Umsetzung, um es richtig zu verwenden. Dass explizit zerstören, gibt dem Benutzer die Möglichkeit eines Missbrauchs der Klasse (nicht durch Aufruf).
- Wenn Sie müssen, Sie zu zerstören, bevor der code abgeschlossen ist, (d.h. exit() einfach nicht nicht schneiden), dann mit einer singleton nicht, was Sie wollen. Wahrscheinlich.
- ja.. in der Schule habe ich gelernt, was ich schrieb in dieser Antwort. Die letzten Monate hier SO habe, unterrichtete mich nie mit singleton wieder 😛 So ist es vielleicht nicht ein problem, nachdem alle. Trotzdem danke
- Leider, die Verwendung von singletons im code ist fast ein cargo-Kult...
InformationsquelleAutor Default
13

Wenn das singleton implementiert ist als eine variable im globalen Bereich, es muss eine öffentlichen Destruktor. Nur öffentliche Mitglieder zugänglich sind, im globalen Gültigkeitsbereich.

Wenn es deklariert als static-member oder statische lokale Variable innerhalb der eigenen Klasse, dann der Destruktor privat. Der Destruktor aufgerufen wird, von innerhalb der Klasse scope, wo es zugänglich ist, wenn das Programm beendet wird. Das ist ein Weg, um durchzusetzen das Objekt ein singleton. Brauchen Sie, um stark zu erzwingen? Wenn dem so ist, ja. Es hängt davon ab, was meinen Sie mit "Pflicht."
```
class A{
private:
    ~A() {}
public:
    static A &getGlobalA() {
        static A a2; //<- or here - better technique
        return a2;   //this is initialized upon 1st access
    };               //and destroyed on program exit

    static A a; //<- constructor, destructor accessed from here
};

A A::a; //<- but "called" from here in terms of control flow
```
- Die tatsächlichen örtlichen static ist eine der bequemste Weg. Was ist die Wirkung von aufrufen getGlobalA nach a2 zerstört wurde (während der Zerstörung von globals) ? Ich fürchte, es würde dazu führen, UB.
- m: in diesem Artikel Finden Sie eine einfache Technik, um das problem gemindert werden: stackoverflow.com/questions/335369/...
InformationsquelleAutor Potatoswatter
4

Alle Klassen einen Destruktor. Wenn Sie nicht erstellen der compiler wird es für Sie tun. Also deine Frage kann umformuliert werden zu: Ist der Destruktor für eine singleton-Klasse müssen private?

Die einfache Antwort ist Nein, es muss nicht sein.

Eine weitere interessante Frage: Ist es eine gute Idee, um den Destruktor der singleton-Klasse private?

Ja, im Allgemeinen, es ist eine gute Idee. Wenn Sie machen es die privaten dann Ihr client-code wird nicht aufgerufen der Destruktor durch Zufall. Ruft den Destruktor dazu, dass das singleton nicht für alle Kunden als Instanz wäre ungültig.
- Wenn Ihr singleton ist nie kopiert (was es nicht sein sollte, da sonst es nicht mehr ein singleton), es kann nie fallen aus dem Rahmen, was bedeutet, dass der Destruktor nie aufgerufen, an Erster Stelle (auch nicht versehentlich).
- es kann: GetSingleton()->~CSingleton()
- aber wer in Ihrem rechten Verstand würde so etwas tun? IMHO, jeder code, ruft ein Destruktor explizit und nicht mit dem placement new ist höchst verdächtig.
- oder weniger pervers: p = GetSingleton(), und /* Momma told me to always delete my pointers:*/ delete p;
- Aber ein Singleton-getter Rückgabe eines Zeiger ist einfach ein Fall von schlechtem interface-design. (Es sei denn, Sie sind in einem Umfeld, in dem eine Nackte, dumme Zeiger bedeutet "Mach dir keine sorgen über die Löschung", denn alles, was lohnt, sich Gedanken über Handling durch den smart-Pointer.) Ich würde erwarten, dass eine Singleton-getter, gib mir einen Verweis.
- Die singelton-Objekt sollte nie zurückgegeben werden getInstance() als Zeiger. Es sollte zurückgegeben werden, wie ein Verweis und dann ist dieses problem irrelevant (auch wenn es intern ist dynamisch zugewiesen, über neue einfach nur wieder eine Anspielung). Wenn man mit einer statischen Methode/variable, Funktion, dann die ganze convept tatsächlich löschen müssen entfernt wird.
- Eigentlich Neige ich dazu nie, um meine singletons, auch nicht von Referenz. Ich bevorzuge nur die Benutzer zu nennen Object::Do(foo) als Object::GetInstance().do(foo)... aber dann ist es nicht so, dass wir mit Dependency Injection da unten.
InformationsquelleAutor Mark Byers

Meiner Meinung nach, der Destruktor eine signleton sollte privat sein. Ansonsten somewone ist in der Lage, um 'löschen' für die singleton-Instanz. Ich weiß, normalerweise niemand wird es tun. Aber wenn wir darüber sprechen, Exzellenz design, es muss resistent gegen alle möglichen beabsichtigten oder unitnended Schäden.

Mit dem modernen C++ ist es erlaubt, zu erklären, auch privaten Destruktoren für statisch aufgebauten Objekte.
Hier ist mein code-snippet für Singleton:

class Singleton
{
public:
    static Singleton& GetInstance();

    //Before C++ 11 
private:
    Singleton()  {}
    ~Singleton() {}

    Singleton(const Singleton&);            //Without implementation
    Singleton& operator=(const Singleton&); //Without implementation

    //Since C++ 11
private:
    Singleton()  = default;
    ~Singleton() = default;

public:
    Singleton(const Singleton&)            = delete;
    Singleton& operator=(const Singleton&) = delete;
};

Singleton& Singleton::GetInstance()
{
    static Singleton instance;
    return instance;
}

InformationsquelleAutor Vadim Sukhorukov

2

Nicht, und in der Regel-Objekte in C++ sind nicht gegeben, privaten Destruktoren. Beachten Sie, dass Singleton bedeutet, dass es nur eine Instanz, und so ist es Aufbau, nicht Zerstörung, das muss kontrolliert /verhindert. In der Regel ein singleton einen privaten Konstruktor public destructor, eine private statische Instanz-variable, und ein public static singleton-get /"lazy construction" - Funktion, obwohl es Variationen über das Muster.

InformationsquelleAutor Michael Aaron Safyan

Können Sie wieder Referenz auf die singleton-Instanz.

class Factory : public IFactory
    {
    private:
        /**
        * This class should not be instantiated through its constructor. Since, it implements 
        * Singleton pattern.
        */
        Factory();      
    public:
        virtual ~Factory();
        /**
        * Accessor method for singleton instance.
        * \note use this static method to access to operations of this class.
        */
        static IFactory& instance(){
            if(!m_instance.get()){
                m_instance.reset(new Factory());    
            }
            return static_cast<IFactory&>(*m_instance);
        }
        /**
        * \see IFactory::create
        */
        virtual boost::shared_ptr<IConnector> create();
    private:
        /* Singleton instance */
        static boost::scoped_ptr<Factory> m_instance;

    };

Abgesehen von der Tatsache, dass die static_cast unnötig ist (Sie können implizit konvertieren von derived zu base), es ist nicht allzu schlimm. Gibt es Probleme mit dem Zugriff nach der Zerstörung, die Sie sollten versuchen zu verstehen, obwohl.
Ich sehe keine Notwendigkeit, für dynamische Schöpfung. Erstellen Sie einfach eine statische Funktion die variable und Sie haben die gleiche Funktionalität. Mit dem Vorteil, dass man Sie Steuern kann (zu einem gewissen Grad), wenn es zerstört wird, so dass Sie nicht erhalten Zugang, nachdem es zerstört wird.
ja du hast Recht aber dies ist nur ein Beispiel für die lazy-Initialisierung.
Wie eine statische variable, Funktion.

InformationsquelleAutor baris.aydinoz

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.