函数多态

父类对象指向的是父类就调用父类的函数

子类对象指向的是子类就调用子类的函数

多态：同样的语句再运行时有多种不同的表现形式（根据对象的实际类型来调用相应的函数)

多态的体现：虚函数的重载

多态关键字：virtual.

　　1. 被virtual声明的函数被重写后具有多态性。

扫描二维码关注公众号，回复： 6201202 查看本文章

　　2. 被virtual声明的函数叫虚函数。

　 3. 对可能要在继承时被重写的函数声明virtual 关键字。

#include <iostream>
#include <string>

using namespace std;

class Parent
{
public:
    virtual void print()   // 定义为虚函数
    {
        cout << "I'm Parent." << endl;
    }
};

class Child : public Parent
{
public:
    void print()      // 通过继承的到多态属性（虚函数）等价于 --> virtual void print()
    {
        cout << "I'm Child." << endl;
    }
};

void how_to_print(Parent* p)
{
    p->print();     // 展现多态的行为（根据p指向的对象调用相应的函数）
}

int main()
{
    Parent p;
    Child c;
    
    how_to_print(&p);    //  I'm Parent.
    how_to_print(&c);    //  I'm Child.
    
    return 0;
}

多态的意义：

　　1. 多态是动态的意义，编译时无法预知实际调用，再运行时才展现具体的调用。

　　2. 重写函数必须用多态来实现。

静态联编：在程序的编译器就决定具体的函数调用。函数重载

动态联编：在程序的执行期才决定具体的函数调用。虚拟函数的重写

#include <iostream>
#include <string>

using namespace std;

class Parent
{
public:
    virtual void func()   // 虚函数
    {}   
    virtual void func(int i)
    {}   
    virtual void func(int i, int j)
    {}
};

class Child : public Parent
{
public:
    void func(int i, int j)  // 通过继承也变成虚函数
    {}  
    void func(int i, int j, int k)  // 通过继承也变成虚函数
    {}
;

void run(Parent* p)
{
    p->func(1, 1);     // 展现多态的特性
                       // 动态联编
}


int main()
{
    Parent p;    
    p.func();         // 静态联编
    p.func(1);        // 静态联编
    p.func(1, 1);     // 静态联编
   
    Child c;    
    c.func(1, 1);     // 静态联编
    
    run(&p);          // 动态联编 打印父类函数
    run(&c);          // 动态联编 打印子类函数    
    return 0;
}

函数覆盖：通过对象访问子类函数。通过作用域符，指针访问父类函数。

函数重写：通过对象访问子类函数。通过作用域符，指针访问父类函数。

函数多态：根据具体对象访问子类和父类函数。

猜你喜欢