частный деструктор для одноэлементного класса

Question

Обязательно иметь частный деструктор для одноэлементного класса.

Answer 1

Это может быть не то, что вы ищете .. Но для справки, я использую его следующим образом:

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

Затем в конце моей программы, я называю уничтожить на объекте. Как указывает Петтер, система вернет память, когда ваша программа закончится, поэтому нет реальной причины. Причина, по которой я использую уничтожение, - это когда Ogre жаловался, что я не выпустил всю память, которую я выделил. После этого я просто использую его как «хорошую манеру», так как мне нравится убираться после себя.

Answer 2

Все классы имеют деструктор. Если вы его не создадите, компилятор сделает это за вас. Таким образом, ваш вопрос может быть изменен: имеет ли деструктор для одноэлементного класса частный?

Простой ответ: нет, это не обязательно.

Более интересный вопрос: полезно ли сделать деструктор одноэлементного класса частным?

Да, в общем, это хорошая идея. Если вы сделаете его приватным, то ваш клиентский код случайно не вызовет деструктора. Вызов деструктора приведет к сбою синглтона для всех клиентов, поскольку экземпляр станет недействительным.

Answer 3

Если синглтон реализован как переменная в глобальном масштабе, он должен иметь общественный деструктор. Доступны только общедоступные члены в глобальном масштабе.

Если он объявлен как статический член или статический локальный в своем собственном классе, деструктор может быть закрытым. Деструктор вызывается изнутри класса, где он доступен, когда программа выходит. Это один из способов обеспечения того, чтобы объект был одиночным. Нужно ли вам усиленно это применять? Если да, да. Это зависит от того, что вы подразумеваете под «обязательным».

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 

Answer 4

Вы можете вернуть ссылку на экземпляр singleton.

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; 

    }; 

Answer 5

Нет, и в целом объектам в C++ не предоставляются частные деструкторы. Имейте в виду, что Синглтон означает, что существует только один экземпляр, и поэтому нужно контролировать/предотвращать конструкцию, а не разрушение. Обычно singleton имеет частный конструктор, публичный деструктор, частную статическую переменную экземпляра и общедоступную статическую однопользовательскую функцию get/lazy construction, хотя на этом шаблоне есть вариации.

Answer 6

На мой взгляд, деструктор знака должен быть закрытым. В противном случае кто-то может вызвать «delete» для вашего экземпляра singleton. Я знаю, обычно никто этого не сделает. Но если мы говорим о дизайне превосходства, он должен быть устойчивым ко всем возможным предполагаемым или единичным повреждениям.

С помощью современного C++ разрешено объявлять даже частные деструкторы для статически построенных объектов. Это мой фрагмент кода для 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; 
}