c++ delegate 最大16个参数，用程序生成的代码

最新推荐文章于 2020-03-23 12:06:53 发布
最新推荐文章于 2020-03-23 12:06:53 发布
阅读量285 收藏
点赞数
分类专栏： c++ 文章标签： c delegate 委托
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sdragonx/article/details/55250456
版权

读这篇文章的前提是，我们使用的编辑器对c++11的支持不太友好。下面是测试代码：

#include <stdio.h>
#include <stdlib.h>
#include "delegate.h"
using namespace std;

class test
{
public:
    void func()
    {
        printf("test::func\n");
    }
    int func_int(int n)
    {
        printf("test::func_int\t%i\n", n);
    }
};

void func()
{
    printf("void func()\n");
}

int main(int args, char* argv[])
{
    test t;

    delegate<int(*)(int)> d;
    d.set_function(&t, &test::func_int);
    d(123);//run test::func_int(0)

    //定义一个类型
    typedef delegate<void(*)()> void_func;
    void_func f;
    f.set_function(&t, &test::func);//绑定类函数
    f();

    f.set_function(&func);//绑定c函数
    f();

    system("pause");
}

程序输出：

test::func_int  123
test::func
void func()

欢迎测试反馈！

/*

 delegate.hpp

 委托类

 程序生成的代码，最大支持16个参数，支持__cdecl、__stdcall、__fastcall
 编辑器不支持C11也能用，c++builder 6.0测试可用
 为了通用性，只能这么暴力了

 sdragonx 2017-02-15 03:41:29

 sdragonx 1:05 2018/1/10 修订

 2018/7/29 1:31 __stdcall __fastcall等调用方式，gcc出现重定义错误。。所以
 修改了，只支持一种或定义的调用方式，一般来说够用了
 gcc 7.2.0测试通过

*/
#ifndef DELEGATE_HPP_20170215034129
#define DELEGATE_HPP_20170215034129

namespace cgl{

template<typename T>
class delegator_base;

template<typename T>
class delegate;

//设定函数调用方式 __cdecl __stdcall __fastcall
#ifndef CGL_DELEGATE_CALL
	#define CGL_DELEGATE_CALL
#endif

//---------------------------------------------------------------------------
// T (*)()

template<typename T>
class delegator_base<T (*)()>
{
public:
	virtual ~delegator_base(){ /*void*/ }
	virtual T invoke()=0;
	virtual delegator_base* clone()const=0;
};

template<typename classT, typename T>
class class_delegatorT0: public delegator_base<T (*)()>
{
public:
	typedef T CGL_DELEGATE_CALL (classT::*function_type)();
	classT *_C;
	function_type _F;
	class_delegatorT0(classT *c, function_type func):_C(c), _F(func){/*void*/}
	T invoke()
	{
		return (_C->*_F)();
	}
	delegator_base<T (*)()>* clone()const
	{
		return new class_delegatorT0(*this);
	}
};

template<typename T>
class delegatorT0 : public delegator_base<T (*)()>
{
public:
	typedef T CGL_DELEGATE_CALL (*function_type)();
	function_type _F;
	delegatorT0(function_type func):_F(func){/*void*/}
	T invoke()
	{
		return (*_F)();
	}
	delegator_base<T (*)()>* clone()const
	{
		return new delegatorT0(*this);
	}
};

template<typename T>
class delegate<T (*)()>
{
public:
	typedef T (*function_type)();
	typedef delegate<function_type> this_type;
	delegator_base<function_type> *base;
	delegate():base(0){/*void*/};
	delegate(const this_type& d):base(d.base_clone()){/*void*/}
	~delegate() { this->destroy(); }
	operator bool()const { return base; }
	void destroy() { if(base)delete base, base = 0; }
	delegator_base<function_type>* base_clone()const { if(base)return base->clone(); else return 0; }
	const this_type& operator=(const this_type& d)
	{
		this->destroy();
		base = d.base_clone();
		return *this;
	}
	T operator()()
	{
		return base->invoke();
	}
	template<typename classT>
	void set_function(classT *c, T CGL_DELEGATE_CALL (classT::*func)())
	{
		this->destroy();
		base = new class_delegatorT0<classT, T>(c, func);
	}
	void set_function(T CGL_DELEGATE_CALL (*func)())
	{
		this->destroy();
		base = new delegatorT0<T>(func);
	}
};

//---------------------------------------------------------------------------
// T (*)(T0)

template<typename T, typename T0>
class delegator_base<T (*)(T0)>
{
public:
	virtual ~delegator_base(){ /*void*/ }
	virtual T invoke(T0)=0;
	virtual delegator_base* clone()const=0;
};

template<typename classT, typename T, typename T0>
class class_delegatorT1: public delegator_base<T (*)(T0)>
{
public:
	typedef T CGL_DELEGATE_CALL (classT::*function_type)(T0);
	classT *_C;
	function_type _F;
	class_delegatorT1(classT *c, function_type func):_C(c), _F(func){/*void*/}
	T invoke(T0 p0)
	{
		return (_C->*_F)(p0);
	}
	delegator_base<T (*)(T0)>* clone()const
	{
		return new class_delegatorT1(*this);
	}
};

template<typename T, typename T0>
class delegatorT1 : public delegator_base<T (*)(T0)>
{
public:
	typedef T CGL_DELEGATE_CALL (*function_type)(T0);
	function_type _F;
	delegatorT1(function_type func):_F(func){/*void*/}
	T invoke(T0 p0)
	{
		return (*_F)(p0);
	}
	delegator_base<T (*)(T0)>* clone()const
	{
		return new delegatorT1(*this);
	}
};

template<typename T, typename T0>
class delegate<T (*)(T0)>
{
public:
	typedef T (*function_type)(T0);
	typedef delegate<function_type> this_type;
	delegator_base<function_type> *base;
	delegate():base(0){/*void*/};
	delegate(const this_type& d):base(d.base_clone()){/*void*/}
	~delegate() { this->destroy(); }
	operator bool()const { return base; }
	void destroy() { if(base)delete base, base = 0; }
	delegator_base<function_type>* base_clone()const { if(base)return base->clone(); else return 0; }
	const this_type& operator=(const this_type& d)
	{
		this->destroy();
		base = d.base_clone();
		return *this;
	}
	T operator()(T0 p0)
	{
		return base->invoke(p0);
	}
	template<typename classT>
	void set_function(classT *c, T CGL_DELEGATE_CALL (classT::*func)(T0))
	{
		this->destroy();
		base = new class_delegatorT1<classT, T, T0>(c, func);
	}
	void set_function(T CGL_DELEGATE_CALL (*func)(T0))
	{
		this->destroy();
		base = new delegatorT1<T, T0>(func);
	}
};

//---------------------------------------------------------------------------
// T (*)(T0, T1)

template<typename T, typename T0, typename T1>
class delegator_base<T (*)(T0, T1)>
{
public:
	virtual ~delegator_base(){ /*void*/ }
	virtual T invoke(T0, T1)=0;
	virtual delegator_base* clone()const=0;
};

template<typename classT, typename T, typename T0, typename T1>
class class_delegatorT2: public delegator_base<T (*)(T0, T1)>
{
public:
	typedef T CGL_DELEGATE_CALL (classT::*function_type)(T0, T1);
	classT *_C;
	function_type _F;
	class_delegatorT2(classT *c, function_type func):_C(c), _F(func){/*void*/}
	T invoke(T0 p0, T1 p1)
	{
		return (_C->*_F)(p0, p1);
	}
	delegator_base<T (*)(T0, T1)>* clone()const
	{
		return new class_delegatorT2(*this);
	}
};

template<typename T, typename T0, typename T1>
class delegatorT2 : public delegator_base<T (*)(T0, T1)>
{
public:
	typedef T CGL_DELEGATE_CALL (*function_type)(T0, T1);
	function_type _F;
	delegatorT2(function_type func):_F(func){/*void*/}
	T invoke(T0 p0, T1 p1)
	{
		return (*_F)(p0, p1);
	}
	delegator_base<T (*)(T0, T1)>* clone()const
	{
		return new delegatorT2(*this);
	}
};

template<typename T, typename T0, typename T1>
class delegate<T (*)(T0, T1)>
{
public:
	typedef T (*function_type)(T0, T1);
	typedef delegate<function_type> this_type;
	delegator_base<function_type> *base;
	delegate():base(0){/*void*/};
	delegate(const this_type& d):base(d.base_clone()){/*void*/}
	~delegate() { this->destroy(); }
	operator bool()const { return base; }
	void destroy() { if(base)delete base, base = 0; }
	delegator_base<function_type>* base_clone()const { if(base)return base->clone(); else return 0; }
	const this_type& operator=(const this_type& d)
	{
		this->destroy();
		base = d.base_clone();
		return *this;
	}
	T operator()(T0 p0, T1 p1)
	{
		return base->invoke(p0, p1);
	}
	template<typename classT>
	void set_function(classT *c, T CGL_DELEGATE_CALL (classT::*func)(T0, T1))
	{
		this->destroy();
		base = new class_delegatorT2<classT, T, T0, T1>(c, func);
	}
	void set_function(T CGL_DELEGATE_CALL (*func)(T0, T1))
	{
		this->destroy();
		base = new delegatorT2<T, T0, T1>(func);
	}
};

//---------------------------------------------------------------------------
// T (*)(T0, T1, T2)

template<typename T, typename T0, typename T1, typename T2>
class delegator_base<T (*)(T0, T1, T2)>
{
public:
	virtual ~delegator_base(){ /*void*/ }
	virtual T invoke(T0, T1, T2)=0;
	virtual delegator_base* clone()const=0;
};

template<typename classT, typename T, typename T0, typename T1, typename T2>
class class_delegatorT3: public delegator_base<T (*)(T0, T1, T2)>
{
public:
	typedef T CGL_DELEGATE_CALL (classT::*function_type)(T0, T1, T2);
	classT *_C;
	function_type _F;
	class_delegatorT3(classT *c, function_type func):_C(c), _F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2)
	{
		return (_C->*_F)(p0, p1, p2);
	}
	delegator_base<T (*)(T0, T1, T2)>* clone()const
	{
		return new class_delegatorT3(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2>
class delegatorT3 : public delegator_base<T (*)(T0, T1, T2)>
{
public:
	typedef T CGL_DELEGATE_CALL (*function_type)(T0, T1, T2);
	function_type _F;
	delegatorT3(function_type func):_F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2)
	{
		return (*_F)(p0, p1, p2);
	}
	delegator_base<T (*)(T0, T1, T2)>* clone()const
	{
		return new delegatorT3(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2>
class delegate<T (*)(T0, T1, T2)>
{
public:
	typedef T (*function_type)(T0, T1, T2);
	typedef delegate<function_type> this_type;
	delegator_base<function_type> *base;
	delegate():base(0){/*void*/};
	delegate(const this_type& d):base(d.base_clone()){/*void*/}
	~delegate() { this->destroy(); }
	operator bool()const { return base; }
	void destroy() { if(base)delete base, base = 0; }
	delegator_base<function_type>* base_clone()const { if(base)return base->clone(); else return 0; }
	const this_type& operator=(const this_type& d)
	{
		this->destroy();
		base = d.base_clone();
		return *this;
	}
	T operator()(T0 p0, T1 p1, T2 p2)
	{
		return base->invoke(p0, p1, p2);
	}
	template<typename classT>
	void set_function(classT *c, T CGL_DELEGATE_CALL (classT::*func)(T0, T1, T2))
	{
		this->destroy();
		base = new class_delegatorT3<classT, T, T0, T1, T2>(c, func);
	}
	void set_function(T CGL_DELEGATE_CALL (*func)(T0, T1, T2))
	{
		this->destroy();
		base = new delegatorT3<T, T0, T1, T2>(func);
	}
};

//---------------------------------------------------------------------------
// T (*)(T0, T1, T2, T3)

template<typename T, typename T0, typename T1, typename T2, typename T3>
class delegator_base<T (*)(T0, T1, T2, T3)>
{
public:
	virtual ~delegator_base(){ /*void*/ }
	virtual T invoke(T0, T1, T2, T3)=0;
	virtual delegator_base* clone()const=0;
};

template<typename classT, typename T, typename T0, typename T1, typename T2, typename T3>
class class_delegatorT4: public delegator_base<T (*)(T0, T1, T2, T3)>
{
public:
	typedef T CGL_DELEGATE_CALL (classT::*function_type)(T0, T1, T2, T3);
	classT *_C;
	function_type _F;
	class_delegatorT4(classT *c, function_type func):_C(c), _F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3)
	{
		return (_C->*_F)(p0, p1, p2, p3);
	}
	delegator_base<T (*)(T0, T1, T2, T3)>* clone()const
	{
		return new class_delegatorT4(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3>
class delegatorT4 : public delegator_base<T (*)(T0, T1, T2, T3)>
{
public:
	typedef T CGL_DELEGATE_CALL (*function_type)(T0, T1, T2, T3);
	function_type _F;
	delegatorT4(function_type func):_F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3)
	{
		return (*_F)(p0, p1, p2, p3);
	}
	delegator_base<T (*)(T0, T1, T2, T3)>* clone()const
	{
		return new delegatorT4(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3>
class delegate<T (*)(T0, T1, T2, T3)>
{
public:
	typedef T (*function_type)(T0, T1, T2, T3);
	typedef delegate<function_type> this_type;
	delegator_base<function_type> *base;
	delegate():base(0){/*void*/};
	delegate(const this_type& d):base(d.base_clone()){/*void*/}
	~delegate() { this->destroy(); }
	operator bool()const { return base; }
	void destroy() { if(base)delete base, base = 0; }
	delegator_base<function_type>* base_clone()const { if(base)return base->clone(); else return 0; }
	const this_type& operator=(const this_type& d)
	{
		this->destroy();
		base = d.base_clone();
		return *this;
	}
	T operator()(T0 p0, T1 p1, T2 p2, T3 p3)
	{
		return base->invoke(p0, p1, p2, p3);
	}
	template<typename classT>
	void set_function(classT *c, T CGL_DELEGATE_CALL (classT::*func)(T0, T1, T2, T3))
	{
		this->destroy();
		base = new class_delegatorT4<classT, T, T0, T1, T2, T3>(c, func);
	}
	void set_function(T CGL_DELEGATE_CALL (*func)(T0, T1, T2, T3))
	{
		this->destroy();
		base = new delegatorT4<T, T0, T1, T2, T3>(func);
	}
};

//---------------------------------------------------------------------------
// T (*)(T0, T1, T2, T3, T4)

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4>
class delegator_base<T (*)(T0, T1, T2, T3, T4)>
{
public:
	virtual ~delegator_base(){ /*void*/ }
	virtual T invoke(T0, T1, T2, T3, T4)=0;
	virtual delegator_base* clone()const=0;
};

template<typename classT, typename T, typename T0, typename T1, typename T2, typename T3, typename T4>
class class_delegatorT5: public delegator_base<T (*)(T0, T1, T2, T3, T4)>
{
public:
	typedef T CGL_DELEGATE_CALL (classT::*function_type)(T0, T1, T2, T3, T4);
	classT *_C;
	function_type _F;
	class_delegatorT5(classT *c, function_type func):_C(c), _F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4)
	{
		return (_C->*_F)(p0, p1, p2, p3, p4);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4)>* clone()const
	{
		return new class_delegatorT5(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4>
class delegatorT5 : public delegator_base<T (*)(T0, T1, T2, T3, T4)>
{
public:
	typedef T CGL_DELEGATE_CALL (*function_type)(T0, T1, T2, T3, T4);
	function_type _F;
	delegatorT5(function_type func):_F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4)
	{
		return (*_F)(p0, p1, p2, p3, p4);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4)>* clone()const
	{
		return new delegatorT5(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4>
class delegate<T (*)(T0, T1, T2, T3, T4)>
{
public:
	typedef T (*function_type)(T0, T1, T2, T3, T4);
	typedef delegate<function_type> this_type;
	delegator_base<function_type> *base;
	delegate():base(0){/*void*/};
	delegate(const this_type& d):base(d.base_clone()){/*void*/}
	~delegate() { this->destroy(); }
	operator bool()const { return base; }
	void destroy() { if(base)delete base, base = 0; }
	delegator_base<function_type>* base_clone()const { if(base)return base->clone(); else return 0; }
	const this_type& operator=(const this_type& d)
	{
		this->destroy();
		base = d.base_clone();
		return *this;
	}
	T operator()(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4)
	{
		return base->invoke(p0, p1, p2, p3, p4);
	}
	template<typename classT>
	void set_function(classT *c, T CGL_DELEGATE_CALL (classT::*func)(T0, T1, T2, T3, T4))
	{
		this->destroy();
		base = new class_delegatorT5<classT, T, T0, T1, T2, T3, T4>(c, func);
	}
	void set_function(T CGL_DELEGATE_CALL (*func)(T0, T1, T2, T3, T4))
	{
		this->destroy();
		base = new delegatorT5<T, T0, T1, T2, T3, T4>(func);
	}
};

//---------------------------------------------------------------------------
// T (*)(T0, T1, T2, T3, T4, T5)

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
class delegator_base<T (*)(T0, T1, T2, T3, T4, T5)>
{
public:
	virtual ~delegator_base(){ /*void*/ }
	virtual T invoke(T0, T1, T2, T3, T4, T5)=0;
	virtual delegator_base* clone()const=0;
};

template<typename classT, typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
class class_delegatorT6: public delegator_base<T (*)(T0, T1, T2, T3, T4, T5)>
{
public:
	typedef T CGL_DELEGATE_CALL (classT::*function_type)(T0, T1, T2, T3, T4, T5);
	classT *_C;
	function_type _F;
	class_delegatorT6(classT *c, function_type func):_C(c), _F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5)
	{
		return (_C->*_F)(p0, p1, p2, p3, p4, p5);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4, T5)>* clone()const
	{
		return new class_delegatorT6(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
class delegatorT6 : public delegator_base<T (*)(T0, T1, T2, T3, T4, T5)>
{
public:
	typedef T CGL_DELEGATE_CALL (*function_type)(T0, T1, T2, T3, T4, T5);
	function_type _F;
	delegatorT6(function_type func):_F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5)
	{
		return (*_F)(p0, p1, p2, p3, p4, p5);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4, T5)>* clone()const
	{
		return new delegatorT6(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
class delegate<T (*)(T0, T1, T2, T3, T4, T5)>
{
public:
	typedef T (*function_type)(T0, T1, T2, T3, T4, T5);
	typedef delegate<function_type> this_type;
	delegator_base<function_type> *base;
	delegate():base(0){/*void*/};
	delegate(const this_type& d):base(d.base_clone()){/*void*/}
	~delegate() { this->destroy(); }
	operator bool()const { return base; }
	void destroy() { if(base)delete base, base = 0; }
	delegator_base<function_type>* base_clone()const { if(base)return base->clone(); else return 0; }
	const this_type& operator=(const this_type& d)
	{
		this->destroy();
		base = d.base_clone();
		return *this;
	}
	T operator()(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5)
	{
		return base->invoke(p0, p1, p2, p3, p4, p5);
	}
	template<typename classT>
	void set_function(classT *c, T CGL_DELEGATE_CALL (classT::*func)(T0, T1, T2, T3, T4, T5))
	{
		this->destroy();
		base = new class_delegatorT6<classT, T, T0, T1, T2, T3, T4, T5>(c, func);
	}
	void set_function(T CGL_DELEGATE_CALL (*func)(T0, T1, T2, T3, T4, T5))
	{
		this->destroy();
		base = new delegatorT6<T, T0, T1, T2, T3, T4, T5>(func);
	}
};

//---------------------------------------------------------------------------
// T (*)(T0, T1, T2, T3, T4, T5, T6)

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
class delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6)>
{
public:
	virtual ~delegator_base(){ /*void*/ }
	virtual T invoke(T0, T1, T2, T3, T4, T5, T6)=0;
	virtual delegator_base* clone()const=0;
};

template<typename classT, typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
class class_delegatorT7: public delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6)>
{
public:
	typedef T CGL_DELEGATE_CALL (classT::*function_type)(T0, T1, T2, T3, T4, T5, T6);
	classT *_C;
	function_type _F;
	class_delegatorT7(classT *c, function_type func):_C(c), _F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6)
	{
		return (_C->*_F)(p0, p1, p2, p3, p4, p5, p6);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6)>* clone()const
	{
		return new class_delegatorT7(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
class delegatorT7 : public delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6)>
{
public:
	typedef T CGL_DELEGATE_CALL (*function_type)(T0, T1, T2, T3, T4, T5, T6);
	function_type _F;
	delegatorT7(function_type func):_F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6)
	{
		return (*_F)(p0, p1, p2, p3, p4, p5, p6);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6)>* clone()const
	{
		return new delegatorT7(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
class delegate<T (*)(T0, T1, T2, T3, T4, T5, T6)>
{
public:
	typedef T (*function_type)(T0, T1, T2, T3, T4, T5, T6);
	typedef delegate<function_type> this_type;
	delegator_base<function_type> *base;
	delegate():base(0){/*void*/};
	delegate(const this_type& d):base(d.base_clone()){/*void*/}
	~delegate() { this->destroy(); }
	operator bool()const { return base; }
	void destroy() { if(base)delete base, base = 0; }
	delegator_base<function_type>* base_clone()const { if(base)return base->clone(); else return 0; }
	const this_type& operator=(const this_type& d)
	{
		this->destroy();
		base = d.base_clone();
		return *this;
	}
	T operator()(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6)
	{
		return base->invoke(p0, p1, p2, p3, p4, p5, p6);
	}
	template<typename classT>
	void set_function(classT *c, T CGL_DELEGATE_CALL (classT::*func)(T0, T1, T2, T3, T4, T5, T6))
	{
		this->destroy();
		base = new class_delegatorT7<classT, T, T0, T1, T2, T3, T4, T5, T6>(c, func);
	}
	void set_function(T CGL_DELEGATE_CALL (*func)(T0, T1, T2, T3, T4, T5, T6))
	{
		this->destroy();
		base = new delegatorT7<T, T0, T1, T2, T3, T4, T5, T6>(func);
	}
};

//---------------------------------------------------------------------------
// T (*)(T0, T1, T2, T3, T4, T5, T6, T7)

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
class delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7)>
{
public:
	virtual ~delegator_base(){ /*void*/ }
	virtual T invoke(T0, T1, T2, T3, T4, T5, T6, T7)=0;
	virtual delegator_base* clone()const=0;
};

template<typename classT, typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
class class_delegatorT8: public delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7)>
{
public:
	typedef T CGL_DELEGATE_CALL (classT::*function_type)(T0, T1, T2, T3, T4, T5, T6, T7);
	classT *_C;
	function_type _F;
	class_delegatorT8(classT *c, function_type func):_C(c), _F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7)
	{
		return (_C->*_F)(p0, p1, p2, p3, p4, p5, p6, p7);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7)>* clone()const
	{
		return new class_delegatorT8(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
class delegatorT8 : public delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7)>
{
public:
	typedef T CGL_DELEGATE_CALL (*function_type)(T0, T1, T2, T3, T4, T5, T6, T7);
	function_type _F;
	delegatorT8(function_type func):_F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7)
	{
		return (*_F)(p0, p1, p2, p3, p4, p5, p6, p7);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7)>* clone()const
	{
		return new delegatorT8(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
class delegate<T (*)(T0, T1, T2, T3, T4, T5, T6, T7)>
{
public:
	typedef T (*function_type)(T0, T1, T2, T3, T4, T5, T6, T7);
	typedef delegate<function_type> this_type;
	delegator_base<function_type> *base;
	delegate():base(0){/*void*/};
	delegate(const this_type& d):base(d.base_clone()){/*void*/}
	~delegate() { this->destroy(); }
	operator bool()const { return base; }
	void destroy() { if(base)delete base, base = 0; }
	delegator_base<function_type>* base_clone()const { if(base)return base->clone(); else return 0; }
	const this_type& operator=(const this_type& d)
	{
		this->destroy();
		base = d.base_clone();
		return *this;
	}
	T operator()(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7)
	{
		return base->invoke(p0, p1, p2, p3, p4, p5, p6, p7);
	}
	template<typename classT>
	void set_function(classT *c, T CGL_DELEGATE_CALL (classT::*func)(T0, T1, T2, T3, T4, T5, T6, T7))
	{
		this->destroy();
		base = new class_delegatorT8<classT, T, T0, T1, T2, T3, T4, T5, T6, T7>(c, func);
	}
	void set_function(T CGL_DELEGATE_CALL (*func)(T0, T1, T2, T3, T4, T5, T6, T7))
	{
		this->destroy();
		base = new delegatorT8<T, T0, T1, T2, T3, T4, T5, T6, T7>(func);
	}
};

//---------------------------------------------------------------------------
// T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
class delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)>
{
public:
	virtual ~delegator_base(){ /*void*/ }
	virtual T invoke(T0, T1, T2, T3, T4, T5, T6, T7, T8)=0;
	virtual delegator_base* clone()const=0;
};

template<typename classT, typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
class class_delegatorT9: public delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)>
{
public:
	typedef T CGL_DELEGATE_CALL (classT::*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8);
	classT *_C;
	function_type _F;
	class_delegatorT9(classT *c, function_type func):_C(c), _F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8)
	{
		return (_C->*_F)(p0, p1, p2, p3, p4, p5, p6, p7, p8);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)>* clone()const
	{
		return new class_delegatorT9(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
class delegatorT9 : public delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)>
{
public:
	typedef T CGL_DELEGATE_CALL (*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8);
	function_type _F;
	delegatorT9(function_type func):_F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8)
	{
		return (*_F)(p0, p1, p2, p3, p4, p5, p6, p7, p8);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)>* clone()const
	{
		return new delegatorT9(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
class delegate<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)>
{
public:
	typedef T (*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8);
	typedef delegate<function_type> this_type;
	delegator_base<function_type> *base;
	delegate():base(0){/*void*/};
	delegate(const this_type& d):base(d.base_clone()){/*void*/}
	~delegate() { this->destroy(); }
	operator bool()const { return base; }
	void destroy() { if(base)delete base, base = 0; }
	delegator_base<function_type>* base_clone()const { if(base)return base->clone(); else return 0; }
	const this_type& operator=(const this_type& d)
	{
		this->destroy();
		base = d.base_clone();
		return *this;
	}
	T operator()(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8)
	{
		return base->invoke(p0, p1, p2, p3, p4, p5, p6, p7, p8);
	}
	template<typename classT>
	void set_function(classT *c, T CGL_DELEGATE_CALL (classT::*func)(T0, T1, T2, T3, T4, T5, T6, T7, T8))
	{
		this->destroy();
		base = new class_delegatorT9<classT, T, T0, T1, T2, T3, T4, T5, T6, T7, T8>(c, func);
	}
	void set_function(T CGL_DELEGATE_CALL (*func)(T0, T1, T2, T3, T4, T5, T6, T7, T8))
	{
		this->destroy();
		base = new delegatorT9<T, T0, T1, T2, T3, T4, T5, T6, T7, T8>(func);
	}
};

//---------------------------------------------------------------------------
// T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
class delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>
{
public:
	virtual ~delegator_base(){ /*void*/ }
	virtual T invoke(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)=0;
	virtual delegator_base* clone()const=0;
};

template<typename classT, typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
class class_delegatorT10: public delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>
{
public:
	typedef T CGL_DELEGATE_CALL (classT::*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9);
	classT *_C;
	function_type _F;
	class_delegatorT10(classT *c, function_type func):_C(c), _F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9)
	{
		return (_C->*_F)(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>* clone()const
	{
		return new class_delegatorT10(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
class delegatorT10 : public delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>
{
public:
	typedef T CGL_DELEGATE_CALL (*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9);
	function_type _F;
	delegatorT10(function_type func):_F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9)
	{
		return (*_F)(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>* clone()const
	{
		return new delegatorT10(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
class delegate<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>
{
public:
	typedef T (*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9);
	typedef delegate<function_type> this_type;
	delegator_base<function_type> *base;
	delegate():base(0){/*void*/};
	delegate(const this_type& d):base(d.base_clone()){/*void*/}
	~delegate() { this->destroy(); }
	operator bool()const { return base; }
	void destroy() { if(base)delete base, base = 0; }
	delegator_base<function_type>* base_clone()const { if(base)return base->clone(); else return 0; }
	const this_type& operator=(const this_type& d)
	{
		this->destroy();
		base = d.base_clone();
		return *this;
	}
	T operator()(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9)
	{
		return base->invoke(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
	}
	template<typename classT>
	void set_function(classT *c, T CGL_DELEGATE_CALL (classT::*func)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9))
	{
		this->destroy();
		base = new class_delegatorT10<classT, T, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(c, func);
	}
	void set_function(T CGL_DELEGATE_CALL (*func)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9))
	{
		this->destroy();
		base = new delegatorT10<T, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(func);
	}
};

//---------------------------------------------------------------------------
// T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
class delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
{
public:
	virtual ~delegator_base(){ /*void*/ }
	virtual T invoke(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)=0;
	virtual delegator_base* clone()const=0;
};

template<typename classT, typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
class class_delegatorT11: public delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
{
public:
	typedef T CGL_DELEGATE_CALL (classT::*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10);
	classT *_C;
	function_type _F;
	class_delegatorT11(classT *c, function_type func):_C(c), _F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9, T10 p10)
	{
		return (_C->*_F)(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>* clone()const
	{
		return new class_delegatorT11(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
class delegatorT11 : public delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
{
public:
	typedef T CGL_DELEGATE_CALL (*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10);
	function_type _F;
	delegatorT11(function_type func):_F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9, T10 p10)
	{
		return (*_F)(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>* clone()const
	{
		return new delegatorT11(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
class delegate<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
{
public:
	typedef T (*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10);
	typedef delegate<function_type> this_type;
	delegator_base<function_type> *base;
	delegate():base(0){/*void*/};
	delegate(const this_type& d):base(d.base_clone()){/*void*/}
	~delegate() { this->destroy(); }
	operator bool()const { return base; }
	void destroy() { if(base)delete base, base = 0; }
	delegator_base<function_type>* base_clone()const { if(base)return base->clone(); else return 0; }
	const this_type& operator=(const this_type& d)
	{
		this->destroy();
		base = d.base_clone();
		return *this;
	}
	T operator()(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9, T10 p10)
	{
		return base->invoke(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
	}
	template<typename classT>
	void set_function(classT *c, T CGL_DELEGATE_CALL (classT::*func)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10))
	{
		this->destroy();
		base = new class_delegatorT11<classT, T, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(c, func);
	}
	void set_function(T CGL_DELEGATE_CALL (*func)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10))
	{
		this->destroy();
		base = new delegatorT11<T, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(func);
	}
};

//---------------------------------------------------------------------------
// T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
class delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>
{
public:
	virtual ~delegator_base(){ /*void*/ }
	virtual T invoke(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)=0;
	virtual delegator_base* clone()const=0;
};

template<typename classT, typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
class class_delegatorT12: public delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>
{
public:
	typedef T CGL_DELEGATE_CALL (classT::*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11);
	classT *_C;
	function_type _F;
	class_delegatorT12(classT *c, function_type func):_C(c), _F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9, T10 p10, T11 p11)
	{
		return (_C->*_F)(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>* clone()const
	{
		return new class_delegatorT12(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
class delegatorT12 : public delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>
{
public:
	typedef T CGL_DELEGATE_CALL (*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11);
	function_type _F;
	delegatorT12(function_type func):_F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9, T10 p10, T11 p11)
	{
		return (*_F)(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>* clone()const
	{
		return new delegatorT12(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
class delegate<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>
{
public:
	typedef T (*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11);
	typedef delegate<function_type> this_type;
	delegator_base<function_type> *base;
	delegate():base(0){/*void*/};
	delegate(const this_type& d):base(d.base_clone()){/*void*/}
	~delegate() { this->destroy(); }
	operator bool()const { return base; }
	void destroy() { if(base)delete base, base = 0; }
	delegator_base<function_type>* base_clone()const { if(base)return base->clone(); else return 0; }
	const this_type& operator=(const this_type& d)
	{
		this->destroy();
		base = d.base_clone();
		return *this;
	}
	T operator()(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9, T10 p10, T11 p11)
	{
		return base->invoke(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
	}
	template<typename classT>
	void set_function(classT *c, T CGL_DELEGATE_CALL (classT::*func)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11))
	{
		this->destroy();
		base = new class_delegatorT12<classT, T, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(c, func);
	}
	void set_function(T CGL_DELEGATE_CALL (*func)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11))
	{
		this->destroy();
		base = new delegatorT12<T, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(func);
	}
};

//---------------------------------------------------------------------------
// T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
class delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>
{
public:
	virtual ~delegator_base(){ /*void*/ }
	virtual T invoke(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)=0;
	virtual delegator_base* clone()const=0;
};

template<typename classT, typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
class class_delegatorT13: public delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>
{
public:
	typedef T CGL_DELEGATE_CALL (classT::*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12);
	classT *_C;
	function_type _F;
	class_delegatorT13(classT *c, function_type func):_C(c), _F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9, T10 p10, T11 p11, T12 p12)
	{
		return (_C->*_F)(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>* clone()const
	{
		return new class_delegatorT13(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
class delegatorT13 : public delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>
{
public:
	typedef T CGL_DELEGATE_CALL (*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12);
	function_type _F;
	delegatorT13(function_type func):_F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9, T10 p10, T11 p11, T12 p12)
	{
		return (*_F)(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>* clone()const
	{
		return new delegatorT13(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
class delegate<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>
{
public:
	typedef T (*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12);
	typedef delegate<function_type> this_type;
	delegator_base<function_type> *base;
	delegate():base(0){/*void*/};
	delegate(const this_type& d):base(d.base_clone()){/*void*/}
	~delegate() { this->destroy(); }
	operator bool()const { return base; }
	void destroy() { if(base)delete base, base = 0; }
	delegator_base<function_type>* base_clone()const { if(base)return base->clone(); else return 0; }
	const this_type& operator=(const this_type& d)
	{
		this->destroy();
		base = d.base_clone();
		return *this;
	}
	T operator()(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9, T10 p10, T11 p11, T12 p12)
	{
		return base->invoke(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
	}
	template<typename classT>
	void set_function(classT *c, T CGL_DELEGATE_CALL (classT::*func)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12))
	{
		this->destroy();
		base = new class_delegatorT13<classT, T, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(c, func);
	}
	void set_function(T CGL_DELEGATE_CALL (*func)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12))
	{
		this->destroy();
		base = new delegatorT13<T, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(func);
	}
};

//---------------------------------------------------------------------------
// T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
class delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>
{
public:
	virtual ~delegator_base(){ /*void*/ }
	virtual T invoke(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)=0;
	virtual delegator_base* clone()const=0;
};

template<typename classT, typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
class class_delegatorT14: public delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>
{
public:
	typedef T CGL_DELEGATE_CALL (classT::*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13);
	classT *_C;
	function_type _F;
	class_delegatorT14(classT *c, function_type func):_C(c), _F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9, T10 p10, T11 p11, T12 p12, T13 p13)
	{
		return (_C->*_F)(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>* clone()const
	{
		return new class_delegatorT14(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
class delegatorT14 : public delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>
{
public:
	typedef T CGL_DELEGATE_CALL (*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13);
	function_type _F;
	delegatorT14(function_type func):_F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9, T10 p10, T11 p11, T12 p12, T13 p13)
	{
		return (*_F)(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>* clone()const
	{
		return new delegatorT14(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
class delegate<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>
{
public:
	typedef T (*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13);
	typedef delegate<function_type> this_type;
	delegator_base<function_type> *base;
	delegate():base(0){/*void*/};
	delegate(const this_type& d):base(d.base_clone()){/*void*/}
	~delegate() { this->destroy(); }
	operator bool()const { return base; }
	void destroy() { if(base)delete base, base = 0; }
	delegator_base<function_type>* base_clone()const { if(base)return base->clone(); else return 0; }
	const this_type& operator=(const this_type& d)
	{
		this->destroy();
		base = d.base_clone();
		return *this;
	}
	T operator()(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9, T10 p10, T11 p11, T12 p12, T13 p13)
	{
		return base->invoke(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
	}
	template<typename classT>
	void set_function(classT *c, T CGL_DELEGATE_CALL (classT::*func)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13))
	{
		this->destroy();
		base = new class_delegatorT14<classT, T, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(c, func);
	}
	void set_function(T CGL_DELEGATE_CALL (*func)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13))
	{
		this->destroy();
		base = new delegatorT14<T, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(func);
	}
};

//---------------------------------------------------------------------------
// T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
class delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>
{
public:
	virtual ~delegator_base(){ /*void*/ }
	virtual T invoke(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)=0;
	virtual delegator_base* clone()const=0;
};

template<typename classT, typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
class class_delegatorT15: public delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>
{
public:
	typedef T CGL_DELEGATE_CALL (classT::*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14);
	classT *_C;
	function_type _F;
	class_delegatorT15(classT *c, function_type func):_C(c), _F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9, T10 p10, T11 p11, T12 p12, T13 p13, T14 p14)
	{
		return (_C->*_F)(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>* clone()const
	{
		return new class_delegatorT15(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
class delegatorT15 : public delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>
{
public:
	typedef T CGL_DELEGATE_CALL (*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14);
	function_type _F;
	delegatorT15(function_type func):_F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9, T10 p10, T11 p11, T12 p12, T13 p13, T14 p14)
	{
		return (*_F)(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>* clone()const
	{
		return new delegatorT15(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
class delegate<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>
{
public:
	typedef T (*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14);
	typedef delegate<function_type> this_type;
	delegator_base<function_type> *base;
	delegate():base(0){/*void*/};
	delegate(const this_type& d):base(d.base_clone()){/*void*/}
	~delegate() { this->destroy(); }
	operator bool()const { return base; }
	void destroy() { if(base)delete base, base = 0; }
	delegator_base<function_type>* base_clone()const { if(base)return base->clone(); else return 0; }
	const this_type& operator=(const this_type& d)
	{
		this->destroy();
		base = d.base_clone();
		return *this;
	}
	T operator()(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9, T10 p10, T11 p11, T12 p12, T13 p13, T14 p14)
	{
		return base->invoke(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
	}
	template<typename classT>
	void set_function(classT *c, T CGL_DELEGATE_CALL (classT::*func)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14))
	{
		this->destroy();
		base = new class_delegatorT15<classT, T, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(c, func);
	}
	void set_function(T CGL_DELEGATE_CALL (*func)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14))
	{
		this->destroy();
		base = new delegatorT15<T, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(func);
	}
};

//---------------------------------------------------------------------------
// T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
class delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>
{
public:
	virtual ~delegator_base(){ /*void*/ }
	virtual T invoke(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)=0;
	virtual delegator_base* clone()const=0;
};

template<typename classT, typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
class class_delegatorT16: public delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>
{
public:
	typedef T CGL_DELEGATE_CALL (classT::*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15);
	classT *_C;
	function_type _F;
	class_delegatorT16(classT *c, function_type func):_C(c), _F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9, T10 p10, T11 p11, T12 p12, T13 p13, T14 p14, T15 p15)
	{
		return (_C->*_F)(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>* clone()const
	{
		return new class_delegatorT16(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
class delegatorT16 : public delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>
{
public:
	typedef T CGL_DELEGATE_CALL (*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15);
	function_type _F;
	delegatorT16(function_type func):_F(func){/*void*/}
	T invoke(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9, T10 p10, T11 p11, T12 p12, T13 p13, T14 p14, T15 p15)
	{
		return (*_F)(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);
	}
	delegator_base<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>* clone()const
	{
		return new delegatorT16(*this);
	}
};

template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
class delegate<T (*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>
{
public:
	typedef T (*function_type)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15);
	typedef delegate<function_type> this_type;
	delegator_base<function_type> *base;
	delegate():base(0){/*void*/};
	delegate(const this_type& d):base(d.base_clone()){/*void*/}
	~delegate() { this->destroy(); }
	operator bool()const { return base; }
	void destroy() { if(base)delete base, base = 0; }
	delegator_base<function_type>* base_clone()const { if(base)return base->clone(); else return 0; }
	const this_type& operator=(const this_type& d)
	{
		this->destroy();
		base = d.base_clone();
		return *this;
	}
	T operator()(T0 p0, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, T8 p8, T9 p9, T10 p10, T11 p11, T12 p12, T13 p13, T14 p14, T15 p15)
	{
		return base->invoke(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);
	}
	template<typename classT>
	void set_function(classT *c, T CGL_DELEGATE_CALL (classT::*func)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15))
	{
		this->destroy();
		base = new class_delegatorT16<classT, T, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(c, func);
	}
	void set_function(T CGL_DELEGATE_CALL (*func)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15))
	{
		this->destroy();
		base = new delegatorT16<T, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(func);
	}
};

} //end namespace cgl

#endif // DELEGATE_HPP_20170215034129

 

sdragonx
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于c#调用C++代码的一些应用的体会
12-22
在C#中调用C++代码是一个常见的跨语言交互需求，尤其在利用现有的C++库或需要高效计算的场景下。下面将详细讲解这个过程涉及的关键技术和注意事项。 1. **DLL函数导入**： C#中调用C++动态链接库（DLL）的功能主要...
实现高效C++委托的代码
10-14
在C++编程中，委托（Delegate）是一种设计模式，它允许将函数或方法作为参数传递，使得函数可以作为另一种函数的输入，增强了代码的灵活性和可扩展性。在这个主题中，我们将深入探讨Don Clugston大神实现的高效C++...
C# 中用delegate传递多个参数给多线程的疑问及探索
weixin_30628077的博客
04-11 297
在线程编程中，我们都知道一般给线程传递参数的大致有三种方式： 1.方式一：使用ParameterizedThreadStart委托 如果使用了ParameterizedThreadStart委托，线程的入口必须有一个object类型的参数，且返回类型为void. View Code using System; using System.Threading; ...
委托模式（转自：http://www.uml.org.cn/j2ee/200411036.htm）
chz870128的专栏
07-05 1313
委托模式透明 选择自 www.c-view.org 梗概委托是对一个类的功能进行扩展和复用的方法。它的做法是：写一个附加的类提供附加的功能，并使用原来的类的实例提供原有的功能。 场景扩展和复用一个类的功能常用的一种方法是继承，而另一种更普遍的方法则是委托。在很
C#中delegate用法（带参数）
热门推荐
小鹰信息技术服务部
10-25 1万+
近期写了几个C#客户端软件，其中，上传数据时另开线程，同时要更新UI，跨线程操作，用到委托。用法如下： //委托 public delegate void delegate1(string str); //方法 private void showUpdateProgress(string content) { //... rtbxUploadLog.Text += content;
C++中实现委托（Delegate）
huangwei.pro
11-17 1568
<br />http://blog.huang-wei.com/2010/08/09/c%E4%B8%AD%E5%AE%9E%E7%8E%B0%E5%A7%94%E6%89%98%EF%BC%88delegate%EF%BC%89/<br /> C++中实现委托（Delegate）<br />公司的项目里有用到Don Clugston的FastDelegate，当时只知道是类似boost::function的东西，UI上当watcher用的比较多，所以也没去关注。今天想写个事件触发器时，突然想起这茬子，看来
在C++中实现委托（Delegate）——普通函数（一）
斧冰
03-23 982
为了一步步实现委托，同时也为了方便将目标问题拆解，我们采用先从普通函数入手，再到成员函数，逐步实现类似于C#中的委托。 首先，明确目标： 一、目标 #include <iostream> #include "CMultiDelegate.h" #include "CStaticDelegate.h" void Say() { printf("void Say(): Hello wo...
C# DLL影子生成程序,DLL转LIB
03-25
标题 "C# DLL影子生成程序,DLL转LIB" 提供了关于一个特定软件开发工具的信息，该工具用于创建C#动态链接库（DLL）的“影子”代码，并能够将其转换为LIB文件，适用于Visual Studio 2008环境。这种工具的主要目标是...
C#Winform动态调用C++和C#的Dll
11-20
在IT行业中，动态链接库（DLL）是一种共享代码的方式，它可以被多个应用程序同时使用，以减少内存占用并提高效率。本文将重点讲解如何在C#的Winform应用中动态调用C++和C#编写的DLL，并将DLL作为嵌入资源处理，避免...
C++ 委托 fastdelegate使用，实现类函数回调绑定
03-26
在C++编程中，回调机制是一种常见的设计模式，它允许我们传递一个函数或者函数指针到另一个函数，以便在适当的时候被调用。这在事件处理、异步操作或者插件系统等场景中非常常见。然而，C++的标准库并没有提供内置的...
c#调用C++DLL实例
02-28
C#使用P/Invoke（Platform Invoke）机制来调用非托管代码，这需要在C#中定义一个与C++函数签名匹配的委托，并使用`DllImport`特性来加载DLL。如下所示： ```csharp // 在C#中定义对应C++函数的委托 public delegate...
c#调用c++代码(dll)
10-08
DLL是Windows操作系统中的一个共享库，它包含可由多个程序同时使用的代码和数据。C++程序员经常使用DLL来封装复杂的功能，以便其他程序可以方便地调用。 在C#中调用C++ DLL主要通过P/Invoke（Platform Invoke）技术...
C++和C#的却别与各自的用法
07-14
C++和C#是两种广泛使用的编程语言，它们在设计理念、特性和用途上有显著的差异。C++起源于C语言，旨在提供高级的面向对象特性，同时保持与C语言的兼容性，允许直接访问硬件资源，因此在系统级编程和高性能应用中占据...
C#调用c++工程文件（调试已通过）
04-28
2. **定义C#中的委托类型**：在C#中，为C++ DLL中的每个函数创建一个对应的委托类型，指定函数的返回类型和参数类型。例如： ```csharp [UnmanagedFunctionPointer(CallingConvention.Cdecl)] public delegate ...
C#调用C++ dll
12-14
本主题聚焦于"C#调用C++ dll"，这是一个关键的编程实践，尤其是在Windows平台下利用.NET Framework的C#应用程序与原生C++代码交互。C++编写的动态链接库（DLL）提供了高性能和灵活性，而C#则提供了丰富的框架支持和...
c++ 实现delegate（支持普通函数与成员函数）
HLW0522的博客
07-27 1623
最近开始写了一些c#的东西，有个delegate的东西蛮有意思。 比如如下C#代码 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace CSharpConsole { public...
在 C/C++ 中实现委托（delegate）
liulilittle的博客
02-05 9884
  相信使用过C#语言的人们，对于委托应该是记忆深刻，委托具有很多不错的特性，但最令人感到兴奋的是它可以简化很多复杂的开发同时具有低耦合与对象闭包的特性。    委托在C/C++中可以解决最直观的就有问题，一个是相同代码签名的成员函数与全局函数可以被一个委托调用的问题，在C/C++语言中我们在不借助委托的前提下，代码很难在不增加耦合与依赖的情况调用它们（无论这个依赖是隐式的还是显式的都会存在这个...
(原創) Function Pointer、Delegate和Function Object (C/C++) (template) (.NET) (C#)
weixin_34032779的博客
01-12 107
From：真 OO无双 http://www.cnblogs.com/oomusou/archive/2007/05/02/734290.html AbstractFunction Pointer(C)、Delegate(C#)和Function Object(C++)這三個其實是一樣的功能，所以在此一併討論。Introductionfunction pointer是C語言中最高級的機制，大概很...
c++ delegate用法
最新发布
03-08
C++中的委托（delegate）是一种函数指针的高级形式，它可以将函数作为参数传递给其他函数或存储在数据结构中。委托提供了一种灵活的方式来实现回调机制和事件处理。 在C++中，可以使用函数指针、函数对象和Lambda...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值