Паттерн Singleton

#include "stdafx.h"
 
template <class T>
class SingletonS
{
    static int m_nCount;
    static T *m_pWork;
public:
 
    SingletonS()
    {
        if (++m_nCount == 1)
        {
            m_pWork = new T;
            cout << " Constructor Singleton typeS: " << this << endl;
        }
    }
 
    ~SingletonS()
    {
        if (--m_nCount == 0)
        {
            delete m_pWork;
            cout << " Destructor Singleton typeS: " << this << endl;
        }
    }
 
 
    T* operator ->()
    {
        return m_pWork;
    }
 
};
 
// объявляем static-переменные (шаблоны)
template <class T>
int SingletonS<T>::m_nCount;
 
template <class T>
T * SingletonS<T>::m_pWork;

#include <iostream>
#include "SingletonS.h"
 
using namespace std;
 
struct foo
{
    int Value;
    foo() : Value(0) {}
};
 
typedef SingletonS<foo> single_foo;
 
void put_value(int Value)
{
    single_foo SingleFoo;
    SingleFoo->Value = Value;
}
 
void show_value()
{
    single_foo SingleFoo;
    cout << SingleFoo->Value << endl;
}
 
int main()
{
    put_value(123);
    show_value();
    return 0;
}

#include <iostream>
#include "SingletonS.h"
 
using namespace std;
 
struct foo
{
    int Value;
    foo() : Value(0) {}
};
 
typedef SingletonS<foo> single_foo;
 
single_foo get_single()
{
    single_foo SingleFoo;
    return SingleFoo;
}
 
int main()
{
    single_foo SingleFoo = get_single();
    cout << SingleFoo->Value << endl;
    return 0;
}

SingletonS():m_nCount(0),m_pWork(0)
{
 
}

T* operator ->()
{
   if(!m_pWork)
   {
      m_pWork = new T;
      ++m_nCount;
   }
   return m_pWork;
}

T* operator ->()

static T* instance()

#include <iostream>
 
class LazySingleton { // иначе называется Meyer's singleton
private:
        LazySingleton() { std::cout << "LazySingleton ctor." << '\n'; } // чтобы посмотреть сколько раз звался ктор
        ~LazySingleton() { std::cout << "LazySingleton dtor." << '\n'; }
public:
        static LazySingleton&
        getInstance()
        {
                static LazySingleton singleton; // здесь весь сахар и происходит, статичная переменная же!
                return singleton;
        }
 
        void
        method()
        {
                std::cout << "called method" << '\n'; // какой-то метод
        }
};
 
void // какая-то функция
function()
{
        std::cout << "from function ";
        LazySingleton::getInstance().method(); // а инстанс уже создан, только позвать метод
}
 
int
main(int argc, char** argv)
{
        LazySingleton::getInstance().method(); // здесь создается инстанс и зовется его метод
        function();
        system("pause"); // проверял под вянды на msvc2013
    return 0;
}

if (!instance) { // 1й поток сделал проверку и заморозился. 2й сделал проверку и прошел её, создав инстанс
    return instance; // 1й разморозился и создал инстанс
}

if (!instance) {
     lock_mutex; // лочьте ваш любимый вид мутекса
     if (!instance) {
          pInstance = instance
     }
     unlock_mutex;
     return pInstance;
}

        void
        method()
        {
                std::cout << "called method" << '\n'; // какой-то метод
        }