在C++中实现委托（Delegate）——普通函数（一）

为了一步步实现委托，同时也为了方便将目标问题拆解，我们采用先从普通函数入手，再到成员函数，逐步实现类似于C#中的委托。
首先，明确目标：
一、目标

#include <iostream>
#include "CMultiDelegate.h"
#include "CStaticDelegate.h"

void Say()
{
	printf("void Say(): Hello world\n");
}

int main(int argc, char* argv[])
{
	{
		CMultiDelegate onclick;
		onclick += newDelegate(Say);
		//onclick -= newDelegate(Say);

		onclick();
	}

	getchar();
	return 0;
}

运行结果：

void Say(): Hello world

二、实现过程
定义接口：
IDelegate.h

#pragma once

#include <typeinfo>

class IDelegate
{
public:
	virtual ~IDelegate() { }
	virtual bool isType(const std::type_info& _type) = 0;
	virtual void invoke() = 0;
	virtual bool compare(IDelegate *_delegate) const = 0;
};

其中virtual bool isType(const std::type_info& _type) = 0;是辅助virtual bool compare(IDelegate *_delegate) const进行判断是否相等的。
invoke()是实际工作的函数，这里就是去调用Say()函数。invoke()的参数和返回值与Say()函数相同。
虚析构函数是作为基类应该提供的，具体原因请看这篇博文：

#pragma once

#include "IDelegate.h"

class CStaticDelegate : public IDelegate
{
public:
	typedef void(*Func)();

	CStaticDelegate(Func _func) : mFunc(_func) {}

	virtual bool isType(const std::type_info& _type) { return typeid(CStaticDelegate) == _type; }

	virtual void invoke() { mFunc(); }

	virtual bool compare(IDelegate *_delegate) const
	{
		if (nullptr == _delegate || !_delegate->isType(typeid(CStaticDelegate))) return false;

		CStaticDelegate *cast = static_cast<CStaticDelegate*>(_delegate);
		return cast->mFunc == mFunc;
	}

private:
	Func mFunc;
};

inline IDelegate* newDelegate(void(*_func)())
{
	return new CStaticDelegate(_func);
}

讲解：

typedef void(*Func)();

定义了一个函数指针.Func mFunc;是在CStaticDelegate中有一个函数指针类型的成员变量mFunc。

inline IDelegate* newDelegate(void(*_func)())
{
	return new CStaticDelegate(_func);
}

这里返回的是一个IDelegate接口，CStaticDelegate的作用就是将普通函数void Say();“变成”类成员函数，而这个类成员函数具有有void Say();函数相同的参数类型，和相同的返回值。
这里的变成是将Say函数指针存到CStaticDelegate中，CStaticDelegate中有个同类型的成员函数，CStaticDelegate去调用这个成员函数，就等于调用了普通函数Say。
我们再回头看看我们的main函数

CMultiDelegate onclick;
onclick += newDelegate(Say);
onclick -= newDelegate(Say);
onclick();

我们需要一个类CMultiDelegate提供+=、-=和()的重载函数，这个CMultiDelegate做为一个集合管理着这些委托事件。
CMultiDelegate.h

#pragma once
#include <list>
#include "IDelegate.h"

class CMultiDelegate
{
public:
	typedef std::list<IDelegate*> ListDelegate;
	typedef ListDelegate::iterator ListDelegateIterator;
	typedef ListDelegate::const_iterator ConstListDelegateIterator;

	CMultiDelegate() {}
	~CMultiDelegate() { clear(); }

	bool empty() const
	{
		return mListDelegates.size() == 0;
	}

	void clear()
	{
		for (ListDelegateIterator iter = mListDelegates.begin(); iter != mListDelegates.end();)
		{
			delete (*iter);
			(*iter) = nullptr;
			iter = mListDelegates.erase(iter);
		}
	}

	CMultiDelegate& operator+=(IDelegate* _delegate)
	{
		for (ListDelegateIterator iter = mListDelegates.begin(); iter != mListDelegates.end(); ++iter)
		{
			if ((*iter)->compare(_delegate))
			{
				return *this;
			}
		}
		mListDelegates.push_back(_delegate);
		return *this;
	}

	CMultiDelegate& operator-=(IDelegate* _delegate)
	{
		for (ListDelegateIterator iter = mListDelegates.begin(); iter != mListDelegates.end(); ++iter)
		{
			if ((*iter)->compare(_delegate))
			{
				delete _delegate;
				_delegate = nullptr;

				mListDelegates.erase(iter);
				return *this;
			}
		}
		delete _delegate;
		_delegate = nullptr;
		return *this;
	}

	void operator()()
	{
		ListDelegateIterator iter = mListDelegates.begin();
		while (iter != mListDelegates.end())
		{
			(*iter)->invoke();
			++iter;
		}
	}

private:
	CMultiDelegate(const CMultiDelegate& _delegate) = delete;
	CMultiDelegate& operator=(const CMultiDelegate& _delegate) = delete;

private:
	ListDelegate mListDelegates;
};

讲解一下这个函数：

CMultiDelegate& operator-=(IDelegate* _delegate)
{
	for (ListDelegateIterator iter = mListDelegates.begin(); iter != mListDelegates.end(); ++iter)
	{
		if ((*iter)->compare(_delegate))
		{
			delete _delegate;
			_delegate = nullptr;

			mListDelegates.erase(iter);
			return *this;
		}
	}
	delete _delegate;
	_delegate = nullptr;
	return *this;
}

std::list的erase函数，如果list中存的是指针，则调用这个函数，并不会去释放该指针指向的对象，而仅仅只是从list中“删除”该指针本身而已，所以存在std::list中元素类型为指针的，需要我们手动去释放对象内存。谁申请，谁释放的原则。
(*iter)->compare(_delegate)相等的时候(*iter)和_delegate指向的对象是相同的，对其任何一个进行delete操作都可以。
main.cpp

#include <iostream>
#include "CMultiDelegate.h"
#include "CStaticDelegate.h"

void Say()
{
	std::cout << "void Say(): Hello world" << std::endl;
}

int main(int argc, char* argv[])
{
	{
		CMultiDelegate onclick;
		onclick += newDelegate(Say);
		onclick += newDelegate(Say);
		//onclick -= newDelegate(Say);

		onclick();
	}

	getchar();
	return 0;
}

至此，我们已经完成了最简单的C++委托事件。

参考：https://blog.csdn.net/y1196645376/article/details/51408114