【设计】工厂模式--C++源代码（VS2015）

1. 简单工厂模式--添加新产品需要修改类Factory，违背的类的封装性原则

#include <iostream>

#include <vector>
using namespace std;


class Product
{
public :
virtual void Show() = 0;
};


class ProductA : public Product
{
public :
void Show()
{
cout << "it is Product A" << endl;
}
};


class ProductB : public Product
{
public:
void Show()
{
cout << "it is Product B" << endl;
}
};


class Factory
{
public:
Product *CreateProduct(const char *ch)
{
if (!strcmp(ch, "ProductA"))
{
return new ProductA;
}
else if (!strcmp(ch, "ProductB"))
{
return new ProductB;
}
else
{
cout << "pls input a right product type" << endl;
return NULL;
}
}
};


int main()
{
Factory* Fac = new Factory();
//工厂制造A产品
Product* Pro_A = Fac->CreateProduct("ProductA");
Pro_A->Show();
//工厂制造B产品
Product* Pro_B = Fac->CreateProduct("ProductB");
Pro_B->Show();
system("pause");
return 0;

}

2. 工厂模式--每增加一个新的产品形态就需要增加一个Factory类

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


class Product
{
public :
virtual void Show() = 0;
};


class ProductA : public Product
{
public :
void Show()
{
cout << "it is Product A" << endl;
}
};


class ProductB : public Product
{
public:
void Show()
{
cout << "it is Product B" << endl;
}
};


class Factory
{
public:
virtual Product *CreateProduct() = 0;
};


class Factory_A : public Factory
{
public :
Product* CreateProduct()
{
return new ProductA;
}
};


class Factory_B : public Factory
{
public:
Product* CreateProduct()
{
return new ProductB;
}
};


int main()
{
//工厂制造A产品
Factory* Fac_A = new Factory_A();
Product* Pro_A = Fac_A->CreateProduct();
Pro_A->Show();
//工厂制造B产品
Factory* Fac_B = new Factory_B();
Product* Pro_B = Fac_B->CreateProduct();
Pro_B->Show();
system("pause");
return 0;
}

3. 抽象工厂模式--A工厂制造A类产品，B工厂制造B类产品

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


class Product_1
{
public :
virtual void Show() = 0;
};


class Product_A1 : public Product_1
{
public :
void Show()
{
cout << "it is Product A1" << endl;
}
};


class Product_B1 : public Product_1
{
public:
void Show()
{
cout << "it is Product B1" << endl;
}
};


class Product_2
{
public:
virtual void Show() = 0;
};


class Product_A2 : public Product_2
{
public:
void Show()
{
cout << "it is Product A2" << endl;
}
};


class Product_B2 : public Product_2
{
public:
void Show()
{
cout << "it is Product B2" << endl;
}
};


class Factory
{
public:
virtual Product_1 *CreateProduct_1() = 0;
virtual Product_2 *CreateProduct_2() = 0;
};


class Factory_A : public Factory
{
public :
Product_1* CreateProduct_1()
{
return new Product_A1;
}
Product_2* CreateProduct_2()
{
return new Product_A2;
}
};


class Factory_B : public Factory
{
public:
Product_1* CreateProduct_1()
{
return new Product_B1;
}
Product_2* CreateProduct_2()
{
return new Product_B2;
}
};


int main()
{
//工厂制造A1产品
Factory* Fac_A1 = new Factory_A();
Product_1* Pro_A1 = Fac_A1->CreateProduct_1();
Pro_A1->Show();


//工厂制造A2产品
Factory* Fac_A2 = new Factory_A();
Product_2* Pro_A2 = Fac_A2->CreateProduct_2();
Pro_A2->Show();


//工厂制造B1产品
Factory* Fac_B1 = new Factory_B();
Product_1* Pro_B1 = Fac_B1->CreateProduct_1();
Pro_B1->Show();


//工厂制造B2产品
Factory* Fac_B2 = new Factory_B();
Product_2* Pro_B2 = Fac_B2->CreateProduct_2();
Pro_B2->Show();
system("pause");
return 0;
}