函数指针做函数参数

1）.函数指针原型：int (*myFuncVar)(int a, int b) ;    //本质是一种变量，专门用做指向函数，变量名为myFuncVar。

　　我们可以这样定义并赋值:

　　int add();

　　int (*myFuncVar)(int a, int b) = add;

　　也可以这样定义并赋值：

　　int add();

　　int (*myFuncVar)(int a, int b)；

　　myFuncVar = add;

 2）作用：函数指针能用来：①当函数用作调用，成为了一般的函数调用    ② 做参数

下面是当函数用作调用：

 //例1
 1 #include<stdio.h>
#include<stdio.h>
int max(int x, int y){ return (x>y ? x : y); }   // 定义带参数max函数 

int main()
{
    int(*ptr)(int, int);        // 定义函数指针变量ptr，参数为两个int型数据
    int a, b, c;
    ptr = max;  //指针变量指向函数首地址
    scanf("%d%d", &a, &b);
    c = (*ptr)(a, b);  //等价于 c = max(a,b); 这样就成了一般的函数调用了
    printf("a=%d, b=%d, max=%d", a, b, c);
    return 0;
}

 

下面是用作函数的参数

 //例2 
 1 #include<stdio.h>
#include<string.h>
#include<stdlib.h>

void A(int a, int b)
{
    printf("我是A,a=%d,b=%d\n", a, b);
}
void B(int a, int b)
{
    printf("我是B,a=%d,b=%d\n", a, b);
}
void C(int a, int b)
{
    printf("我是C,a=%d,b=%d\n",a,b);
}

int myMianOp( void(*myFuncVar)(int a, int b) ) //函数指针当做函数的参数
{
    myFuncVar(1, 2);
    return 0;
}
void main()
{
    myMianOp(A);    //调用者  //A不仅为函数名，也是函数的首地址（也称函数入口点）
    myMianOp(B);    //调用者  //B不仅为函数名，也是函数的首地址（也称函数入口点）
    myMianOp(C);    //调用者  //C不仅为函数名，也是函数的首地址（也称函数入口点）

    system("pause");
}
/***************************************************************************
输出如下：
　　我是A，a=1,b=2
　　我是B，a=1,b=2
　　我是C，a=1,b=2
****************************************************************************/

  

3）C++里，多态是指基类和派生类里有重写函数，而基类里的重写函数前有virtual关键字修饰，当一个函数试图调用这些重写函数时，它会根据被送进来的参数对象来执行对应的重写函数，如果参数是基类的对象就会运行基类里的重写函数，如果参数是派生类的对象就会运行派生类的重写函数。简而言之，一个函数根据参数对象会有不同的运行形态。如果没有virtual关键字修饰，则只会执行基类里的重写函数。

重写函数：必须在继承里，基类和派生类有类型名、函数名、参数均一模一样的成员函数，此类成员函数称重写函数。

虚函数：重写函数里，如果在基类的重写函数前头用virtual关键字修饰，则称这些函数名一样的成员函数为虚函数。

因此，多态成立的三个条件为：要有继承，虚函数重写，一个带参数且要试图调用重写函数的函数。

 

 //例3 C++多态的实现
 1 #include <iostream>
using namespace std;

 5 

class Parent
{
public:
    Parent(int a=0)
    {
        this->a = a;
    }

    virtual void print_one()  //1 动手脚  写virtal关键字 会特殊处理 //虚函数表
    {
        cout<<"我是爹"<<endl;
    }
    virtual void print_tow()  //1 动手脚  写virtal关键字 会特殊处理 //虚函数表
    {
        cout<<"我是爹"<<endl;
    }
private:
    int a;
};

class Child : public Parent
{
public:
    Child(int a = 0, int b=0):Parent(a)
    {
        this->b = b;
    }

    virtual void print_one()
    {
        cout<<"我是儿子"<<endl;
    }
private:
    int b;
};

void HowToPlay(Parent *base)
{
    base->print_one(); //有多态发生  //2 动手脚  
    //效果:传来子类对 执行子类的print_one函数 传来父类对执行父类的print_one函数 
    //C++编译器根本不需要区分是子类对象 还是父类对象
    //父类对象和子类对象分步有vptr指针 , ==>虚函数表===>函数的入口地址
    //迟绑定 (运行时的时候,c++编译器才去判断)
}

void main01()
{

    Parent    p1; //3 动手脚 提前布局  
                //用类定义对象的时候 C++编译器会在对象中添加一个vptr指针 
    Child    c1; //子类里面也有一个vptr指针

    HowToPlay(&p1);
    HowToPlay(&c1);

    cout<<"hello..."<<endl;
    system("pause");
    return ;
}