设计模式学习记录

创建型

与对象的创建有关

抽象工厂模式

提供一个创建一系列相关或相互依赖的对象的接口

//来1张1费卡  1张2费卡 一系列相关
class Card {
public:
	virtual void out() = 0;
};
//还可以定义更多的卡牌
class CardCost1:public Card {
public:
	virtual void out() {
		cout << "我是1费卡" << endl;
	}
};

class CardCost2 :public Card {
public:
	virtual void out() {
		cout << "我是2费卡" << endl;
	}
};

class Factory {
public:
	virtual Card* CreateCost1() = 0;
	virtual Card* CreateCost2() = 0;
};
//还可以定义更多的工厂来组合
class CardFactory:public Factory {
public:
	Card* CreateCost1() {//来一张1费卡
		return new CardCost1();
	}
	Card* CreateCost2() {//来一张2费卡
		return new CardCost2();
	}
};
class CardFamaly
int main() {
	CardFactory *fac = new CardFactory();
	Card* cost1 = fac->CreateCost1();
	Card* cost2 = fac->CreateCost2();

	cost1->out();
	cost2->out();
	delete cost1;
	delete cost2;
	delete fac;
	return 0;
}

工厂模式

定义一个用于创建对象的接口,让子类决定实例化哪个类
//和抽象工厂区别是 1个和多个？

class Card {
public:
	virtual void out() = 0;
};

class CardCost1:public Card {
public:
	virtual void out() {
		cout << "我是1费卡" << endl;
	}
};

class CardCost2 :public Card {
public:
	virtual void out() {
		cout << "我是2费卡" << endl;
	}
};
class Factory {
public:
	virtual Card* Create() = 0;
};


class CardCost1Factory:public Factory {
public:
	Card* Create() {
		return new CardCost1();
	}
};

class CardCost2Factory :public Factory {
public:
	Card* Create() {
		return new CardCost2();
	}
};
int main() {
	CardCost1Factory* fac1 = new CardCost1Factory();
	CardCost2Factory* fac2 = new CardCost2Factory();
	Card* cost1 = fac1->Create();
	Card* cost2 = fac2->Create();

	cost1->out();
	cost2->out();
	delete cost1;
	delete cost2;
	delete fac1;
	delete fac2;
	return 0;
}

生成器模式

在某些情况下，一个对象的创建过程非常复杂，涉及多个步骤，每个步骤都可能有不同的实现方式。如果将所有创建逻辑放在一个类中，会导致该类变得庞大且难以维护。此外，如果需要创建不同的变体对象，就需要在该类中添加更多的逻辑，使得代码变得混乱。

原型模式

克隆

单例模式

就是单例

结构型

适配器模式

将一个类的接口转变为另外一个希望的接口

template<typename Type>
void permutation(Type first, int len) {
	int val = 1;
	for (int i = 0; i < len; i++) {
		*first = val;
		val++;
		first++;
	}
}

int main() {
	vector<int> a;
	//本来vector 不能用 = int 赋值 ++
	//把vector =>back_insert_iterator(重载++ = ) 调用vector push_back
	permutation(back_inserter(a), 10);
	int b[20];
	permutation(b, 10);
	return 0;
}

桥接模式

将抽象部分和其实现部分分离,使它们都可以独立的变化

//羁绊
class Jiban {
public:
	virtual void out() = 0;
};

class Family :public Jiban {
public:
	virtual void out() {
		cout << " 家人 " << endl;
	}
};

class ZhenMan :public Jiban {
public:
	virtual void out() {
		cout << " 铁血屈服者 " << endl;
	}
};
//英雄
class Hero {
public:
	virtual void out() = 0;
	virtual void SetJiban(Jiban* jb) = 0;
	Jiban* m_jb = nullptr;
};

class BaoBao:public Hero {
public:
	virtual void out() {
		cout << " 爆爆 ";
		m_jb->out();
	}
	virtual void SetJiban(Jiban* jb) {
		m_jb = jb;
	}
	
};

class JieSi :public Hero {
public:
	virtual void out() {
		cout << " 杰斯 ";
		m_jb->out();
	}
	virtual void SetJiban(Jiban* jb) {
		m_jb = jb;
	}
};

int main() {
	Family* family = new Family;
	ZhenMan* zm = new ZhenMan;

	JieSi* js = new JieSi();
	BaoBao* bb = new BaoBao();

	js->SetJiban(zm);
	bb->SetJiban(family);

	js->out();
	bb->out();
	return 0;

}

组合模式

将对象组合成树型结构以表示整体与部分的层次结构
文件系统

装饰模式

动态的给一个对象添加一些额外的职责

class Water {
public:
	virtual int cost() = 0;
	virtual void out() = 0;
};

class Wahaha :public Water {
public:
	virtual int cost() {
		return 2;
	}
	virtual void out() {
		cout << "娃哈哈";
	}
};

class WaterDecorator :public Water {
public:
	WaterDecorator(Water* self) {
		m_self = self;
	}
	virtual int cost() {
		return m_self->cost();
	}
	virtual void out() {
		m_self->out();
	}
	Water* m_self;
};
//加冰
class IceDecorator :public WaterDecorator {
public:
	IceDecorator(Water* self) :WaterDecorator(self) {}
	virtual int cost() {
		return 1 + m_self->cost();
	}
	virtual void out() {
		m_self->out();
		cout << " 加冰 ";
	}
};
//加糖
class SugarDecorator :public WaterDecorator {
public:
	SugarDecorator(Water* self) :WaterDecorator(self) {}
	virtual int cost() {
		return 1 + m_self->cost();
	}
	virtual void out() {
		m_self->out();
		cout << " 加糖 ";
	}
};

int main() {
	Wahaha* whh = new Wahaha();
	{
		IceDecorator* d = new IceDecorator(whh);
		SugarDecorator* d2 = new SugarDecorator(d);
		d2->out();
		cout << d2->cost() << endl;
	}
	return 0;
}

外观模式

为子系统中一组接口提供一个一致的界面

class Computer {
public:
	void turnOn() {
		cout << " 开电脑 ";
	}
	void turnOff() {
		cout << " 关电脑 ";
	}
};
class Light {
public:
	void turnOn() {
		cout << " 开灯 ";
	}
	void turnOff() {
		cout << " 关灯 ";
	}
};

class MyLife {
	Computer computer;
	Light light;
public:
	void play() {
		computer.turnOn();
		light.turnOn();
		cout << endl;
	}
	void sleep() {
		computer.turnOff();
		light.turnOff();
		cout << endl;
	}
};

int main() {
	MyLife* mf = new MyLife;
	mf->play();
	mf->sleep();
	return 0;
}

享元模式

运用共享技术有效的支持大量细粒度的对象

struct Base {
public:
	string name;
	int gongji;//攻击
	int fangyu;//防御
};

class BaoBao{
public:
	BaoBao(Base *base) {
		m_base = base;
		x = y = 0;
	}
	
	Base* m_base;
	int x, y;//坐标
};

class BaoBaoFactory {

public:
	BaoBao* GetHero() {
		Base* base = nullptr;
		if (mmp.count("爆爆"))base = mmp["爆爆"];
		else {
			base = new Base;
			base->name = "爆爆";
			base->gongji = 999;
			base->fangyu = 999;
			mmp[base->name] = base;
		}
		return new BaoBao(base);
	}
	unordered_map<string, Base *> mmp;
};

int main() {
	BaoBaoFactory* fac = new BaoBaoFactory();
	vector<BaoBao* > all;

	for (int i = 0; i < 100; i++) {
		all.push_back(fac->GetHero());
	}
	return 0;
}

代理模式

行为型

责任链模式

命令模式

解释器模式

迭代器模式

中介者模式

备忘录模式

观察者模式

状态模式

策略模式

模版方法模式

访问者模式