23种设计模式 3 行为型模式之3.6 mediator 中介者模式

参考1 网友k_eckel 的书籍《设计模式精讲-GoF 23种设计模式解析附C++实现源码》

参考2 腾讯元宝问答

文章目录

[0 前言](#0 前言)
[1 问题](#1 问题)
[2 模式选择](#2 模式选择)
[3 实现](#3 实现)
- [3.1 colleage.h](#3.1 colleage.h)
- [3.2 colleage.cpp](#3.2 colleage.cpp)
- [3.3 mediator.h](#3.3 mediator.h)
- [3.4 mediator.cpp](#3.4 mediator.cpp)
- [3.5 main.cpp](#3.5 main.cpp)
- [3.6 原作者对代码说明](#3.6 原作者对代码说明)
[4 讨论](#4 讨论)
[5 总结](#5 总结)

0 前言

mediator 模式，中介者模式。

实现对象和对象之间的交互与通信。

和ai沟通，中介者，这里又可以衍生出具体中介者和通用中介者

本文讲的是具体中介者（类之间的交互于通信方法具体放在mediator中）

1 问题

通常，在系统较小时，可以直接硬编码到各个对象的方法中。

在系统规模变大，对象的变量引起系统复杂度的急剧增加，对象间的通信也变得越来越复杂，这时候我们就需要提供一个专门处理对象间交互和通信的类。（这个就是mediator模式）

mediator模式提供将对象间的交互和通信封装在一个类中，各个对象间的通信不必显势的去声明和引用，大大降低了系统的复杂性。（了解一个对象总比深入熟悉N个对象要好）

2 模式选择

3 实现

3.1 colleage.h

cpp 复制代码

#ifndef __COLLEAGE_H_
#define __COLLEAGE_H_

#include <string>
using namespace std;

class mediator;

class colleage
{
public:
	virtual ~colleage();
	virtual void aciton() = 0;
	virtual void set_state(const string& sdt) = 0;
	virtual string get_state() = 0;
protected:
	colleage();
	colleage(mediator* mdt);
	mediator* _mdt;
private:
};

class concrete_colleage_a:public colleage
{
public:
	concrete_colleage_a();
	concrete_colleage_a(mediator* mdt);
	~concrete_colleage_a();
	void aciton();
	void set_state(const string& sdt);
	string get_state();
protected:

private:
	string _sdt;
};

class concrete_colleage_b:public colleage
{
public:
	concrete_colleage_b();
	concrete_colleage_b(mediator* mdt);
	~concrete_colleage_b();
	void aciton();
	void set_state(const string& sdt);
	string get_state();
protected:

private:
	string _sdt;
};

#endif //~~ __COLLEAGE_H_

3.2 colleage.cpp

cpp 复制代码

#include "mediator.h"
#include "colleage.h"

#include <iostream>
using namespace std;

colleage::colleage()
{
// _std = "";
}

colleage::colleage(mediator* mdt)
{
	this->_mdt = mdt;
	//_sdt = "";
}

colleage::~colleage()
{

}

concrete_colleage_a::concrete_colleage_a()
{

}

concrete_colleage_a::~concrete_colleage_a()
{

}

concrete_colleage_a::concrete_colleage_a(mediator* mdt):colleage(mdt)
{

}

string concrete_colleage_a::get_state()
{
	return _sdt;
}

void concrete_colleage_a::set_state(const string& sdt)
{
	_sdt = sdt;
}

void concrete_colleage_a::aciton()
{
	_mdt->do_action_from_a_to_b();
	cout << "state of concrete_colleage_b:" << "" << this->get_state() << endl;
}

concrete_colleage_b::concrete_colleage_b()
{

}

concrete_colleage_b::~concrete_colleage_b()
{

}

concrete_colleage_b::concrete_colleage_b(mediator* mdt):colleage(mdt)
{
	
}

void concrete_colleage_b::aciton()
{
	_mdt->do_action_from_b_to_a();
	cout << "state of concrete_colleage_b:" << "" << this->get_state() << endl;
}

string concrete_colleage_b::get_state()
{
	return _sdt;
}

void concrete_colleage_b::set_state(const string& sdt)
{
	_sdt = sdt;
}

3.3 mediator.h

cpp 复制代码

#ifndef __MEDIATOR_H_
#define __MEDIATOR_H_

class colleage;

class mediator
{
public:
	virtual ~mediator();
	virtual void do_action_from_a_to_b() = 0;
	virtual void do_action_from_b_to_a() = 0;

protected:
	mediator();

private:
};

class concrete_mediator:public mediator
{
public:
	concrete_mediator();
	concrete_mediator(colleage* clg_a, colleage* clg_b);
	~concrete_mediator();
	void set_concrete_colleage_a(colleage* clg_a);
	void set_concrete_colleage_b(colleage* clg_b);
	colleage* get_concrete_colleage_a();
	colleage* get_concrete_colleage_b();
	void intro_colleage(colleage* clg_a, colleage* clg_b);
	void do_action_from_a_to_b();
	void do_action_from_b_to_a();
protected:

private:
	colleage* _clg_a;
	colleage* _clg_b;
};

#endif //~~ __MEDIATOR_H_

3.4 mediator.cpp

cpp 复制代码

#include "mediator.h"
#include "colleage.h"

mediator::mediator()
{

}

mediator::~mediator()
{

}

concrete_mediator::concrete_mediator()
{

}

concrete_mediator::~concrete_mediator()
{

}

concrete_mediator::concrete_mediator(colleage* clg_a, colleage* clg_b)
{
	this->_clg_a = clg_a;
	this->_clg_b = clg_b;
}

void concrete_mediator::do_action_from_a_to_b()
{
	_clg_b->set_state(_clg_a->get_state());
}

void concrete_mediator::set_concrete_colleage_a(colleage* clg_a)
{
	this->_clg_a = clg_a;
}

void concrete_mediator::set_concrete_colleage_b(colleage* clg_b)
{
	this->_clg_b = clg_b;
}

colleage* concrete_mediator::get_concrete_colleage_a()
{
	return _clg_a;
}

colleage* concrete_mediator::get_concrete_colleage_b()
{
	return _clg_b;
}

void concrete_mediator::intro_colleage(colleage* clg_a, colleage* clg_b)
{
	this->_clg_a = clg_a;
	this->_clg_b = clg_b;
}

void concrete_mediator::do_action_from_b_to_a()
{
	_clg_a->set_state(_clg_b->get_state());
}

3.5 main.cpp

cpp 复制代码

#include "mediator.h"
#include "colleage.h"

#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{
	concrete_mediator* m = new concrete_mediator();
	concrete_colleage_a* c1 = new concrete_colleage_a(m);
	concrete_colleage_b* c2 = new concrete_colleage_b(m);

	m->intro_colleage(c1, c2);

	c1->set_state("old");
	c2->set_state("old");
	c1->aciton();
	c2->aciton();
	cout << endl;

	c1->set_state("new");
	c1->aciton();
	c2->aciton();
	cout << endl;


	c2->set_state("old");
	c2->aciton();
	c1->aciton();

	return 0;
}

运行结果

3.6 原作者对代码说明

4 讨论

原作者内容

5 总结

mediator模式（中介者模式）解决的问题：类之间的交互和通信。

这里实现的方式：

集中式的，具体的mediator；

mediator和通信类，通过类指针相互关联（mediator和通信类之间实现弱绑定。生命周期不绑定；）

将通信类之间的交流通信方法集中在mediator中；

通信类内部开放出通信操作接口Axx(Axx间接通过mediator提供的方法来实现交流通信)

23种设计模式 3 行为型模式 之3.6 mediator 中介者模式

文章目录

0 前言

1 问题

2 模式选择

3 实现

3.1 colleage.h

3.2 colleage.cpp

3.3 mediator.h

3.4 mediator.cpp

3.5 main.cpp

3.6 原作者对代码说明

4 讨论

5 总结

23种设计模式 3 行为型模式之3.6 mediator 中介者模式