设计模式.md

代理模式

// 代理模式

// todo:怎么用一个代理，代理多个subject子类？
class Subject {
public:
	Subject(){}
	virtual ~Subject(){}
	virtual void work() {
		cout << "base class work " << endl;
	}
};

class SubjectA : public Subject {
public:
	SubjectA(){}
	virtual ~SubjectA(){}
	virtual void work() override{ 
		cout << "A work!!" << endl;
	}
};

class SubjectB : public Subject {
public:
	SubjectB(){}
	virtual ~SubjectB (){}
	virtual void work() override {
		cout << "B work!!" << endl;
	}
};

class Proxy : public Subject {
public:
	Proxy( Subject sub ) { 
		subject = make_shared<Subject>(sub);
	}
	~Proxy() {}
	shared_ptr<Subject> subject;
	virtual void work() {
		cout << "before call" << endl;
		subject->work();
		cout << "after call" << endl;
	}
};
int main()
{
	Subject sub = SubjectB();
	Proxy p(sub); 
	p.work();
	return 0;
}

装饰者模式

class Log {
public:
	Log(){}
	virtual ~Log(){}
	virtual void log_out()
	{
		cout << "print log" << endl;
	}
};

class ErrorLog : public Log{
public:
	ErrorLog(){}
	virtual ~ErrorLog() {}
	virtual void log_out() override {
		cout << "print error log" << endl;
	}
};

class DebugLog : public Log {
public:
	DebugLog() {}
	virtual ~DebugLog() {}
	virtual void log_out() {
		cout << "print debug log " << endl;
	}
};

class DecoratorLog : public Log {
public:
	Log* _log;
	DecoratorLog(Log*  log) {
		_log = log;
	}
	virtual ~DecoratorLog(){}
	virtual void log_out()
	{
		cout << "log decorator" << endl;
		_log->log_out();
	}
};

class DecoratorErrorLog : public DecoratorLog {
public:
	DecoratorErrorLog(Log* log):DecoratorLog(log){}
	virtual ~DecoratorErrorLog(){}
	virtual void log_out() {
		cout << "errorlog decorator" << endl;
		_log->log_out();
	}
};

class DecoratorDebugLog : public DecoratorLog {
public:
	DecoratorDebugLog(Log* log) :DecoratorLog(log) {}
	virtual ~DecoratorDebugLog() {}
	virtual void log_out() {
		cout << "Debuglog decorator" << endl;
		_log->log_out();
	}
};


int main()
{
	Log* log1 = new DecoratorErrorLog(new ErrorLog());
	log1->log_out();
	Log* log2 = new DecoratorDebugLog(new DebugLog());
	log2->log_out();
	return 0;
}

适配器模式

class Api {
public:
	void old_api() {
		cout << "old api" << endl;
	}
};

class NewApi {
public:
	void new_api() {
		cout << "new api" << endl;
	}
};

class AdaptApi {
public:
	shared_ptr<NewApi> api;
	AdaptApi()
	{
		api = make_shared<NewApi>(new NewApi());
	}
	void new_api()
	{
		api->new_api();
	}
};

void apply(int a, int b, int c) {   // 原先用的旧接口， 这样改了之后，两个接口都可以用
	//API a1;  原先的老的接口函数
	//a1.old_apply();
	AdaptApi a1;
	a1.new_api();
}

void apply(int a, int b) {    // 先版本的接口，可以兼容
	NewApi a1;
	a1.new_api();
}

int main()
{
	apply(1, 2, 3);  // 改了之后，新版本下，也可以调就接口，但是库里面已经改了，就接口内部实现的是适配器模式调用新接口，设计模式的最大哲学就是不动源代码
	apply(1, 2);
	return 0;
}