由浅入深讲解动态类函数指针

1、首先描述一下指针值的含义: 

假设内存值的序列是这样描述的 ： 我们定义一个 0 ~ 50 的正整数序列。

                                                       0，0，0，0，0，0，0，0，0，0，

                                                       0，0，0，0，1，0，0，8，0，0，

                                                       0，0，0，0，0，0，0，0，0，0，

                                                       0，0，0，0，0，0，0，0，0，0，

                                                       0，0，0，0，0，0，0，0，0，0

它第15号数值是 1，第18号数值是8。

由此，我们可以想象 “序号15” 就是指针，指针的值就是 “序号15位置上描述了一个变量1”。

为了方便表示：我们定义变量 x 的位置就在 “序号15”上，y序号的位置就在”序号18”上。

                                                        所以其值相加：x + y = 1 + 8 = 9;

为了刻意记录这些序号位置，我们又创建了一张表专门记录这些序号，它的描述方式假设是这样的：

(为了文章的简洁性：我们将”描述这些变量的值” 用 ”n(x)” 来表式, “&” 表示向上取这些值的序号位置 )

                                          &n0  ,&n1  ,&n2  ,&n3  ,&n4  ,&n5  ,&n6  ,&n7  ,&n8  ,&n9 ,

                                          &n10,&n11,&n12,&n13,&n14,&n15,&n16,&n17,&n18,&n19,

                                          &n20,&n21,&n22,&n23,&n24,&n25,&n26,&n27,&n28,&n29,

                                          &n30,&n31,&n32,&n33,&n34,&n35,&n36,&n37,&n38,&n39,

                                          &n40,&n41,&n42,&n43,&n44,&n45,&n46,&n47,&n48,&n49

“序号15”位置上描述了一个变量1，我们可以理解成，记录 “序号15值”的变量是1，其变量名是”n15”,记录n15的位置是”&n15”(第15号地址)；

因 ”&表示获取序号” ,那么它的反作用 ”*表示取序号下的值”所以:

                                                                                 *(&n15) = n15 = 1;

扩展理解【假设: *n15 = *(&1); (这里是把n15 的值当做一个地址来使用，它表示第1号地址的值)】

2、由于本文章强调的是动态函数指针传递，那么我们进入正题：(关于指针的其他问题可以在评论区提问)

//例子1 运行基本实例 （动态函数指针的传递）
class T_object
{
public:
	T_object(){
	}
	virtual ~T_object(){
	}
	int func(void* p){
		int step = *((int*)p);
		step += 2;
		return step;
	}
};

void main()
{
	T_object t;
	int (T_object::* _pfunc) (void*) = &T_object::func;
	int step = 0;
	for (size_t i = 0; i < 100; i++)
	{
		step = (t.*_pfunc)(&step);
		printf("running T_object::func,%d\n", step);
	}
}

将动态函数指针赋予 _pfunc 作为载体，它需要 t 对象完成实例化执行。

执行方法如下：

step = (t.*_pfunc)(&step); 
step = t.func(&step);

这两个等式表达方式是一样的。

（关于用途举例：可以在主类不采用多态的方式承载多套实现的方法，这里引用敲门砖，希望大家能够举一反三）

//例子2 动态函数指针的应用
class T_object
{
public:
	T_object(){
	}
	virtual ~T_object(){
	}
	int func(void* p){
		int step = *((int*)p);
		step += 2;
		return step;
	}
//new coode begin
	int func1(void* p) {
		int step = *((int*)p);
		step += 3;
		return step;
	}
	int func2(void* p) {
		int step = *((int*)p);
		step += 4;
		return step;
	}
//new coode end
};

void main()
{
	T_object t;
	int (T_object::* _pfunc) (void*) = &T_object::func;
	_pfunc = &T_object::func1;
	_pfunc = &T_object::func2;
	int step = 0;
	for (size_t i = 0; i < 100; i++)
	{
		step = (t.*_pfunc)(&step);
		printf("running T_object::func,%d\n", step);
	}
}

以上调用仅表示它最基本的原始代码展现，方便认知阅读：

（为了提高阅读使用性，下面我们开始优化变型操作）

将函数式包含在内，使调用方更易理解及调用;

//例子3 函数指针作为参数传递
class T_object
{
public:
	T_object(){
		m_pfunc = NULL;
	}
	virtual ~T_object() {
	}
	int func(void* p){
		int step = *((int*)p);
		step += 2;
		return step;
	}
	void addfunc(int(T_object::* pfunc)(void*))
	{
		m_pfunc = pfunc;
	}
	int Do(int step)
	{
		if (m_pfunc != NULL)
		{
			step = (this->*m_pfunc)(&step);
		}
		return step;
	}
	int(T_object::* m_pfunc)(void*);
};

void main()
{
	T_object t;
    //添加函数指针 （对外的方法及调用）
	t.addfunc(&T_object::func);
	int step = 0;
	for (size_t i = 0; i < 100; i++){
		step = t.Do(step);
		printf("running T_object::func,%d\n", step);
	}
}

根据此方法，可以动态的实施类函数的调用。

将函数指针式再简化，函数指针作为命名类型参数传递：

//例子 4 函数指针作为命名类型参数传递
class T_object
{
public:
	//定义函数类
	typedef int(T_object::* PFUNC)(void*);
	T_object() {
		m_pfunc = NULL;
	}
	virtual ~T_object() {
	}
	int func(void* p) {
		int step = *((int*)p);
		step += 2;
		return step;
	}
	void addfunc(PFUNC pfunc)
	{
		m_pfunc = pfunc;
	}
	int Do(int step)
	{
		if (m_pfunc != NULL)
		{
			step = (this->*m_pfunc)(&step);
		}
		return step;
	}
	PFUNC m_pfunc;
};
 
void main()
{
	T_object t;
    //添加函数指针 （对外的方法及调用）
	t.addfunc(&T_object::func);
	int step = 0;
	for (size_t i = 0; i < 100; i++){
		step = t.Do(step);
		printf("running T_object::func,%d\n", step);
	}
}

以上是关于类函数传参的调用方式，可以通过该方法实现很多功能，内容太多本次就不一一举例了。