函數指針分為一般的函數指針和成員函數指針
類的非靜態函數中有一個隱形的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、靜態成員函數可以代替普通函數被調用函數指針（非成員函數指針）的函數調用。但是靜態成員函數有一個好處，就是可以被類私有保護起來——當然，最好是有其他公共成員將其作用對外連接起來的時候。