Gof 设计模式 创建型

#include<iostream>
using namespace std;

#if 0
class A{
public:
virtual void test()
{
cout << "test A" << endl;
}
};

class B{
public:
virtual void test()
{
cout << "test B" << endl;
}
};

class C :public A, public B
{

};
int main()
{
cout << sizeof(C) << endl;
int ar[100];
delete ar;
return 0;
}
#endif
//单例模式
#if 0
class singleclass
{
public:
static singleclass *getobject()
{
//lock();
if (ms == NULL)
{
ms = new singleclass();
}
//unlock();
return ms;
}
void test()
{
cout << "singleclass" << endl;
}
private:
singleclass(){}
static singleclass *ms;
};
singleclass* singleclass::ms = NULL;

int main()
{
singleclass *p = singleclass::getobject();
p->test();
return 0;
}
#endif

//          原型模式
//原型模式是创建型模式的一种,
//其特点在于通过“复制”一个已经存在的实例来返回新的实例,而不是新建实例。
//被复制的实例就是我们所称的“原型”，这个原型是可定制的。
//原型模式多用于创建复杂的或者耗时的实例，
//因为这种情况下，复制一个已经存在的实例使程序运行更高效；
//或者创建值相等，只是命名不一样的同类数据
#if 0
class Resume
{
protected:
char *name;
public:
Resume() {}
virtual ~Resume() {}
virtual Resume* Clone() { return NULL; }
virtual void Set(char *n) {}
virtual void Show() {}
};
class ResumeA : public Resume
{
public:
ResumeA(const char *str);  //构造函数
ResumeA(const ResumeA &r); //拷贝构造函数
~ResumeA();                //析构函数
ResumeA* Clone();          //克隆，关键所在
void Show();               //显示内容
};
ResumeA::ResumeA(const char *str)
{
if (str == NULL) {
name = new char[1];
name[0] = '\0';
}
else {
name = new char[strlen(str) + 1];
strcpy(name, str);
}
}
ResumeA::~ResumeA() { delete[] name; }
ResumeA::ResumeA(const ResumeA &r) {
name = new char[strlen(r.name) + 1];
strcpy(name, r.name);
}
ResumeA* ResumeA::Clone() {
return new ResumeA(*this);
}
void ResumeA::Show() {
cout << "ResumeA name : " << name << endl;
}

class ResumeB : public Resume
{
public:
ResumeB(const char *str);  //构造函数
ResumeB(const ResumeB &r); //拷贝构造函数
~ResumeB();                //析构函数
ResumeB* Clone();          //克隆，关键所在
void Show();               //显示内容
};
ResumeB::ResumeB(const char *str)
{
if (str == NULL) {
name = new char[1];
name[0] = '\0';
}
else {
name = new char[strlen(str) + 1];
strcpy(name, str);
}
}
ResumeB::~ResumeB() { delete[] name; }
ResumeB::ResumeB(const ResumeB &r) {
name = new char[strlen(r.name) + 1];
strcpy(name, r.name);
}
ResumeB* ResumeB::Clone() {
return new ResumeB(*this);
}
void ResumeB::Show() {
cout << "ResumeB name : " << name << endl;
}

int main(int argc, char* argv[])
{
Resume *r1 = new ResumeA("A");
Resume *r2 = new ResumeB("B");
Resume *r3 = r1->Clone();
Resume *r4 = r2->Clone();
r1->Show(); r2->Show();
//删除r1,r2
delete r1; delete r2;
r1 = r2 = NULL;
//深拷贝所以对r3,r4无影响
r3->Show(); r4->Show();
delete r3; delete r4;
r3 = r4 = NULL;
return 0;
}
#endif

//        建造模式
//生成器模式（英：Builder Pattern）是一种设计模式，
//又名：建造模式，是一种对象构建模式。
//它可以将复杂对象的建造过程抽象出来（抽象类别），
//使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象。
#if 0
class Product{
public:
string ProductName;
};
class ProductA : public Product{
public:
ProductA() : ProductName("ProductA"){}
};
class ProductB :public Product{
public:
ProductB() : ProductName("ProductB"){}
};

class Creator{
public:
inline Product *CreateProduct(){
return DoCreateProduct();
}
protected:
virtual Product *DoCreateProduct() = 0;
};
class CreatorA : public Creator{
public:
Product *DoCreateProduct(){
return new ProductA;
}
};
class CreatorB : public Creator{
public:
Product *DoCreateProduct(){
return new ProductB;
}
};

int main(int argc, char **argv){
Creator *creator = new CreatorA;
Product *product = creator->CreateProduct();
cout << product->ProductName << endl;//"ProductA"
delete creator;
delete product;
creator = new CreatorB;
product = creator->CreateProduct();
cout << product->ProductName << endl;//"ProductB"
delete creator;
delete product;
return 0;
}
#endif

//          工厂方法模式
//工厂方法模式（英语：Factory method pattern）是一种实现了“工厂”概念的面向对象设计模式。
//就像其他创建型模式一样，它也是处理在不指定对象具体类型的情况下创建对象的问题。
//工厂方法模式的实质是“定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类。
//工厂方法让类的实例化推迟到子类中进行。
#if 0
class IProduct
{
public:
IProduct(){}
~IProduct(){}
};
class Android : public IProduct{};
class Iphone : public IProduct{};
class IFactory
{
public:
IFactory(){}
virtual ~IFactory(){}
virtual IProduct *getproduct() = 0;
};

class AndroidFactory : public IFactory
{
public:
AndroidFactory(){}
~AndroidFactory(){}
IProduct *getproduct()
{
cout << "a Android phone be create" << endl;
return new Android();
}
};
class AppleFactory : public IFactory
{
public:
AppleFactory(){}
~AppleFactory(){}
IProduct *getproduct()
{
cout << "a Apple phone be create" << endl;
return new Iphone();
}
};

int main()
{
IFactory *fac = new AndroidFactory();
IProduct *pro =  fac->getproduct();
fac = new AppleFactory();
pro = fac->getproduct();
return 0;
}
#endif

//抽象工厂模式（英语：Abstract factory pattern）是一种软件开发设计模式。
//抽象工厂模式提供了一种方式，可以将一组具有同一主题的单独的工厂封装起来。
//在正常使用中，客户端程序需要创建抽象工厂的具体实现，然后使用抽象工厂作为接口来创建这一主题的具体对象。
//客户端程序不需要知道（或关心）它从这些内部的工厂方法中获得对象的具体类型，
//因为客户端程序仅使用这些对象的通用接口。抽象工厂模式将一组对象的实现细节与他们的一般使用分离开来。

//AbstractFactory 模式和 Factory 模式的区别是初学（使用）设计模式时候的一个容易引
//起困惑的地方。 实际上， AbstractFactory 模式是为创建一组（ 有多类） 相关或依赖的对象提
//供创建接口， 而 Factory 模式正如我在相应的文档中分析的是为一类对象提供创建接口或延
//迟对象的创建到子类中实现。并且可以看到， AbstractFactory 模式通常都是使用 Factory 模
//式实现（ ConcreteFactory1）。

class AbstractIProduct
{
public:
AbstractIProduct(){}
~AbstractIProduct(){}
};
class Androidphone : public AbstractIProduct{};
class Androidpad : public AbstractIProduct{};
class Iphone : public AbstractIProduct{};
class Ipad : public AbstractIProduct{};
class IFactory
{
public:
IFactory(){}
virtual ~IFactory(){}
virtual AbstractIProduct *getpad() = 0;
virtual AbstractIProduct *getphone() = 0;
};

class AndroidFactory : public IFactory
{
public:
AndroidFactory(){}
~AndroidFactory(){}
AbstractIProduct *getphone()
{
cout << "a Android phone be create" << endl;
return new Androidphone();
}
AbstractIProduct *getpad()
{
cout << "a Android pad be create" << endl;
return new Androidpad();
}
};
class AppleFactory : public IFactory
{
public:
AppleFactory(){}
~AppleFactory(){}
AbstractIProduct *getphone()
{
cout << "a Apple phone be create" << endl;
return new Iphone();
}
AbstractIProduct *getpad()
{
cout << "a Apple pad be create" << endl;
return new Ipad();
}
};

int main()
{
IFactory *fac = new AndroidFactory();
AbstractIProduct *pro = fac->getpad();
pro = fac->getphone();
fac = new AppleFactory();
pro = fac->getpad();
pro = fac->getphone();
return 0;
}