《大话设计模式》读书笔记之C++实现--chapter15抽象工厂模式

#include <iostream>
using namespace std;

//抽象产品类
class AbstractProduct{
public:
virtual void ProductFunction() = 0;     //子类可以重写该函数来实现不同子类的特有功能
virtual ~AbstractProduct(){}
};

//具体产品类，有实现自己功能的成员函数
class ConcreteProductA:public AbstractProduct{
public:
void ProductFunction()
{
cout << "ConcreteProductA do its function" << endl;
}
};

class ConcreteProductB:public AbstractProduct{
public:
void ProductFunction()
{
cout << "ConcreteProductB do its function" << endl;
}
};

//抽象工厂类，可以生产不同的产品
class AbstractFactory{
public:
virtual AbstractProduct* CreateProduct() = 0;
virtual ~AbstractFactory(){}
};

class ConcreteFactoryA:public AbstractFactory{
public:
AbstractProduct* CreateProduct()
{
return new ConcreteProductA();
}
};

class ConcreteFactoryB:public AbstractFactory{
public:
AbstractProduct* CreateProduct()
{
return new ConcreteProductB();
}
};

int main(int argc,char** argv)
{
AbstractFactory *factoryA = new ConcreteFactoryA();
AbstractFactory *factoryB = new ConcreteFactoryB();
AbstractProduct *productA = factoryA->CreateProduct();
AbstractProduct *productB = factoryB->CreateProduct();
productA->ProductFunction();
productB->ProductFunction();
return 0;
}

#include <iostream>
using namespace std;

class User{

};

class IUser{
public:
virtual void Insert(User user) = 0;
virtual void GetId(User user) = 0;
};

class SqlServerUser:public IUser{
public:
void Insert(User user)
{
cout << "use sqlserver insert into user" << endl;
}
void GetId(User user)
{
cout << "use sqlserver get user id " << endl;
}
};

class AccessUser:public IUser{
public:
void Insert(User user)
{
cout << "use AccessUser insert into user" << endl;
}
void GetId(User user)
{
cout << "use AccessUser get user id " << endl;
}
};

class IFactory{
public:
virtual IUser* CreateUser() = 0;
};

class SqlServerFactory:public IFactory{
public:
IUser* CreateUser()
{
return new SqlServerUser();
}
};

class AcceseFactory:public IFactory{
public:
IUser* CreateUser()
{
return new AccessUser();
}
};

int main(int argc,char** argv)
{
User user;
IFactory* access = new AcceseFactory();
IUser* accessUser = access->CreateUser();
accessUser->Insert(user);
return 0;
}

#include <iostream>
#include <string>
using namespace std;

//抽象产品类
class AbstractProduct{
public:
virtual void ProductFunction() = 0;     //子类可以重写该函数来实现不同子类的特有功能
virtual ~AbstractProduct(){}
};

//具体产品类，有实现自己功能的成员函数
class ConcreteProductA:public AbstractProduct{
public:
void ProductFunction()
{
cout << "ConcreteProductA do its function" << endl;
}
};

class ConcreteProductB:public AbstractProduct{
public:
void ProductFunction()
{
cout << "ConcreteProductB do its function" << endl;
}
};

//产品枚举类，代表不同产品
enum ProductType{
ConcreteA,
ConcreteB
};

//抽象工厂类，可以生产不同的产品
class Factory{
public:
static AbstractProduct* CreateProduct()
{
switch (m_ProductType) {
case ConcreteA:
return new ConcreteProductA();
break;
case ConcreteB:
return new ConcreteProductB();
break;
default:
return nullptr;
break;
}
}

private:
static
4000
ProductType m_ProductType;
};

//在类外初始化static数据成员并决定生成哪种产品
ProductType Factory::m_ProductType = ConcreteB;

int main(int argc,char** argv)
{
AbstractProduct *product = Factory::CreateProduct();
product->ProductFunction();
return 0;
}