Singleton

Singleton

#include <iostream>

namespace ImplMethod1 {

// Singleton template implementation: Method 1
template <typename T>
class Singleton {
public:
     static T* GetInstance() {
         // You can consider thread-safe here if you will
         static T* s_ptr =  new T;
         return s_ptr;
    }

private:
    Singleton() {};
     virtual ~Singleton() {};
    Singleton( const Singleton&);
    Singleton&  operator=( const Singleton&);
};

// How use it
class MyClass {
public:
     void func() {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }

private:
    friend  class Singleton<MyClass>;
    MyClass() {};
    ~MyClass() {};
    MyClass( const MyClass&);
    MyClass&  operator=( const MyClass&);
};

}  //  end of namespace ImplMethod1

// ---------------------------------------------------------------------------

namespace ImplMethod2 {

// Singleton template implementation: Method 2
template <typename T>
class Singleton {
public:
     static T* GetInstance() {
         // You can consider thread-safe here if you will
         static T* s_ptr =  new T;
         return s_ptr;
    }

protected:
    Singleton() {};
     virtual ~Singleton() {};

private:
    Singleton( const Singleton&);
    Singleton&  operator=( const Singleton&);
};

// How use it
class MyClass:  public Singleton<MyClass> {
public:
     void func() {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }

private:
    friend  class Singleton<MyClass>;
    MyClass() {};
    ~MyClass() {};
};

}  //  end of namespace ImplMethod2

// ---------------------------------------------------------------------------

namespace ImplMethod3 {

// Singleton template implementation: Method 3
class LazyInstantiation {
protected:
    template <typename T>
     static T* CreateInstance(T* dummy) {
         // You can consider thread-safe here if you will
         return  new T;
    }
     virtual ~LazyInstantiation() {};
};

template <typename T, typename InstantiationPolicy = LazyInstantiation>
class Singleton :  public InstantiationPolicy {
public:
     static T* GetInstance() {
         // You can consider thread-safe here if you will
         static T* s_ptr = InstantiationPolicy::CreateInstance((T*)NULL);
         return s_ptr;
    }

protected:
    Singleton() {};
     virtual ~Singleton() {};

private:
    Singleton( const Singleton&);
    Singleton&  operator=( const Singleton&);
};

// How use it
class MyClass:  public Singleton<MyClass> {
public:
     void func() {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }

private:
    friend  class LazyInstantiation;
    MyClass() {};
    ~MyClass() {};
};

}  //  end of namespace ImplMethod3

// ---------------------------------------------------------------------------

/* *
 * 分析：
 * 方法1不需要继承，但不能直观的通过MyClass::GetInstance来获取实例，且在MyClass里需要将拷贝构造以及operator=声明为private；
 * 方法2通过继承的方式，比方法1好；
 * 方法3在方法2的基础上，进行了巧妙的扩展，可以让用户自定InstantiationPolicy，可以支持一些有特殊构造函数的类；
 *
 * 结论：
 * 综合来看，方法2简单易用，方法3实现成本稍高，但比方法2又精进了一步。
  */
int main( int argc,  char* argv[]) {
    ImplMethod1::MyClass* p1 = ImplMethod1::Singleton<ImplMethod1::MyClass>::GetInstance();
    p1->func();

    ImplMethod2::MyClass* p2 = ImplMethod2::MyClass::GetInstance();
    p2->func();

    ImplMethod3::MyClass* p3 = ImplMethod3::MyClass::GetInstance();
    p3->func();
     return 0;
}