函数指针分为一般的函数指针和成员函数指针
类的非静态函数中有一个隐形的this指针，类的成员函数指针和一般的函数指针不一样

1、指向一般函数的指针
函数指针的声明中就包括了函数的参数类型、顺序和返回值，只能把相匹配的函数地址赋值给函数指针。为了封装同类型的函数，可以把函数指针作为通用接口函数的参数，并通过函数指针来间接调用所封装的函数。
下面是一个指向函数的指针使用的例子

#include <iostream.h>

/**//*指向函数的指针*/
typedef int (*pFun)(int, int);

int Max(int a, int b)
{
    return a > b ? a : b;
}

int Min(int a, int b)
{
    return a < b ? a : b;
}

/**//*通用接口函数，实现对其他函数的封装*/
int Result(pFun fun, int a, int b)
{
    return (*fun)(a, b);
}

void main()
{
    int a = 3;
    int b = 4;

    cout<<"Test function pointer: "<<endl;
    cout<<"The maximum number between a and b is "<<Result(Max, a, b)<<endl;
    cout<<"The minimum number between a and b is "<<Result(Min, a, b)<<endl;
}

2、指向类的成员函数的指针

类的静态成员函数采用与一般函数指针相同的调用方式。而受this指针的影响，类的非静态成员函数与一般函数指针是不兼容的。而且，不同类的this指针是不一样的，因此，指向不同类的非静态成员函数的指针也是不兼容的。指向类的非静态成员函数的指针，在声明时就需要添加类名。

下面是一个指向类的成员函数的指针的使用的例子，包括指向静态和非静态成员函数的指针的使用。

#include <iostream.h>
   
    class CA;
   
    /*指向类的非静态成员函数的指针*/
    typedef int (CA::*pClassFun)(int, int);
   
    /*指向一般函数的指针*/
    typedef int (*pGeneralFun)(int, int);
   
    class CA
    {
    public:
   
        int Max(int a, int b)
        {
            return a > b ? a : b;
        }
       
        int Min(int a, int b)
        {
            return a < b ? a : b;
        }
   
        static int Sum(int a, int b)
        {
            return a + b;
        }
   
        /*类内部的接口函数，实现对类的非静态成员函数的封装*/
        int Result(pClassFun fun, int a, int b)
        {
            return (this->*fun)(a, b);
        }
   
    };
   
    /*类外部的接口函数，实现对类的非静态成员函数的封装*/
    int Result(CA* pA, pClassFun fun, int a, int b)
    {
        return (pA->*fun)(a, b);
    }
   
    /*类外部的接口函数，实现对类的静态成员函数的封装*/
    int GeneralResult(pGeneralFun fun, int a, int b)
    {
        return (*fun)(a, b);
    }
   
   
    void main()
    {
        CA ca;
        int a = 3;
        int b = 4;
       
        cout<<"Test nonstatic member function pointer from member function:"<<endl;
        cout<<"The maximum number between a and b is "<<ca.Result(&CA::Max, a, b)<<endl;
        cout<<"The minimum number between a and b is "<<ca.Result(&CA::Min, a, b)<<endl;
   
        cout<<endl;
        cout<<"Test nonstatic member function pointer from external function:"<<endl;
        cout<<"The maximum number between a and b is "<<Result(&ca, &CA::Max, a, b)<<endl;
        cout<<"The minimum number between a and b is "<<Result(&ca, &CA::Min, a, b)<<endl;
   
        cout<<endl;
        cout<<"Test static member function pointer: "<<endl;
        cout<<"The sum of a and b is "<<GeneralResult(CA::Sum, a, b)<<endl;
    }

在后来的编译器中 成员函数指针的传入需要写成&CA::Max, 如果直接写成 CA::Max是参数错误的

3.游戏的设计离不开多线程，在C++新标准出来之前，多线程的设计还是多以依赖特定系统的函数库或者某些特定的函数库为主，如同SDL，打开多线程的函数也主要是C函数。我们当然很期待boost中真正意义上的C++多线程类的加入，不过仍然需要等待。问题就出在打开多线程的C函数上，因为他们通常调用的是函数指针，但是在C++中，我们通常把函数绑定到了与其数据相关的类中，也就是说，我们在C++中很少用到“单身”的函数，成员函数可以被那些调用函数指针的启动多线程的函数调用吗？
        答案是：通常不行，但是静态成员函数例外。
        在C++中，函数指针与成员函数指针完全是两个概念，并且相互之间在任何情况下，无法转换！
        我们来看这么一个类

#include <iostream>

class A
{
private:
    int a;
public:
    A(int _a): a(_a)
    {}
    void f1() const
    {
        std::cout << "call f1, a = " << a << std::endl;
    }
    int f2() const
    {
        std::cout << "call f2, a = " << a << std::endl;
        return 0;
    }
    static void f3(const A& _a)
    {
        std::cout << "call f3, ";
        _a.f1();
    }
    friend void f4(const A& _a)
    {
        std::cout << "call f4, a = " << _a.a << std::endl;
    }
};

其中函数A::f1()和A::f2()是毫无疑问的成员函数；A::f3()也是成员函数，但是他是静态成员函数；f4()是A类的友元函数，他实际上就是一个普通的函数。
A::f1()的指针我们需要这样定义：

typedef void (A::*pcf)()const;

作为参数的时候必须这样写“&A::f1”。
A::f2()的指针我们这样定义：

typedef int (A::*ptf)()const;

尽管A::f2()与A::f1()的返回类型不同，但是他们的形参列表是一样的，所以，指针可以通过强制转换进行转换。 强制转换建立在参数一致的基础上
如果他们的形参列表不一致，则强制转换在编译期间没有问题，但是运行时会抛出异常。
这是因为形参列表不一样意味着强制转换后，某些函数无法得到某些必须的参数。所以，这种转换应该是需要避免的。

A::f3()和f4()尽管一个是静态成员函数，一个是普通函数，但是他们的指针定义却是一样的：

typedef void (*pf)(const A&);

这也就是为什么调用函数指针的函数可以直接调用静态成员函数指针的原因。
作为参数的时候，他们既可以加上“&”来写：“&A::f3”, “&f4”；
也可以不用“&”：“A::f3”, “f4”。
这是在A类定义域外的情况。在A定义域内，比如在写A的成员函数的时候，静态成员函数甚至可以不需要加上A的定义域符号“A::”，直接可以使用“&f3”或者“f3”。
 
我们把剩下的程序补充完整：

void call_A(pcf pF, const A& _a)
{
    (_a.*pF)();
}

void call_A(pf pF, const A& _a)
{
    (*pF)(_a);
}

int main(int argc, char* argv[])
{
    A a(10);
    
    //  正确调用成员函数指针，传入&A::f1,并传入调用的对象
    call_A(&A::f1, a);

    ptf __f2 = &A::f2;

    // 强制转换函数指针
    pcf _f2 = (pcf)(__f2);
    call_A(_f2, a);

    //静态函数调用
    call_A(A::f3, a);

    call_A(f4, a);

    return 0;
}

可以看到的情况是：
1、成员函数的指针与对象是不绑定的。也就是说，尽管我也很希望如果a是A的对象，a.f1()的指针要是能表示成a.f1（或者“&(a.f1)”）多好？但是这是不允许的，至少现在是不允许的。我们要调用A::f1()方法，还得指定其对象，所以，这实际上与调用静态成员函数与普通函数是一样的。

2、静态成员函数可以代替普通函数被调用函数指针（非成员函数指针）的函数调用。但是静态成员函数有一个好处，就是可以被类私有保护起来——当然，最好是有其他公共成员将其作用对外连接起来的时候。