目录
入门之简单工厂
功能:
定义创建对象的接口,封装了对象的创建
类图:
C++代码简单实现:
#include<iostream>
using namespace std;
class Product
{
public:
Product()
{
cout<<"Product"<<endl;
}
};
class Product1:public Product
{
public:
Product1()
{
cout<<"Product1"<<endl;
}
};
class Factory
{
public:
Product* CreateProduct()
{
return new Product1();
}
};
int main()
{
Factory f;
Product* p = f.CreateProduct();
return 0;
}
工厂方法
功能:
定义创建对象的接口,封装了对象的创建。
使得具体化类的工作延迟到了子类中。
类图:
代码:
#include<iostream>
using namespace std;
class Product
{
public:
Product()
{
cout<<"Product"<<endl;
}
};
class Product1:public Product
{
public:
Product1()
{
cout<<"Product1"<<endl;
}
};
class Factory
{
public:
virtual Product* CreateProduct()=0;
};
class Foctory1:public Factory
{
public:
Product* CreateProduct()
{
return new Product1();
}
};
int main()
{
Factory* f = new Foctory1();
Product* p = f->CreateProduct();
return 0;
}
抽象工厂
功能:
创建一组相关或相互依赖的对象
类图:
代码:
#include<iostream>
using namespace std;
class ProductA //A类产品
{
};
class ProductB //B类产品
{
};
class ProductA1:public ProductA //A类产品普通版本
{
public:
ProductA1()
{
cout<<"ProductA1"<<endl;
}
};
class ProductA2:public ProductA //A类产品升级版本
{
public:
ProductA2()
{
cout<<"ProductA2"<<endl;
}
};
class ProductB1:public ProductB //B类产品普通版本
{
public:
ProductB1()
{
cout<<"ProductB1"<<endl;
}
};
class ProductB2:public ProductB //B类产品升级版本
{
public:
ProductB2()
{
cout<<"ProductB2"<<endl;
}
};
class Factory
{
public:
virtual ProductA* CreateProductA()=0;
virtual ProductB* CreateProductB()=0;
};
class Factory1:public Factory //针对普通用户
{
public:
ProductA* CreateProductA()
{
return new ProductA1();
}
ProductB* CreateProductB()
{
return new ProductB1();
}
};
class Factory2:public Factory//针对VIP
{
public:
ProductA* CreateProductA()
{
return new ProductA2();
}
ProductB* CreateProductB()
{
return new ProductB2();
}
};
int main()
{
Factory* p1 = new Factory1();
p1->CreateProductA();
p1->CreateProductB();
Factory* p2 = new Factory2();
p2->CreateProductA();
p2->CreateProductB();
return 0;
}
单例模式
功能:
Singleton 模式解决问题十分常见,我们怎样去创建一个唯一的变量(对象)?
类图:
代码:
#include<iostream>
using namespace std;
class Singleton
{
private:
Singleton()
{
cout<<"create"<<endl;
}
~Singleton()
{
cout<<"del"<<endl;
}
static Singleton* m_instance;
public:
static Singleton* createSig()
{
if(m_instance == NULL)
m_instance = new Singleton();
return m_instance;
}
static void del()
{
if(m_instance)
delete m_instance;
m_instance = NULL;
}
};
Singleton* Singleton::m_instance = 0;
int main()
{
Singleton* s = Singleton::createSig();
Singleton::del();
s = Singleton::createSig();
return 0;
}
原型模式
功能:
自我复制的功能,就是说新对象的创建可以通过已有对象进行 创建。
类图:
代码:
#include<iostream>
using namespace std;
class Product
{
public:
virtual Product* clone() = 0;
};
class Product1:public Product
{
public:
Product1(){}
Product1(const Product1& pro)
{
cout<<"copy"<<endl;
}
Product* clone()
{
return new Product1(*this);
}
};
int main()
{
Product* pro1 = new Product1();
Product* pro2 = pro1->clone();
return 0;
}
建造者模式
功能:
分步骤创建对象,步骤不同结果不同
类图
代码:
#include<iostream>
#include<list>
#include<string>
using namespace std;
class Product//最后产品
{
private:
list<string> lst;
public:
void add(string str)
{
lst.push_back(str);
}
void show()
{
for(auto &it:lst)
cout<<it<<"->";
cout<<"product"<<endl;
}
};
class Builder //建造者
{
protected:
Product* pro;
public:
virtual void buildPart1()=0;
virtual void buildPart2()=0;
virtual Product* getResult()=0;
};
class Builder1:public Builder
{
public:
Builder1()
{
pro = new Product();
}
void buildPart1()
{
pro->add("hand");
}
void buildPart2()
{
pro->add("foot");
}
Product* getResult()
{
return pro;
}
};
class Builder2:public Builder
{
public:
Builder2()
{
pro = new Product();
}
void buildPart1()
{
pro->add("hand");
pro->add("hand");
}
void buildPart2()
{
pro->add("foot");
pro->add("foot");
}
Product* getResult()
{
return pro;
}
};
class Director //控制建造过程
{
public:
void Ctrl(Builder* bud)
{
bud->buildPart1();
bud->buildPart2();
}
};
int main()
{
Director* dir = new Director();
Builder* bud1 = new Builder1();
Builder* bud2 = new Builder2();
dir->Ctrl(bud1);
Product* pro1 = bud1->getResult();
dir->Ctrl(bud2);
Product* pro2 = bud2->getResult();
pro1->show();
pro2->show();
return 0;
}
总结
原型模式通过复制原型(Prototype)而获得新对象创建的功能,这里原型本
身就是“对象工厂”(因为能够生产对象),实际上 原型 模式和建造者模式、
抽象工厂模式都是通过一个类(对象实例)来专门负责对象的创建工作(工厂对象),
它们之间的区别是:建造者模式重在复杂对象的一步步创建(并不直接返回对象),
抽象工厂模式重在产生多个相互依赖类的对象,而 原型模式重在从自身复制自
己创建新类。