饿汉模式（线程安全）

    1. class singleton
    2. {
    3. protected:
    4.     singleton()
    5.     {}
    6. private:
    7.     static singleton* p;
    8. public:
    9.     static singleton* initance();
    10.     void sayhi() {std::cout << "Hi!" << std::endl;}
    11. };
    13. singleton* singleton::p = new singleton;
    15. singleton* singleton::initance()
    16. {
    17.     return p;
    18. }
    20. int main(int argc, char* argv[]) {
    21.     singleton::initance()->sayhi();
    22. }

    懒汉模式 （c++11保证线程安全）

    1. class S
    2. {
    3.     public:
    4.         static S& getInstance()
    5.         {
    6.             static S    instance; // Guaranteed to be destroyed.
    7.                                   // Instantiated on first use.
    8.             return instance;
    9.         }
    10.     private:
    11.         S() {}                    // Constructor? (the {} brackets) are needed here.
    13.         // C++ 03
    14.         // ========
    15.         // Don't forget to declare these two. You want to make sure they
    16.         // are unacceptable otherwise you may accidentally get copies of
    17.         // your singleton appearing.
    18.         S(S const&);              // Don't Implement
    19.         void operator=(S const&); // Don't implement
    21.         // C++ 11
    22.         // =======
    23.         // We can use the better technique of deleting the methods
    24.         // we don't want.
    25.     public:
    26.         S(S const&)               = delete;
    27.         void operator=(S const&)  = delete;
    29.         // Note: Scott Meyers mentions in his Effective Modern
    30.         //       C++ book, that deleted functions should generally
    31.         //       be public as it results in better error messages
    32.         //       due to the compilers behavior to check accessibility
    33.         //       before deleted status
    34. };

    全局变量析构问题

    1. class A
    2. {
    3.     public:
    4.         // Get the global instance abc
    5.         static A& getInstance_abc()  // return a reference
    6.         {
    7.             static A instance_abc;
    8.             return instance_abc;
    9.         }
    10. };
    12. class B
    13. {
    14.     public:
    15.         static B& getInstance_Bglob;
    16.         {
    17.             static B instance_Bglob;
    18.             return instance_Bglob;;
    19.         }
    21.         ~B()
    22.         {
    23.              A::getInstance_abc().doSomthing();
    24.              // The object abc is accessed from the destructor.
    25.              // Potential problem.
    26.              // You must guarantee that abc is destroyed after this object.
    27.              // To guarantee this you must make sure it is constructed first.
    28.              // To do this just access the object from the constructor.
    29.         }
    31.         B()
    32.         {
    33.             A::getInstance_abc();
    34.             // abc is now fully constructed.
    35.             // This means it was constructed before this object.
    36.             // This means it will be destroyed after this object.
    37.             // This means it is safe to use from the destructor.
    38.         }
    39. };

    参考
    https://www.cnblogs.com/qiaoconglovelife/p/5851163.html
    https://stackoverflow.com/questions/1008019/c-singleton-design-pattern
    https://stackoverflow.com/questions/335369/finding-c-static-initialization-order-problems/335746#335746