シングルトンクラスからInheritedクラスのデストラクタを呼び出す

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

シングルトンヘッダー：

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

あなたのクラス（シングルトン）：

#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

こんにちはフォームデストラクタ