函数指针调用类成员函数的解决方案

    如果碰到在一个类中通过函数指针调用成员函数的要求。比如：在一个类中使用了 STL的排序函数qsort时，因qsort参数需要一个比较函数指针，如果这个类使用某个成员函数做比较函数，就需要将这个成员函数的指针，也就是成员函数名，传给qsort供其调用。

    如以下三种情况就会出现编译错误：

    1 将类的成员函数指针赋予同类型非成员函数指针

#include<stdlib.h>
#include<iostream>
typedef void (*Function1)();//定义一个函数指针类型
Function1 f1;
class Test1
{
public:
 void Memberfun1()
 {
  std::cout<<"Calling Test3::Memberfun2 OK"<<'/n';
 }
 void Memberfun2()
 {
  f1=reinterpret_cast<Function1>(Memberfun1);//将成员函数指针赋予f1, 编译错误
  f1();
 }
};
int main()
{
 Test1 t1;
 t1.Memberfun2();
 return 0;
} 

    2 在一个类中，有标准库函数，如 qsort或其他全局函数，用函数指针调用类的成员函数

#include<stdlib.h>
#include<iostream>
class Test2
{
private:
 int data[2];
public:
 int _cdecl Compare(const void* elem1,const void* elem2)
 {
  std::cout<<"Calling Test2::Memberfun OK"<<'/n';//如改为static函数可以成功
 }
 void Memberfun()
 {
  data[0]=2;
  data[1]=5;
  //标准库函数调用成员函数，编译出错
  qsort(data,2,sizeof(int),Compare);
 }
};
int main()
{
 Test2 t2;
 t2.Memberfun();
 return 0;
}

   3 同一个类中，一个成员函数调用另一个成员函数

#include <stdio.h>
#include <iostream>
class Test3
{
public:
 void Memberfun1(void (*f2)())
 {
  f2();
 }
 void Memberfun2()
 {
  std::cout<<"Calling Test3::Memberfun2 OK"<<'/n';   / /如改为static函数可以成功
 }
 void Memberfun3()
 {
  Memberfun1(Memberfun2);//出错
 }
};
int main()
{
 Test3 t3;
 t3.Memberfun3();
 return 0;
}

    以上都会编译错误，但是如果将类的外衣脱掉，如下代码所示，编译正确且运行正常。

#include <stdio.h>
#include <iostream>

 void Memberfun1(void (*f2)())
 {
  f2();
 }
 void Memberfun2()
 {
  std::cout<<"Calling Test3::Memberfun2 OK"<<'/n';  / /如改为static函数可以成功

 }
 void Memberfun3()
 {
  Memberfun1(Memberfun2);//出错
 }

int main()
{
 //Test3 t3;
 /*t3.*/Memberfun3();
 return 0;
}

    原因其实很难表述，简单说就是因为类的成员函数里面并不那么纯洁，它附带了很多其他信息，如：每个成员函数都拥有this指针等等。

    那么如何解决这个问题，实现指针调用类的成员函数 也就是说将函数名作为另一个函数的参数？

    1 在每个被调用函数之前加上static, 可以使成员函数脱离对象信息单独存在，虽然它属于这个类，但是没有附带上对象信息，但是前提是，static成员函数不能使用对象的信息（成员和函数）。

    2 使用一个全局函数做中转，间接调用成员函数，如下代码修改Test3：

#include <stdio.h>
#include <iostream>
class Test3;
void _cdecl Helper(Test3 *test3);
class Test3
{
public:

void Memberfun1(void (*f2)(Test3 *))
 {
  f2(this);
 }
 void  Memberfun2()
 {
  std::cout<<"Calling Test3::Memberfun2 OK"<<'/n';
 }
 void Memberfun3()
 {
  //Memberfun1(Memberfun2);//出错
  Memberfun1(Helper);
 }
};
void _cdecl Helper(Test3 *test3)
{
 test3->Memberfun2();
}
int main()
{
 Test3 t3;
 t3.Memberfun2();
 return 0;
}

3 使用一个函数参数函数对象信息的static类型的成员函数中转，间接调用其它成员函数。

#include <stdio.h>
#include <iostream>
class Test3
{
public:
 static void _cdecl Helper(Test3 *test3)
 {
  test3->Memberfun2();
 }

 void Memberfun1(void (*f2)(Test3 *))
 {
  f2(this);
 }
 void  Memberfun2()
 {
  std::cout<<"Calling Test3::Memberfun2 OK"<<'/n';
 }
 void Memberfun3()
 {
  Memberfun1(Helper);
 }
};

int main()
{
 Test3 t3;
 t3.Memberfun2();
 return 0;
}

    由此可见，函数指针不能直接调用类的成员函数，因为成员函数指针和一般函数指针有着本质差别，因为成员函数带有很多对象信息。要解决调用的问题，应该使用static或者全局函数，实现间接调用。