设计模式(策略模式、单例模式模板、享元模式)

原创 2018年04月16日 10:38:30

1.享元模式

类图


#include "stdafx.h"
#include <iostream>
#include <map>
using namespace std;
/********************************************享元模式*******************************************/
#if 1
class Character  
{
public:
	virtual ~Character(){};

	virtual void SetSize(int, int) = 0;
	virtual void Display() = 0;
protected:
	Character(){};
	char m_chSymbol;
	int m_nWeight;
	int m_nHeight;
};

class CharacterA : public Character
{
public:
	CharacterA();
	virtual ~CharacterA();

	void SetSize(int, int);
	void Display();
};

CharacterA::CharacterA()
{
	this->m_chSymbol = 'A';
	this->m_nWeight = 100;
	this->m_nHeight = 200;
}

CharacterA::~CharacterA()
{

}
void CharacterA::SetSize(int nWeight, int nHeight)
{
	this->m_nWeight = nWeight;
	this->m_nHeight = nHeight;
}
void CharacterA::Display()
{
	cout << "CharacterA:" << m_chSymbol << "(" << m_nWeight << "," << m_nHeight << ")" << endl;
}

class CharacterB : public Character
{
public:
	CharacterB();
	virtual ~CharacterB();

	void SetSize(int, int);
	void Display();
};

CharacterB::CharacterB()
{
	this->m_chSymbol = 'B';
	this->m_nWeight = 100;
	this->m_nHeight = 200;
}

CharacterB::~CharacterB()
{

}

void CharacterB::SetSize(int nWeight, int nHeight)
{
	this->m_nWeight = nWeight;
	this->m_nHeight = nHeight;
}

void CharacterB::Display()
{
	cout << "CharacterB:" << m_chSymbol << "(" << m_nWeight << "," << m_nHeight << ")" << endl;
}

class CharacterFactory  
{
public:
	CharacterFactory();
	virtual ~CharacterFactory();

	Character* GetCharacter(char);
private:
	std::map<char, Character*> m_mChar;
};

CharacterFactory::CharacterFactory()
{
	m_mChar.insert(make_pair<char, Character*>('A', new CharacterA));
	m_mChar.insert(make_pair<char, Character*>('B', new CharacterB));
}

CharacterFactory::~CharacterFactory()
{
	map<char,Character *>::iterator iter = m_mChar.begin();
	for(;iter != m_mChar.end();++iter)
	{
		delete iter->second;
		iter->second = NULL;
	}
	m_mChar.clear();
}

Character* CharacterFactory::GetCharacter(char chIn)
{
	map<char, Character*>::iterator it = m_mChar.find(chIn);
	if(it != m_mChar.end())
	{
		return (Character*)it->second;
	}

	return NULL;
}

int _tmain(int argc, _TCHAR* argv[])
{
	CharacterFactory* pFactory = new CharacterFactory;


	Character* ch1 = pFactory->GetCharacter('A');
	ch1->Display();


	Character* ch2 = pFactory->GetCharacter('B');
	ch2->SetSize(500, 800);
	ch2->Display();
	system("pause");


	return 0;
}
#endif 

运行结果


优点:

1、享元模式的优点在于它能够极大的减少系统中对象的个数。

2、享元模式由于使用了外部状态,外部状态相对独立,不会影响到内部状态,所以享元模式使得享元对象能够在不同的环境被共享。

缺点:

1、由于享元模式需要区分外部状态和内部状态,使得应用程序在某种程度上来说更加复杂化了。

2、为了使对象可以共享,享元模式需要将享元对象的状态外部化,而读取外部状态使得运行时间变长。


2.策略模式

#if 1
class WeaponBehavior
{
public:
	void virtual useWeapon() = 0;
};

class AK47:public WeaponBehavior
{
public:
	void useWeapon()
	{
		cout << "Use AK47 to shoot!" << endl;
	}
};

class Knife:public WeaponBehavior
{
public:
	void useWeapon()
	{
		cout << "Use Knife to kill!" << endl;
	}
};

class Character
{
public:
	Character()
	{
		weapon = 0;
	}
	void setWeapon(WeaponBehavior *w)
	{
		this->weapon = w;
	}
	void virtual fight() = 0;
protected:
	WeaponBehavior *weapon;
};

class King:public Character
{
public:
	void fight()
	{
		cout << "The king:" ;
		if ( this->weapon == NULL)
		{
			cout << "You don't have a weapon! Please Set Weapon!" << endl;
		}
		else
		{ 
			weapon->useWeapon();
		}
	}
};
int main()
{    
	WeaponBehavior *ak47 = new AK47();
	WeaponBehavior *knife = new Knife();     

	Character *kin = new King();      

	kin->fight();   
	cout << endl; 

	kin->setWeapon(ak47);
	kin->fight();
	cout << endl;

	kin->setWeapon(knife);
	kin->fight();
	system("pause");
	return 0;
}


#endif 

运行结果


优点:

  1、 简化了单元测试,因为每个算法都有自己的类,可以通过自己的接口单独测试。
  2、 避免程序中使用多重条件转移语句,使系统更灵活,并易于扩展。
       3、 遵守大部分GRASP原则和常用设计原则,高内聚、低偶合。

缺点:
  1、 因为每个具体策略类都会产生一个新类,所以会增加系统需要维护的类的数量。

       2、 在基本的策略模式中,选择所用具体实现的职责由客户端对象承担,并转给策略模式的Context对象

3.单例模式

参照:https://www.cnblogs.com/qiaoconglovelife/p/5851163.html     点击打开链接

这个链接已经讲的很清楚了,下来给你们看下单例模式的模板

#include<mutex>
#include<memory>
#include<iostream>
template<class T>
class Singleton{
public:
	template<class ...Args>
	static inline std::shared_ptr<T> instance(Args&&... args){
		if (!instance_.get()){
			std::unique_lock<std::mutex> lock(instanceMutex_);
			if (!instance_.get()){
				instance_.reset(new T(std::forward<Args>(args)...));
			}
		}
		return instance_;
	}
private:
	Singleton() = default;
	virtual ~Singleton() = default;
	Singleton(const Singleton&) = default;
	Singleton& operator=(const Singleton&) = delete;
private:
	static std::shared_ptr<T> instance_;
	static std::mutex instanceMutex_;
};

template<class T>
std::shared_ptr<T> Singleton<T>::instance_;

template<class T>
std::mutex Singleton<T>::instanceMutex_;

#define SINGLETON_DECL(type) \
	friend class Singleton<type>; \
	friend class std::shared_ptr<type>; \


class Test1{
public:
	Test1(int age, std::string name) :age_(age), name_(name){
		std::cout << "Test1" << std::endl; 
	}
private:
	SINGLETON_DECL(Test1);
	int age_;
	std::string name_;
};
class Test2{
public:
	Test2(int age, std::string name,std::string addr) :age_(age), name_(name),addr_(addr){
		std::cout << "Test2" << std::endl;
	}
private:
	SINGLETON_DECL(Test2);
	int age_;
	std::string name_;
	std::string addr_;
};
class Test3{
public:
	Test3() {
		std::cout << "Test3" << std::endl;
	}
private:
	SINGLETON_DECL(Test3);
	int age_;
	std::string name_;
};
int main(){
	 
	auto test = Singleton<Test3>::instance();
	std::cin.get();
	return 0;
}

《设计模式之禅》读书笔记-策略模式、享元模式、工厂模式、门面模式混用

前一篇讲的什么是策略模式,策略模式的优缺点,在实际应用中肯定不能这么简单的应用,需要结合其他模式混用。比如结合门面模式解决所有策略类都需要对外暴露的缺点,使用享元模式解决多次创建实例的缺点等。 此篇...
  • timothy316
  • timothy316
  • 2017-05-15 21:45:03
  • 194

享元模式和单例模式的区别

享元模式可以理解成一组共享的对象集合享元模式Class flyWeight { Object get(std::string key) { if(m_map.cont...
  • epeaktop
  • epeaktop
  • 2016-07-05 13:02:22
  • 1639

C++设计模式[十]享元模式

所谓享元模式就是运行共享技术有效地支持大量细粒度对象的复用。系统使用少量对象,而且这些都比较相似,状态变化小,可以实现对象的多次复用。 共享模式是支持大量细粒度对象的复用,所以享元模式要求能够共享的对...
  • langb2014
  • langb2014
  • 2015-11-11 15:26:38
  • 890

C#设计模式

  • 2011年12月18日 17:41
  • 737KB
  • 下载

java设计模式(工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式、适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式,。 行为型模式,共十一种:策略模式、模板方法)

设计模式(Design Patterns) ——可复用面向对象软件的基础 设计模式(Design pattern)是一套被反复使用、多数人知晓...
  • zgliang88
  • zgliang88
  • 2017-02-19 12:11:34
  • 1663

享元模式 - 结构型模式

享元模式:运用共享技术有效地支持大量细粒度的对象。 The intent of this pattern is to use sharing to support a large number of ...
  • paincupid
  • paincupid
  • 2015-07-15 17:54:11
  • 718

《JAVA与模式》26天系列—第12天—享元模式=单例模式+工厂模式+合成模式

享元模式=单例模式+工厂模式+合成模式   单例模式: 保证一个类仅有一个实例,并提供一个访问它的全局访问点。 结构图: 注意多线程的单例。 package com.bankht.Fl...
  • m13666368773
  • m13666368773
  • 2012-06-26 15:35:20
  • 5704

设计模式demo (单例模式、建造者模式、策略模式)

  • 2015年07月29日 09:46
  • 18KB
  • 下载

设计模式系列之四_策略模式 和 模版方法模式(Template method)

1.策略模式 1.1 策略模式   策略模式定义了一系列的算法,并将每一个算法封装起来,而且使它们还可以相互替换。 策略模式让算法独立于使用它的客户而独立变化。   策略模式属于对象的行为模式...
  • orclight
  • orclight
  • 2013-03-12 16:28:14
  • 3763

JAVA设计模式之享元模式

解释一下概念:也就是说在一个系统中如果有多个相同的对象,那么只共享一份就可以了,不必每个都去实例化一个对象。比如说一个文本系统,每个字母定一个对象,那么大小写字母一共就是52个,那么就要定义52个对象...
  • jason0539
  • jason0539
  • 2014-04-04 07:34:52
  • 32761
收藏助手
不良信息举报
您举报文章:设计模式(策略模式、单例模式模板、享元模式)
举报原因:
原因补充:

(最多只允许输入30个字)