设计模式系列之单例模式——未完待续

#ifndef DESIGNMODE_H
#define DESIGNMODE_H

#include "Common.h"


// 工厂模式
class Test_Factory
{
public:
	//static Test_Factory *eu ;
	//static int i =0;
	virtual void trycout() =0;//{ cout<<"i am executed!"<<endl;}
	static Test_Factory *get(){
	// i = 0;
		static Test_Factory *eu = 0;
			if( !eu ){
				//eu = new Test_Factory;
				return eu;
			}
	}
	void abc()
	{
		if( 1 ){
			int i = 123;
			cout<< i<<endl;
		}
		//cout<<"another "<<i<<endl;
	}
	//cout<<"outer i "<<i<<endl;
};

void Test_F();

enum CTYPE { COREA,COREB };
class SingleCore
{
public:
	virtual void show() = 0;
};
class SingleCoreA:public SingleCore
{
public:
	void show() { cout<<"SingleCore A"<<endl; }
};
class SingleCoreB:public SingleCore
{
public:
	void show(){ cout<<"SingleCore B"<<endl; }
};

class Factory
{
public:
	SingleCore * CreateSingleCore( enum CTYPE ctype )
	{
		if( ctype == COREA )
			return new SingleCoreA();
		else if( ctype == COREB )
			return new SingleCoreB();
		else
			return NULL;
	}
};

class Factory_1
{
public:
	virtual SingleCore * CreateSingleCore() = 0;
};

class Factory_1A:public Factory_1
{
public:
	SingleCoreA *CreateSingleCore(){
		return new SingleCoreA;
	}
};

class Factory_1B:public Factory_1
{
public:
	SingleCoreB *CreateSingleCore(){
		return new SingleCoreB;
	}
};

class MultiCore
{
public:
	virtual void show() = 0;
};
class MultiCoreA : public MultiCore
{
public:
	void show() { cout<<"Multi Core A"<<endl;}
};
class MultiCoreB : public MultiCore
{
public:
	void show() { cout<<"Multi Core B"<<endl;}
};
class CoreFactory
{
public:
	virtual SingleCore * CreateSingleCore() = 0;
	virtual MultiCore * CreateMultiCore() = 0;
};

class FactoryA :public CoreFactory
{
public:
	SingleCore *CreateSingleCore(){ return new SingleCoreA(); }
	MultiCore *CrateMultiCore(){ return new MultiCoreA(); }
};

class FactoryB:public CoreFactory
{
public:
	SingleCore *CreateSingleCore() { return new SingleCoreB(); }
	MultiCore *CreateMultiCore() { return new MultiCoreB(); }
};

//单例模式
/* 单例模式设计的总结：
 * 1、首先，控制对象产生的源头。即保证这个类的“构造函数是私有”的，这样就“无法在类外面构造这个类的对象”。
 * 2、那只有在类的内部函数中产生这个对象，并返回指针，这个指针也是私有的，使得外部就无法对其进行操作。
 * 3、然后，这个“指针必须要是静态的”，这才是保证实例唯一性的关键因素。因为它不属于对象，对实例来说它是唯一的，所以可以利用它来判断计数。
 * 4、产生这个对象的函数要是静态的，因为，《在这里再重温一下静态成员函数的功能》
 * 5、静态成员函数：
 */

/*
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
class Singlenton
{
public:
	static Singleton * instance();
private:
	Singleton *p;
	static Lock lock;
}

Singleton *Singleton::instance()
{
	lock.getlock();
	if( !p )
		p = new Singleton;
	p = new Singleton;
	lock.unlock();
	return p;
}*/
// 下面这个类：CSingleton_1
// 唯一实例类在静态成员函数中隐藏创建实例的操作。
// 习惯上，把这个成员函数叫做Instance(),它返回值是一个唯一实例的指针。
class CSingleton_1
{
private:
	CSingleton_1(){}
	static CSingleton_1 *m_pInstance;
public:
	static CSingleton_1 *GetInstance()
	{
		if( m_pInstance == NULL )
			m_pInstance = new CSingleton_1();
		return m_pInstance;
	}
};

// 下面这个类：CSingleton_2
// 让这个类自己知道在合适的时候把自己删除，或者说把删除自己的操作
// 挂在操作系统中的某个合适的点上，使其在恰当的时候被自动执行。
// 我们都知道，程序在结束的时候，系统会自动析构所有的全局变量。事实上，
// 系统也会析构所有的类的静态成员变量，就像这些静态成员也是全局变量一样。
// 利用这个特征，我们可以在单例类中定义一个这样的静态成员变量，而它唯一的工作
// 就是在析构函数中删除单例类的实例。
class CSingleton_2
{
private:
	CSingleton_2(){}
	static CSingleton_2 *m_pInstance;
	class CGarbo{
	public:
		~CGarbo(){
			if( CSingleton_2::m_pInstance)
				delete CSingleton_2::m_pInstance;
		}
	};
	static CGarbo Garbo;
public:
	static CSingleton_2 *GetInstance()
	{
		if( m_pInstance == NULL )
			m_pInstance = new CSingleton_2();
		return m_pInstance;
	}
};

class CSingleton_3
{
private:
	CSingleton_3(){}
public:
	static CSingleton_3 *GetInstance()
	{
		static CSingleton_3 instance;
		return &instance;
	}
};

///文件测试代码//
void DesignModeTest();

#endif

#include "DesignMode.h"


void DesignModeTest()
{
Test_F();
}


// 工厂模式的测试
//Test_Factory * Test_Factory::eu = 0 ;
void Test_F()
{
//for( int i = 0; i < 100; i++ )
//Test_Factory *t = Test_Factory::get();
//Test_Factory::trycout();
}