先看看这段代码：

#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;     

[1] [2] 下一页