指针的学习（好文收集）

C++ 的函数指针

先看看这段代码：

#include <iostream>

using std::cout;

using std::endl; 

inline int min(int a,int b)

{

        return (a>b) ? b : a;

} 

int Min(int a,int b,int (*pf)(int,int))  

//可以使用缺省参数：int Min(int a,int b,int (*pf)(int,int)=min)

{

        return pf(a,b);                   //通过函数指针来调用函数，也可以写为

                           //return (*pf)(a,b);作用是一样的。

} 

int main(int argc, char* argv[])

{

        int i=1;

        int j=10;

        int r=Min(i,j,min);               //如果使用缺省参数的话，可以写成：int r=Min(i,j);

        cout<<r<<endl;       

        return 0;

}

其中int (*pf)(int,int)定义了一个返回值为int,参数为两个int的函数指针。如果不在*pf上加括号的话，即：

int *pf(int,int)，

编译器会把它解释为一个返回值为整型指针，参数为两个int的函数。

可以用typedef来简化代码：

#include <iostream>

using std::cout;

using std::endl;

typedef int (*PF)(int,int); 

//这行代码是关键，相当与把上个例子中的函数指针声明为一种数据类型。 

inline int min(int a,int b)

{

        return (a>b) ? b : a;

}

int Min(int a,int b,PF f)            //PF f定义f为和上个例子中一样的函数指针。

{

        return f(a,b);

}

int main(int argc, char* argv[])

{

        int i=1;

        int j=10;

        int r=Min(i,j,min);

        cout<<r<<endl;    

        return 0;

}

也可以提供一个用模板实现的函数指针:

#include <iostream>

using std::cout;

using std::endl;

inline int min(int a,int b)

{

        return (a>b) ? b : a;

}

template <typename T>

T Min(T a,T b,T (*pf)(T,T))

{

        return pf(a,b);

}

int main(int argc, char* argv[])

{

        int i=1;

        int j=10;   

        int r=Min<int>(i,j,min);  

 //int r=Min(i,j,min<int>); 这种形式编译器会报错：Expression syntax

        cout<<r<<endl;   

        return 0;

} 

当然，这个指针指向的函数也可用模板来实现:

#include <iostream>

using std::cout;

using std::endl; 

template <typename T>

inline T min(T a,T b)

{

        return (a>b) ? b : a;

}

template <typename T>

T Min(T a,T b,T (*pf)(T,T))

{

        return pf(a,b);

}

int main(int argc, char* argv[])

{

        long i=2000000;

        long j=1000000;

        //使用时有三种形式：

        long r=Min(i,j,min<long>); 

        //第一种。注意这里在min后一定要加<long>，否则编译器将报错：

        //Could not find a match for "Min<T>(long,long,T(*)(T,T)"

        //第二种：long r=Min<long>(i,j,min);

       //第三种：long r=Min<long>(i,j,min<long>);

       //其实质是一样的。                               

        cout<<r<<endl;

        return 0;

}

不过我不能用typedef使代码更为简便，就像下面这种形式：

template <typename T>

typedef T (*PF)(T,T);

编译器会提示：Templates must be classes or functions

另外还可以使用函数指针的数组：

#include <iostream>

using std::cout;

using std::endl;

inline int min(int a,int b)

{

        return (a>b) ? b : a;

}

inline int max(int a,int b)

{

        return (a>b) ? a : b;

}

int main(int argc, char* argv[])

{

        int i=1;

        int j=10;

         int (*pf[2])(int,int);         

//拥有两个元素的函数指针数组，每个元素是返回值为int,参数为两个int的函数指针。

        pf[0]=min;

        pf[1]=max; 

        int r1=pf[0](i,j);

        int r2=pf[1](i,j);

        cout<<r1<<endl;

        cout<<r2<<endl;     

        return 0;

} 

指向重载函数的指针也是值得注意的：
#include <iostream>
using std::cout;
using std::endl;

inline void print(int a)
{
        cout<<a<<endl;
}
inline void print(long b)
{
        cout<<b<<endl;
}

int main(int argc, char* argv[])
{
        int i=1;
        long m=100000;

        void (*pf1)(int)=print;
        void (*pf2)(long)=print;

        pf1(i);
        pf2(m);

        return 0;
}
程序运行的很成功。因为编译器会自动查找所有的重载函数，以找到和函数指针指向的函数具有相同的返回类型和参数表的函数。

如上我们可知声明一个给定函数的函数指针的一般规则：即这个函数指针的返回类型和参数表必须和给定的函数相同。要注意省略号也是函数类型的一部分，int function1(int,...)与int function2(int)需要两个不同的函数指针。其实函数名就是指向该函数的指针，对于int function(int)来说，function就是它的指针。我们可用这个特性对函数指针进行初始化：

int (*pf)(int)=function;

取地址操作符也可以用在函数名上，上面的代码和int (*pf)(int)=&function的作用是一样的。

(所有代码在C++Builder6下调试通过)

理解这种东西，只要你能理解C++最简单的声明表达式就OK了。
下面是int类型的声明表达式。
int integer;//声明一个int型变量，变量名为integer.
再声明表达式的前面加上typedef，则原来的变量名就变成了类型名的别名。
typedef int integer
下面看函数指针变量的声明：
int (*CallbackFunctionPtr)(int parameter);
上式的函数指针的变量名是CallbackFunctionPtr,因此
typedef int (*CallbackFunctionPtr)(int parameter);
CallbackFunctionPtr变成了函数指针 int(*)(int)的别名。

http://jpk.shcemt.edu.cn/cplus/kejian/content/chapter4/chapter4_5_9.htm

函数指针

一个函数在编译时被分配一个入口地址(第一条指令的地址),可以将地址赋给一个指针,这样,指针变量持有函数入口地址,它就指向了该函数,所以称这种指针为指向函数的指针,简称函数指针。

函数指针定义的一般形式：

         数据类型 （*指针变量名）（形参类型）；

在说明函数指针时，同时也要描述这个指针所指向的函数的参数类型和个数，以及函数的返回值类型。例如：

         int (* funp)(int a,int b);

该语句说明了一个函数指针变量funp。注意：在这个说明中，包围*号和函数指针名funp的圆括号是必须的，这funp被解释为：funp是一个指针，它指向带有两个int类型参数的函数，函数返回值类型为int。

函数指针的性质与数据指针相同，惟一的区别是数据指针指向的是内存的数据存储区，而函数指针指向的是内存的程序代码存储区（因为函数本身就是一段程序代码）。由于这一区别，使得他们访问目标*运算的意义是不同的。数据指针访问的是内存中的数据，而函数指针访问目标*运算时，其结果是使程序控制转移至该函数指针所指向的函数的入口地址，从而开始执行该函数。因此，当把函数的地址赋给一个指针变量时，对该指针变量的操作就等同于调用该函数。例如：

         result=(I funp)(5,10);

就等同于：

         result=fun(5,10);

这两条语句都是调用函数fun,并将5和10人微言轻料参传递给该函数。

下面是一个使用函数指针的例子，它简单地演示了通过指针变量调用函数的情况。

#include<iostream.h>
void main()
{
 int func(int a,int b); 
  int (* pf)(int a,int b);  //定义一个函数指针变量pf
  pf=func;   //将函数func的入口地址赋给了函数指针pf,从而使函数指针指向了该函数
 cout<<"please enter two integers :"<<endl;
 int m,n;
 cin>>m>>n;
 int result=(* pf)(m,n);   //等价执行result=func(5,10)
 cout<<"result is "<<result<<endl;

}
int func(int a,int b)
{
 return a+b;
}

函数存放在内存的代码区域内，它们同样有地址，我们如何能获得函数的地址呢？

　　如果我们有一个int test(int a)的函数，那么，它的地址就是函数的名字，这一点如同数组一样，数组的名字就是数组的起始地址。

　定义一个指向函数的指针用如下的形式，以上面的test()为例：

int (*fp)(int a);//这里就定义了一个指向函数的指针

　　函数指针不能绝对不能指向不同类型，或者是带不同形参的函数，在定义函数指针的时候我们很容易犯如下的错误。

int *fp(int a);//这里是错误的，因为按照结合性和优先级来看就是先和()结合，然后变成了一个返回整形指针的函数了，而不是函数指针，这一点尤其需要注意！

　　下面我们来看一个具体的例子：

#include <iostream> 
#include <string> 
using namespace std; 
 
int test(int a); 
 
void main(int argc,char* argv[])   
{ 
    cout<<test<<endl;//显示函数地址 
    int (*fp)(int a); 
    fp=test;//将函数test的地址赋给函数学指针fp 
    cout<<fp(5)<<"|"<<(*fp)(10)<<endl; 
//上面的输出fp(5),这是标准c++的写法,(*fp)(10)这是兼容c语言的标准写法,两种同意,但注意区分,避免写的程序产生移植性问题! 
    cin.get(); 
} 
 
int test(int a) 
{ 
    return a; 
}

　　typedef定义可以简化函数指针的定义，在定义一个的时候感觉不出来，但定义多了就知道方便了，上面的代码改写成如下的形式：

#include <iostream> 
#include <string> 
using namespace std; 
 
int test(int a); 
 
void main(int argc,char* argv[])   
{ 
    cout<<test<<endl; 
    typedef int (*fp)(int a);//注意,这里不是生命函数指针,而是定义一个函数指针的类型,这个类型是自己定义的,类型名为fp 
    fp fpi;//这里利用自己定义的类型名fp定义了一个fpi的函数指针! 
    fpi=test; 
    cout<<fpi(5)<<"|"<<(*fpi)(10)<<endl; 
    cin.get(); 
} 
 
int test(int a) 
{ 
    return a; 
}

函数指针同样是可以作为参数传递给函数的，下面我们看个例子，仔细阅读你将会发现它的用处，稍加推理可以很方便我们进行一些复杂的编程工作。

//-------------------该例以上一个例子作为基础稍加了修改----------------------------- 
#include <iostream>   
#include <string>   
using namespace std;   
   
int test(int);   
 
int test2(int (*ra)(int),int); 
 
void main(int argc,char* argv[])     
{   
    cout<<test<<endl; 
    typedef int (*fp)(int);   
    fp fpi; 
    fpi=test;//fpi赋予test 函数的内存地址 
 
    cout<<test2(fpi,1)<<endl;//这里调用test2函数的时候,这里把fpi所存储的函数地址(test的函数地址)传递了给test2的第一个形参 
    cin.get(); 
}   
   
int test(int a) 
{   
    return a-1; 
} 
 
int test2(int (*ra)(int),int b)//这里定义了一个名字为ra的函数指针 
{ 
    int c=ra(10)+b;//在调用之后,ra已经指向fpi所指向的函数地址即test函数 
    return c; 
}

　　利用函数指针，我们可以构成指针数组，更明确点的说法是构成指向函数的指针数组，这么说可能就容易理解的多了。

#include <iostream>   
#include <string>   
using namespace std; 
 
void t1(){cout<<"test1";} 
void t2(){cout<<"test2";} 
void t3(){cout<<"test3";} 
void main(int argc,char* argv[])     
{ 
    void* a[]={t1,t2,t3}; 
    cout<<"比较t1()的内存地址和数组a[0]所存储的地址是否一致"<<t1<<"|"<<a[0]<<endl; 
 
    cout<<a[0]();//错误!指针数组是不能利用数组下标操作调用函数的 
 
    typedef void (*fp)();//自定义一个函数指针类型 
    fp b[]={t1,t2,t3}; //利用自定义类型fp把b[]定义趁一个指向函数的指针数组 
    b[0]();//现在利用指向函数的指针数组进行下标操作就可以进行函数的间接调用了; 
    cin.get(); 
}

　　仔细看上面的例子可能不用我多说大家也会知道是怎么一会事情了,最后我们做一个重点小结,只要记住这一点,对于理解利用函数指针构成数组进行函数间接调用就很容易了!

void* a[]={t1,t2,t3};
cout<<"比较t1()的内存地址和数组a[0]所存储的地址是否一致"<<t1<<"|"<<a[0]<<endl;

cout<<a[0]();//错误!指针数组是不能利用数组下标操作调用函数的

　　上面的这一小段中的错误行，为什么不能这么调用呢？

　　前一篇教程我们已经说的很清楚了，不过在这里我们还是复习一下概念，指针数组元素所保存的只是一个内存地址，既然只是个内存地址就不可能进行a[0]()这样地址带括号的操作，而函数指针不同它是一个例外，函数指针只所以这么叫它就是因为它是指向函数指向内存的代码区的指针，它被系统授予允许与()括号操作的权利，进行间接的函数调用，既然函数指针允许这么操作，那么被定义成函数指针的数组就一定是可以一样的操作的。