工厂模式和单例模式

#include <iostream>
#include <pthread.h>

using  namespace std;

class  AbstractProductA
{
public:
    virtual   ~AbstractProductA() {}
    virtual   void  Operation() = 0;
};

class  AbstractProductB
{
public:
    virtual  ~AbstractProductB() {}
    virtual  void  Operation() = 0;
};

class AbstractFactory
{
public:
    virtual   ~AbstractFactory() {}
    virtual   AbstractProductA*  CreateProductA() = 0;
    virtual   AbstractProductB*  CreateProductB() = 0;

};

class  ProductA1 : public AbstractProductA

{

public:

   virtual  void  Operation()
    {
        printf("ProductA1\n");
    }
};

class  ProductB1 : public  AbstractProductB
{
public:
    virtual  void  Operation()
    {
        printf("ProductB1\n");
    }
};

class  ProductA2 : public AbstractProductA
{
public:
    virtual  void  Operation()
    {
        printf("ProductA2\n");
    }
};

class  ProductB2 : public AbstractProductB
{
public:
    virtual  void  Operation()
    {
        printf("ProductB2\n");
    }
};
class  Factory1 : public  AbstractFactory
{
public:
    virtual   AbstractProductA*  CreateProductA()
    {
        return  new  ProductA1();
    }
    virtual   AbstractProductB*  CreateProductB()
    {
        return  new  ProductB1();
    }
};
class  Factory2 : public  AbstractFactory
{
public:
    virtual   AbstractProductA*  CreateProductA()
    {
        return  new  ProductA2();
    }
    virtual   AbstractProductB*  CreateProductB()
    {
        return  new  ProductB2();
    }
};

class  Locker
{
public:
    Locker()
    {
        pthread_mutex_init(&m_mutex, NULL);
    }
    ~Locker()
    {
        pthread_mutex_destroy(&m_mutex);
    }
    void  Lock()
    {
        pthread_mutex_lock(&m_mutex);
    }
    void  UnLock()
    {
        pthread_mutex_unlock(&m_mutex);
    }
private:
    pthread_mutex_t  m_mutex;
};

class  Syncer 
{
public:
    Syncer(Locker& locker)
        : m_locker(locker)
    {
        m_locker.Lock();
    }
    ~Syncer()
    {
        m_locker.UnLock();
    }
private:
    Locker&  m_locker;
};

// single instance hungry
class  Singleton
{
public:
    static  Singleton*  GetInstance();
private:
    static  Singleton*  m_pInstance;
private:
    Singleton() {}
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);
};

Singleton*  Singleton::m_pInstance = new  Singleton();

Singleton*  Singleton::GetInstance()
{
    return m_pInstance;
}

// lazy
Locker locker; // global

class  Singleton_1
{
public:
    static Singleton_1*  GetInstance();
private:
    static  Singleton_1*  m_pInstance;
private:
    Singleton_1() {}
    Singleton_1(const Singleton_1&);
    Singleton_1& operator=(const Singleton_1&);
};

Singleton_1*  Singleton_1::m_pInstance = NULL;

Singleton_1*  Singleton_1::GetInstance()
{
    if (NULL == m_pInstance) {    // double locker
        Syncer sync(locker);
        if (NULL == m_pInstance) {
            m_pInstance = new  Singleton_1();
        }
    }
    return m_pInstance;
}

class  Singleton_2
{
public:
    static  Singleton_2&  GetInstance()
    {
        Syncer sync(locker);  // local static instance.
        static  Singleton_2  instance;
        return instance;

    }

private:
    Singleton_2() {}
    Singleton_2(const Singleton_2&);
    Singleton_2& operator=(const Singleton_2&);
};

int main()
{
    Singleton* instance = Singleton::GetInstance();
    if (instance) {
        printf("instance = [%p]\n", instance);
    }
    /*
    AbstractFactory*  factory = new   Factory1();
    AbstractProductA* productA = factory->CreateProductA();
    productA->Operation();
    delete productA;
    AbstractProductB* productB = factory->CreateProductB();
    productB->Operation();
    delete productB;
    delete factory;
    factory = new  Factory2();
    productA = factory->CreateProductA();
    productA->Operation();
    delete productA;
    productB = factory->CreateProductB();
    productB->Operation();
    delete productB;
    delete factory;
    */
    return 0;
}