Вызов деструктора Inherited class из singleton class C++

Question

У меня есть базовый класс, который является одноточечным и является абстрактным. Поэтому в основном я создаю экземпляр с одним из унаследованных классов. У меня есть конструктор и деструктор абстрактных как защищенный. Я хочу иметь базовый класс, где некоторые функции имеют определение, а некоторые из них являются чистыми виртуальными и подклассами, реализующими методы в этом интерфейсе, но я хочу, чтобы он был одноточечным.

#include<iostream> 
#include<bits/stdc++.h> 
using namespace std; 

class Base { 
    protected: 
     Base() {} 
     virtual ~Base() { 
      cout<< "base class destructor \n"; 
     } 
    private: 
     static Base *instance; 

    public: 
     virtual void overrideMe() = 0; 
     static Base* getinstance(const char*); 
     static void resetInstance(){ 
      delete instance; 
     } 
     virtual void testmethod(); 

}; 
class Derived1 : public Base{ 
    friend class Base; 
    protected: 
     Derived1(){ 
      cout<<" in Derived1 constructor \n"; 
     } 
     virtual ~Derived1(){ 
      cout<< "in Derived1 destructor \n"; 
     } 

    public: 
     void overrideMe(){ 
      cout<< "in Derived1 \n"; 
     } 
     void testmethod(){ 
      cout<< "testmethod of Derived1 \n "; 
      overrideMe(); 
     } 
}; 
class Derived2 : public Base{ 
    friend class Base; 
    protected: 
      Derived2(){ 
      cout<<" in Derived2 constructor \n"; 
     } 
     virtual ~Derived2(){ 
      cout<< "in Derived2 destructor \n"; 
     } 
    public: 

     void overrideMe(){ 
      cout<< "in Derived2 \n"; 
     } 
     void testmethod(){ 
      cout<< "testmethod of Derived2 \n "; 
      overrideMe(); 
     } 


}; 
Base* Base::instance = NULL; 

void Base::testmethod() { 
    cout << "Testing :)\n"; 
} 

Base* Base::getinstance(const char* type) { 
    if(instance == NULL){ 
     if(std::strcmp(type, "Derived1") == 0) 
      instance = new Derived1(); 
     if(std::strcmp(type, "Derived2") == 0) 
      instance = new Derived2(); 
    } 
    return instance; 
} 


int main() { 

    Base *instanceA = Base::getinstance("Derived1"); 
    // Derived1* ob = new Derived1(); 
    instanceA->testmethod(); 
    Base::resetInstance(); 
    return 0; 
} 

Есть ли лучший способ достичь того же, что и выше?

Answer 1

Singleton Заголовок:

#include <memory> 
#include <mutex> 

template <typename T> 
class Singleton { 
public: 
    Singleton(const Singleton&) = delete; 
    const Singleton& operator=(const Singleton&) = delete; 

    static T& getInstance() { 
    std::call_once(m_flag, [] { m_instance.reset(new T); }); 
    return *m_instance.get(); 
    } 

protected: 
    Singleton() {} 

private: 
    static std::unique_ptr<T> m_instance; 
    static std::once_flag m_flag; 
}; 

template <typename T> 
std::once_flag Singleton<T>::m_flag; 

template <typename T> 
std::unique_ptr<T> Singleton<T>::m_instance; 

Ваш класс (Singleton):

#include <iostream> 
#include "Singleton.hpp" 



class YourInterface { 
public: 
    virtual void Hello() = 0; 
    virtual ~YourInterface() {} 
}; 

class YourClass : public YourInterface, public Singleton<YourClass> { 
    friend class Singleton<YourClass>; 

public: 
    virtual void Hello() {std::cout << "Hello form YourClass\n";} 
    virtual ~YourClass(){std::cout << "Hello form Destructor\n";} 

private: 
    ~YourClass() {} 

}; 

Наконец, вы можете назвать это так:

#include "YourClass.hpp" 

int main() { 
    YourClass::getInstance().Hello(); 
    return 0; 
} 

Помните о компиляции с -pthread флагом

выхода:

Здравствуйте образует YourClass

Здравствуйте форму деструктор