C++设计模式（5）：抽象工厂模式

这是一系列的文章，在这些文章的开头会首先介绍这个模式，并稍加讨论。然后介绍类图、结构、以及代码。最后对这个模式进行完整的讨论，包括适用性、应用场景、优缺点、与其他模式的关系等等。

工厂方法仅仅实现了对一类数据的不同操作，也就是仅仅局限于一类，如果我们要对多类对象(不同数据)操作时，我们就得使用抽象工厂模式了。

抽象工厂：提供一个创建一系列相关或者相互依赖的对象的接口，而无须制定他们具体的类。不同于简单工厂和工厂模式，这两个模式针对相同的数据不同的操作，而抽象工厂对不同的数据有不同的操作。

抽象工厂的UML图：



结构：

这里的抽象工厂的创建就是用工厂模式实现的，就像两个工厂模式的相加。其中：

AbstractFactory：生命一个创建抽象产品对象的接口。

ConcreteFactory：实现创建具体产品对象的操作。

AbstractProduct：为一类产品对象声明一个接口。

ConcreteProduct：定义一个将被相应的具体工厂创建的产品对象，实现AbstractProduct接口。

Client仅使用由AbstractFactory和AbstractProduct类声明的接口。

代码：

class IUser
{
public:
virtual void getUser() = 0;  //纯虚接口类，抽象类
virtual void setUser() = 0;
};

class SqlUser :public IUser   //继承抽象实现sql数据库使用者的实例化
{
public:
void getUser()
{
cout << "在sql中返回user" << endl;
}
void setUser()
{
cout << "在sql中设置user" << endl;
}
};

class AccessUser :public IUser //继承抽象实现access数据库使用者的实例化
{
public:
void getUser()
{
cout << "在Access中返回user" << endl;
}
void setUser()
{
cout << "在Access中设置user" << endl;
}
};

class IDepartment  //抽象类，提供接口
{
public:
virtual void getDepartment() = 0;
virtual void setDepartment() = 0;
};

class SqlDepartment :public IDepartment  //SQL操作的实现
{
public:
void getDepartment()
{
cout << "在sql中返回Department" << endl;
}
void setDepartment()
{
cout << "在sql中设置Department" << endl;
}
};

class AccessDepartment :public IDepartment //access操作的实现
{
public:
void getDepartment()
{
cout << "在Access中返回Department" << endl;
}
void setDepartment()
{
cout << "在Access中设置Department" << endl;
}
};

class IFactory     //抽象工厂
{
public:
virtual IUser *createUser() = 0;
virtual IDepartment *createDepartment() = 0;
};

class SqlFactory :public IFactory  //抽象工厂一个实现
{
public:
IUser *createUser()
{
return new SqlUser();
}
IDepartment *createDepartment()
{
return new SqlDepartment();
}
};

class AccessFactory :public IFactory // 抽象工厂一个实现
{
public:
IUser *createUser()
{
return new AccessUser();
}
IDepartment *createDepartment()
{
return new AccessDepartment();
}
};

/*************************************************************/
//CLinet:SqlFactory和AccessFactory都依赖这个类进行转接
class DataAccess
{
private:
static string db;
//string db="access";
public:
static IUser *createUser()
{
if (db == "access")
{
return new AccessUser();
}
else if (db == "sql")
{
return new SqlUser();
}
}
static IDepartment *createDepartment()
{
if (db == "access")
{
return new AccessDepartment();
}
else if (db == "sql")
{
return new SqlDepartment();
}
}
};
string DataAccess::db = "sql";

int main3()
{
//IFactory *factory=new SqlFactory();
IFactory *factory;//抽象工厂
IUser *user;//抽象消费者
IDepartment *department;//提供的操作

factory = new AccessFactory();//基类的指针指指向派生类的对象
user = factory->createUser();//基类的指针指向派生类的对象
department = factory->createDepartment();//基类的指针指向派生类的对象

user->getUser();
user->setUser();

department->getDepartment();
department->setDepartment();

user = DataAccess::createUser(); // 静态类不需要实例化就能访问内部函数和成员
department = DataAccess::createDepartment();

user->getUser();
user->setUser();
department->getDepartment();
department->setDepartment();
cin.get();
return 0;
}

适用于：

1、一个系统要独立于它的产品的创建、组合和表示时。

2、一个系统要由多个产品系列中的一个来配置时

3、当要强调一系列相关的产品对象的设计以便进行联合使用时

4、当提供一个产品类库，只想显示他们的接口而不是实现时

应用：

去办理业务时，有不同的柜台（工厂），而不同的人办理不同的业务需要去相应的柜台，也就是说一类工厂对应一类人的一类操作（也可以是多类操作），有多个工厂就能对应多类人。而简单工厂和工厂模式是，只有一个柜台，只能是一类人的不同操作。

游戏中创建多个角色。

与其他模式的关系：

简单工厂和工厂是对一类对象的多种操作，而抽象工厂是对一组对象（有多个种类）的多种操作，且这一组对象的增加只需要增加与其对应的具体工厂。

这三种工厂模式都提供了创建对象的接口，把产品具体创建的过程给隐藏了。而工厂方法模式和抽象工厂模式还把类的实例化延迟到了子类。

且抽象工厂的实现一类与工厂方法或者简单工厂模式。