C++仿c#的delegate的实现源码

/*
* Delegate.hpp
*
*  Created on: Aug 31, 2016
*      Author: root
*/

#ifndef DELEGATE_HPP_
#define DELEGATE_HPP_

#include <vector>

template <typename... Types>
class CallBackBase
{
public:
CallBackBase() {}
virtual ~CallBackBase() {};
virtual void operator () (Types... args) = 0;
};

template <typename... Types>
class CallBackFunction : public CallBackBase<Types...>
{
public:
typedef void (*FPCallBack)(Types... args);

CallBackFunction(){}

CallBackFunction(FPCallBack pFunc)
{
if (pFunc != nullptr)
{
m_fpCallBack = pFunc;
}
}

virtual ~CallBackFunction()
{
}

virtual void operator () (Types... args)
{
if (m_fpCallBack != nullptr)
m_fpCallBack(args...);
//throw std::exception("null function address is called");
return ;
}

private:
FPCallBack m_fpCallBack = nullptr;
};

template <typename T, typename... Types>
class CallBackMethod : public CallBackBase<Types...>
{
public:
typedef void (T::*FPClassCallBack)(Types... args);

CallBackMethod(){}

CallBackMethod(T *pThis, FPClassCallBack pFunc)
{
if (pThis != nullptr && pFunc != nullptr)
{
m_pThis = pThis;
m_fpCallBack = pFunc;
}
}

virtual ~CallBackMethod()
{
}

virtual void operator () (Types... args)
{
if (m_pThis != nullptr && m_fpCallBack != nullptr)
{
(m_pThis->*m_fpCallBack)(args...);
}
//throw std::exception("null function address is called");
return ;
}

private:
T *m_pThis = nullptr;
FPClassCallBack m_fpCallBack = nullptr;
};

template <typename... Types>
class Delegate
{
using CallBackType = CallBackBase<Types...>;
public:
Delegate(){};
Delegate(CallBackType *callBack)
{
_vecCallBack.clear();
_vecCallBack.push_back(callBack);
}

virtual ~Delegate() {};

void operator () (Types... args)
{
for (auto item : _vecCallBack)
{
(*item)(args...);
}
}

virtual void operator += (CallBackType *pFunc)
{
if (pFunc != nullptr)
{
_vecCallBack.push_back(pFunc);
}
}

virtual void operator -= (CallBackType *pFunc)
{
if (pFunc != nullptr)
{
auto it = _vecCallBack.begin();
for (; it != _vecCallBack.end(); ++it)
{
if (*it == pFunc)
{
_vecCallBack.erase(it);
break;
}
}
//auto it = std::find(_vecCallBack.rbegin(), _vecCallBack.rend(), pFunc);
//if (it != _vecCallBack.cend())
//  _vecCallBack.erase(it);
}
}

private:
std::vector<CallBackType*> _vecCallBack;
};

#endif /* DELEGATE_HPP_ */

//============================================================================
// Name        : DelegateTest.cpp
// Author      : Zhangjf
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
#include "Delegate.hpp"

using namespace std;

void print1(std::string strP);

class Test1
{
public:
void print1(std::string str1)
{
printf("%s, %d: %s\n", __func__, __LINE__, str1.c_str());
return ;
}
};

int main() {

CallBackFunction<std::string> callBack1(print1);
Delegate<std::string> d1(&callBack1);
d1("test1");

Test1 t;
CallBackMethod<Test1, std::string> callBack2(&t, &Test1::print1);
d1 += &callBack2;

d1("test2");

d1 -= &callBack1;
d1("test3");

return 0;
}

void print1(std::string strP)
{
printf("%s, %d, %s\n", __func__, __LINE__, strP.c_str());
return ;
}