C++工厂类和单例模式的结合使用

单例模式：

简单来说一个类只有一个实例且封装性好。这里用宏定义实现。

animal_singleton.h

#pragma once
#include <iostream>

#define IMPLEMENTION_SINGLETON_CLASS( Type ) \
public:                                      \
static Type* GetInstance()               \
{                                        \
static Type oInstance;               \
return &oInstance;                   \
}                                        \
private:                                     \
Type( const Type& )                      \
{                                        \
}                                        \
\
Type& operator= ( const Type& )          \
{                                        \
return *this;                        \
}

工厂模式：

简单来说，工厂模式减少文件之间的依赖关系，一是可以优化编译，即实现部分改变了而客户不需要重新编译自己的文件；二是实现开放和封闭原则，有利于维护和扩展。

一个animal的例子，animal作为一个接口，由cat和dog来实现，并用factory对cat和dog进行封装，客户端只要有animal接口和factory头文件即可实现cat和dog的具体内容，实现了分离并且有利于维护。

animal_interface.h

#pragma once
#include <iostream>

namespace FactoryAndInstance
{
class animalIF
{
public:
animalIF(void)
{

}
virtual ~animalIF(void)
{

}

virtual void LikeEat() = 0;
};
}

animal_cat.h

#pragma onece

#include "animal_singleton.h"
#include "animal_interface.h"

namespace FactoryAndInstance
{
class CCat:public animalIF
{
IMPLEMENTION_SINGLETON_CLASS(CCat);
public:
CCat();
~CCat();

void LikeEat();
};
}

animal_cat.cpp

#include "animal_cat.h"
#include <iostream>
using namespace std;

namespace FactoryAndInstance
{
CCat::CCat()
{

}

CCat::~CCat()
{

}

void CCat::LikeEat()
{
cout<<"cat like eating fish"<<endl;
}
}

animal_dog.h

#pragma onece

#include "animal_singleton.h"
#include "animal_interface.h"

namespace FactoryAndInstance
{
class CDog:public animalIF
{
IMPLEMENTION_SINGLETON_CLASS(CDog);
public:
CDog();
~CDog();

public:
void LikeEat();
};
}

animal_dog.cpp

#include "animal_dog.h"
#include <iostream>
using namespace std;

namespace FactoryAndInstance
{
CDog::CDog()
{

}

CDog::~CDog()
{

}

void CDog::LikeEat()
{
cout<<"dog like eating meat"<<endl;
}
}

animal_factory.h

#pragma once
#include "animal_singleton.h"

namespace FactoryAndInstance
{
class animalIF;

class CAnimalFactory
{
IMPLEMENTION_SINGLETON_CLASS(CAnimalFactory);

private:
CAnimalFactory()
{

}

public:
~CAnimalFactory()
{

}

animalIF* GetCatInstance();
animalIF* GetDogInstance();
};
}

animal_factory.cpp

#include "animal_factory.h"
#include "animal_cat.h"
#include "animal_dog.h"

namespace FactoryAndInstance
{
animalIF* CAnimalFactory::GetCatInstance()
{
return CCat::GetInstance();
}
animalIF* CAnimalFactory::GetDogInstance()
{
return CDog::GetInstance();
}
}

客户实现部分：

main

#include <iostream>
#include "animal_factory.h"
#include "string"
#include "animal_interface.h"

using namespace std;

using namespace FactoryAndInstance;
int main()
{
animalIF* pCat = CAnimalFactory::GetInstance()->GetCatInstance();
pCat->LikeEat();

animalIF* pDog = CAnimalFactory::GetInstance()->GetCatInstance();
pDog->LikeEat();

system("PAUSE");
return 0;
}