函数指针碰到点问题。请大家指点下具体的解决方案。

zhengfaqi

1. //这个是头文件.h
   
2. #pragma once
   
3. #include <iostream>
   
4. using namespace std;
   
5. #include <ctime>
   
6. 
   
7. class C12_08_16
   
8. {
   
9. public:
   
10.         C12_08_16(void);
    
11.         ~C12_08_16(void);
    
12.         int work(void);
    
13. 
    
14. private:       
    
15.         int test(void);
    
16.         int test1(void);
    
17.         int plus(int,int);
    
18.         double plus(double,double);
    
19.         int sum(int a,int b);
    
20. };
    
21. 
    
22. //这个是cpp文件
    
23. int C12_08_16::test1()
    
24. {       
    
25.         int (*pSum)(int,int);
    
26.         pSum = sum;                         //出错
    
27.         pSum(0,50);
    
28.         return 0;
    
29. }
    
30. 
    
31. int C12_08_16::sum(int a,int b)
    
32. {
    
33.         int sn = 0;
    
34.         for(int i = a; i <= b; i++)
    
35.                 sn += i;
    
36.         return sn;
    
37. }

复制代码

我是想把一个函数指针指向一个类成员函数。现在在赋值指向的操作中，出现错误。请个问指教下，具体的如何解决。
我现在只知道一个错误的地方，就是必须把需要被函数指针指向的函数要定义成静态函数static，但是我另外想请教点知识的问题，static本身不是将变量或者函数定义为全局性的吗？同时他有个特性就是用static所定义的变量和函数不能被其他类所调用和使用。那么，对于类中的成员函数而言，是否用static来定义有什么意义吗？类成员函数本身就是一个类中的全局函数。是否指定static貌似没什么区别。如果用static指定函数sum后，后面的具体操作是否和正常的使用函数指针一样？直接拿pSum调用就行了呢？
请个问指点下，菜鸟求指点！～

夜行的猫仔

这个问题的关键是函数指针指向了一个类成员函数。
函数指针是通过指向函数的指针间接调用函数。函数指针指向普通函数是没有问题的。函数指针可以实现对参数类型、参数顺序、返回值都相同的函数进行封装，是多态的一种实现方式。
由于类的一般成员函数中有一个隐形的this指针，因此，类的成员函数的指针和一般函数的指针的表现形式不一样。要消除this指针的影响，可以将类成员函数声明成静态成员函数。

夜行的猫仔

但是实际上，通过程序也是可以通过函数指针的方式访问普通类成员函数。
如下面这个例子：

1. #include "stdafx.h"
   
2. #include <iostream>
   
3. using namespace std;
   
4. 
   
5. class A
   
6. {
   
7. private:
   
8.         int a;
   
9. public:
   
10.         A(int _a): a(_a)
    
11.         {}
    
12.         void fun1() const
    
13.         {
    
14.                 std::cout << "this is fun1, a = " << a << std::endl;
    
15.         }
    
16.         int fun2() const
    
17.         {
    
18.                 std::cout << "this is fun2, a = " << a << std::endl;
    
19.                 return 0;
    
20.         }
    
21.         static void fun3(const A& _a)
    
22.         {
    
23.                 std::cout << "this is  fun3, ";
    
24.                 _a.fun1();
    
25.         }
    
26.         friend void fun4(const A& _a)
    
27.         {
    
28.                 std::cout << "this is fun4, a = " << _a.a << std::endl;
    
29.         }
    
30. };
    
31. 
    
32. typedef void (A::*pcf)()const;
    
33. 
    
34. void call_A(pcf pF, const A& _a)
    
35. {
    
36.         (_a.*pF)();
    
37. }
    
38. 
    
39. int _tmain(int argc, _TCHAR* argv[])
    
40. {
    
41.         A a(10);
    
42. 
    
43.         call_A(&A::fun1, a);
    
44. 
    
45.         return 0;
    
46. }

复制代码

在这个例子中，fun1是类A的成员函数，我们通过typedef void (A::*pcf)()const; 定义了一个pcf函数指针指向了A::fun1()就可以直接调用。