函数指针

函数指针：

1）  函数指针的初始化。

函数如下：

1 int CompareString(const string& str1, const string& str2)
2 {
3     return str1.compare(str2);  

4 }

函数的初始化有两种方式：

第一种，也是最普遍的方式：

1 int (*CompareFunction)(const string&, const string&) = CompareString;

第二种，是使用typedef定义函数类型，这种写法有助于对代码的理解：

1 typedef int (*CompareFunctionType)(const string&, const string&);
2 CompareFunctionType CompareFunction = CompareString;

2）  函数指针赋值。

函数名可以理解为该类型函数的指针。当然，取地址操作符作用于函数名上也能产生指向该类型函数的指针。也就是说下面两种赋值都是可行的:

1 CompareFunctionType CompareFunction = CompareString;
2 CompareFunctionType CompareFunction = &CompareString;

3）  函数调用。

无论是用函数名调用，还是用函数指针调用，还是用显式的指针符号调用，其写法是一样的：

1 CompareString("abc", "cba");
2 CompareFunction("abc", "cba");
3 (*CompareFunction)("abc", "cba");

4）  函数指针的数组。

对于函数指针的数组，强烈建议使用typedef方式定义类型之后再使用，不然影响代码的阅读性，继续以以上例子为例：

1 //without typedef
2 int (*CompareFunctionArray[3])(const string&, const string&);
3 //with typedef
4 CompareFunctionType CompareFunctionTypeArray[3];

5）  函数指针用做函数返回值的类型。

到这一步，会发现typedef是多么的好用了。不然我是完全读不懂下面语句的意思的：

1 //without typedef
2 int (*func(int*, int))(const string&, const string&);

上面的声明，将func(int*, int)声明为一个函数，返回值为函数指针，函数类型为int (*)(const string&, const string&)。

多么的晦涩啊！

如果写成typedef就不用这么纠结了，足见typedef的作用：

1 CompareFunctionType func(int*, int);

补充：区分函数指针数组和指向“函数指针数组”的指针

• 函数指针数组

　　我们可以声明一个函数指针的数组，比如：

　　int (*pFuncArray[10])();

　　[]的优先级高于*，该语句将pFuncArray声明为拥有10个元素的数组，每一个元素都是指向一个函数的函数指针，该函数没有参数，返回值类型为int；

　　注意不能写作：int ((*pFuncArray)[10])()，这样会产生编译错误；

　　(*pFuncArray)[10]表明了pFuncArray是一个指针，该指针指向一个’含有 10个元素的数组’；其类型为int()()，显然，编译不能通过。

　　将上面的声明转换为typedef格式，会使程序可读性增加：

　　typedef int(*pFunc)();

　　pFunc pFuncArray[10];

　　如果需要调用其中的第三个函数，那么调用方式为：pFuncArray[2]();

• 指向‘函数指针数组’的指针

　　还可以声明一个指向‘函数指针数组’的指针，比如下面的例子代码：

 
class AClass
{
public:
    void Add(int a){m_iValue += a;}
    int  m_iValue;
};
int _tmain(int argc, _TCHAR* argv[])
{
    AClass a;
   // 声明并指向AClass的一个成员变量的指针
    int AClass::*pValue = &AClass::m_iValue;
    // 或者如下方式：
    // int AClass::*pValue;// 指针变量声明
    // pValue = &AClass::m_iValue;// 指向A的m_iValue成员
    a.*pValue = 4; // 使用方式，赋值
    cout<<a.m_iValue<<endl; // 输出4
    return 0;
}

　　声明分解说明如下：

　　(*ppCmps)：表明ppCmps是一个指针;

　　(*ppCmps)[2]：后面紧跟[2]，表明ppCmps是一个指向‘两个元素数组’的指针

　　PCMP_FUNC表明了该数组元素的类型，它是指向函数的指针，返回值为int，有两个const char*类型的参数；

　　实际上语句PCMP_FUNC (*ppCmps)[2] = &pCmpFuncs;

　　将会被编译器解释为：

　　int (*(*ppCmps)[2])(const char*, const char*) = &pCmpFuncs;

　　声明分解：

　　(*ppCmps)：表明ppCmps是一个指针;

　　(*ppCmps)[2]：后面紧跟[2]，表明ppCmps是一个指向‘两个元素数组’的指针

　　int (*)(const char*, const char *)：表明了该数组元素的类型，它是指向函数的指针，返回值为int，有两个const char*类型的参数；

　　总结：

　　函数指针数组：int (*pFuncArray[10])();

　　指向“函数指针数组”的指针：int (*(*ppCmps)[2])(const char*, const char*);

　　关键在于有没有加括号！！！

参考：　http://www.cnblogs.com/AnnieKim/archive/2011/11/20/2255813.html

　　　　http://blog.csdn.net/sparkliang/article/details/4254115