1.普通函数

体现：一个函数作为另外一个函数的参数，进行函数传递，当然可以通过这种形式进行函数重载。

方式1：函数类型

将函数作为基本类型，形如int a，int 是类型，a是形参；int f(int, int )，int (int ，int)是类型，f是形参；
缺点：该种类型的写法太繁琐

#include<iostream>
using namespace std;

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

int F(int f(int,int),int a,int b){
    return f(a,b);
}

int main(){
    cout<<F(add,1,2)<<endl;//3
}

方式2：函数指针

用typedefine重新定义一种指针，该指针指向类型为int (int ,int)的函数。形参为p
注意，函数指针 = 函数名，所以，执行函数的时候，不用解指针！！！

#include<iostream>
using namespace std;

typedef int (*pf)(int,int); //

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

int F(pf p,int a,int b){//
    return p(a,b);//
}

int main(){
    cout<<F(add,1,2)<<endl;//3
}

方式3：定义新类型

用typedefine重新定义一种新类型

#include<iostream>
using namespace std;

typedef int FuncType(int,int); //定义了FuncType这种函数数据类型

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

int F(FuncType tf,int a,int b) {//
    return tf(a,b);//
}

int main(){
    cout<<F(add,1,2)<<endl;//3
}

应用实例

这里运用函数传递实现函数的重载

#include<iostream>
using namespace std;


//三种比较方式
int CmpAsc(int x, int y)  
{  
    //如果x>y返回1，否则返回0；  
    if(x>y)return 1;  
    else return 0;  
}  

int CmpDec(int x, int y)  
{  
    //如果x<y返回1，否则返回0；  
    if(x<y)return 1;  
    else return 0;  
}  

int CmpAbsAsc(int x, int y)  
{
    //如果abs(x)>abs(y)返回1，否则返回0  
    if(abs(x)>abs(y))return 1;  
    else return 0;  
}  

//排序
void sort(int a[], int n, int (*cmp)(int,int))  
{   
    /*对数组a排序，排序原则由cmp指定，若cmp为真，表示两元素逆序*/  
    for(int i=0;i<n-1;i++)  
        for(int j=i+1;j<n;j++)  
            if(cmp(a[i],a[j]))  
                swap(a[i],a[j]);  
}  


int main(void)  
{  
    int a[10],i,n;   
    int slt;  
    /*读入n和n个整数，存入数组a*/  
    cin>>n;  
    for(int i=0;i<n;i++)  
        cin>>a[i];  
    /*读入用户的选择，存入slt; */  

    cin>>slt;  
    switch(slt)  
    {  
    case 1:   sort(a, n, CmpAsc); break;  
    case 2:   sort(a, n, CmpDec); break;  
    case 3:   sort(a, n, CmpAbsAsc);break;  
    }  
    /*输出排序后的数组*/  
    for(int i=0;i<n;i++)  
    {  
        if(i==0)  
            cout<<a[i];  
        else  
            cout<<" "<<a[i];  
    }  
    cout<<endl;  
    return 0;  
}

2. 类成员函数

传递普通函数和类的成员函数方式不同：
普通函数传的就是函数的实际地址；
成员函数在类的内部中没有地址，只能传递在类中的偏移量；
当然，可以将成员函数设置为静态函数（static）来当作普通函数来看待。

#include<iostream>;
using namespace std;
class ABC {
    public:
        void f1(int n, int b);
        void f2(int n);
};

void ABC::f1(int n, int b) {
    cout << n << "," << b << endl;
}

void ABC::f2(int n) {
    cout << "member function:" << n << endl;
}

void f(int n) {
     cout << "normal function: " << n << endl;
}

// member function
template <class T>
void cb(T *obj, void (T::*callback)(int), int n) {
     (obj->*callback)(n);
}
int main(void) {
    ABC *abc = new ABC();
    abc->f1(1, 2);
    abc->f2(3);

    // invoke normal function
    cb(f, 5);

    system("pause");
    return 0;
}