C++学习笔记 工厂与策略

一、设计模式的分类
C++各类设计模式及实现

1.工厂模式

       工厂模式属于创建型模式，大致可以分为三类，简单工厂模式、工厂方法模式、抽象工厂模式。

enum CTYPE {coreA, coreB};

class SingleCore
{
public:
	virtual void show() = 0;
};

class SingleCoreA : public SingleCore
{
public:
	void show() {
		cout << "A";
	}
};

class SingleCoreB : public SingleCore 
{
	void show()
	{
		cout << "B" << endl;
	}
};



//class Factory
//{
//public:
//	SingleCore* f(enum CTYPE t)
//	{
//		if (t == coreA)
//			return new SingleCoreA();
//		else if (t == coreB)
//			return new SingleCoreB();
//		else
//			return NULL;
//	}
//};



//class Factory {
//public:
//	virtual SingleCore* f() = 0;
//};
//
//class FactoryA : public Factory
//{
//public:
//	SingleCoreA* f() { return new SingleCoreA; }
//};
//
//class FactoryB : public Factory
//{
//public:
//	SingleCoreB* f() { return new SingleCoreB; }
//};



class MutiCore
{
public:
	virtual void show() = 0;
};

class MutiCoreA : public MutiCore
{
public:
	void show()
	{
		cout << "MA" << endl;
	}
};

class MutiCoreB : public MutiCore
{
public:
	void show()
	{
		cout << "MB" << endl;
	}
};

class CoreFactory
{
public:
	virtual SingleCore* CreateSingleCore() = 0;
	virtual MutiCore* CreateMultiCore() = 0;
};
//工厂A，专门用来生产A型号的处理器    
class FactoryA :public CoreFactory
{
public:
	SingleCore* CreateSingleCore() { return new SingleCoreA(); }
	MutiCore* CreateMultiCore() { return new MutiCoreA(); }
};
//工厂B，专门用来生产B型号的处理器    
class FactoryB : public CoreFactory
{
public:
	SingleCore* CreateSingleCore() { return new SingleCoreB(); }
	MutiCore* CreateMultiCore() { return new MutiCoreB(); }
};

2.策略模式

策略模式是指定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。也就是说这些算法所完成的功能一样，对外的接口一样，只是各自实现上存在差异。

class ReplaceAlgorithm
{
public:
	virtual void Replace() = 0;
};

class LRU_ReplaceAlgorithm : public ReplaceAlgorithm
{
public:
	void Replace() { cout << "Least Recently Used replace algorithm" << endl; }
};

class FIFO_ReplaceAlgorithm : public ReplaceAlgorithm
{
public:
	void Replace() { cout << "First in First out replace algorithm" << endl; }
};

class Random_ReplaceAlgorithm : public ReplaceAlgorithm
{
public:
	void Replace() { cout << "Random replace algorithm" << endl; }
};


class Cache
{
private:
	ReplaceAlgorithm* m_ra;
public:
	Cache(ReplaceAlgorithm* ra) { m_ra = ra; }
	void Replace() { m_ra->Replace(); }
	~Cache() { delete m_ra; }
};

int main()
{
	Cache cache(new LRU_ReplaceAlgorithm()); //暴露了算法的定义  
	cache.Replace();
	return 0;
}


enum RA { LRU, FIFO, RANDOM }; //标签  
class Cache
{
private:
	ReplaceAlgorithm* m_ra;
public:
	Cache(enum RA ra)
	{
		if (ra == LRU)
			m_ra = new LRU_ReplaceAlgorithm();
		else if (ra == FIFO)
			m_ra = new FIFO_ReplaceAlgorithm();
		else if (ra == RANDOM)
			m_ra = new Random_ReplaceAlgorithm();
		else
			m_ra = NULL;
	}
	~Cache() { delete m_ra; }
	void Replace() { m_ra->Replace(); }
};

int main()
{
	Cache cache(LRU);
	cache.Replace();
	retrun 0;
}


//Cache需要用到替换算法  
template 
class Cache
{
private:
	RA m_ra;
public:
	Cache() { }
	~Cache() { }
	void Replace() { m_ra.Replace(); }
};

//Cache需要用到替换算法  
template 
class Cache
{
private:
	RA m_ra;
public:
	Cache() { }
	~Cache() { }
	void Replace() { m_ra.Replace(); }
};