设计模式以及C++实现(一)创建型模式

目录

 

入门之简单工厂

功能：

类图：

C++代码简单实现：

工厂方法

功能：

类图：

代码：

抽象工厂

功能：

类图：

代码：

单例模式

功能：

类图：

代码：

原型模式

功能：

类图：

代码：

建造者模式

功能：

类图

代码：

---

入门之简单工厂

功能：

定义创建对象的接口，封装了对象的创建

类图：

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）而获得新对象创建的功能，这里原型本

身就是“对象工厂”（因为能够生产对象），实际上 原型 模式和建造者模式、

抽象工厂模式都是通过一个类（对象实例）来专门负责对象的创建工作（工厂对象），

它们之间的区别是：建造者模式重在复杂对象的一步步创建（并不直接返回对象），

抽象工厂模式重在产生多个相互依赖类的对象，而 原型模式重在从自身复制自

己创建新类。