目录

一、什么叫重写

二、面向对象期望的重写​

1、示例分析

2、所期望的重写

三、多态的概念和意义

1、多态的概念

2、C++如何支持多态概念

3、多态内部运行剖析

4、多态的意义

5、修改示例代码

四、静态联编和动态联编

五、小结

一、什么叫重写

1、子类中可以重定义父类中已经存在的成员函数；

2、这种重定义发生在继承中，叫做函数重写；

3、函数重写是同名覆盖的一种特殊情况。

二、面向对象期望的重写

先来验证个小示例：

#include <QCoreApplication>
#include <iostream>
#include <QDebug>

using namespace std;

class Parent
{

public:

    void Printfln()
    {
        std::cout << "Parent: void Printfln()..." << std::endl;
    }
};

class Child : public Parent
{
public:

    void Printfln()
    {
        std::cout << "Child: void Printfln()..." << std::endl;
    }
};

void run(Parent *p)
{
    p->Printfln();
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Parent p;
    Child c;

    run(&p);
    run(&c);

    return a.exec();
}

1、示例分析

1、结果：结果是调用两次run函数打印的结果相同；

2、分析：

（1）编译期间，编译器只能根据指针的类型判断所指向的对象；

（2）根据赋值兼容性原则，编译器认为父类指针指向的是父类对象；

（3）run函数中的指针p，编译器不可能知道它指向的究竟是什么，但是编译器没理由报错，编译器认为最安全的做法就是调用父类Printfln()函数，因为父类和子类都有相同的Printfln()函数；

（4）因此，编译器结果只可能是调用父类定义的同名函数。

2、所期望的重写

面向对象的期望重写行为：根据实际的对象类型来判断如何调用重写函数；

（1）当父类指针（引用）指向父类对象，则调用父类中定义的成员函数；

（2）当父类指针（引用）指向子类对象，则调用子类中定义的重写函数。

三、多态的概念和意义

1、多态的概念

（1）根据实际的对象类型决定函数调用的具体目标；

（2）同样的调用语句在实际运行时有多种不同的表现形态体现，这就是多态，同一语句具有多种形态。

2、C++如何支持多态概念

（1）通过使用virtual关键字对多态进行支持；

（2）被virtual修饰的函数被重写后具有多种不同的表现形态；

（3）被virtual声明的函数称为虚函数。

3、多态内部运行剖析

父类和子类的对象，首地址都各自有一个虚函数表地址，该地址都保存着虚函数Printfln()的地址，在运行过程中：

（1）在父类指针（引用）p，指向父类对象，就相当于指向父类的虚函数表，从而在父类的虚函数表中找到Printfln()函数；

（2）在父类指针（引用）p，指向子类对象，相当于指向子类的虚函数表，从而在子类的虚函数表中找到Printfln()函数。

4、多态的意义

（1）在程序运行中展现出动态的特性；

（2）函数重写必须多态实现，否则没有任何意义；

（3）多态是面向对象组件化程序设计的基础特性。

5、修改示例代码

根据多态的概念，在程序中给父子类同名函数声明virtual关键字，只需要在父类中声明即可，在子类中可以不写，写了也是对的，编译器不会报错。

#include <QCoreApplication>
#include <iostream>
#include <QDebug>

using namespace std;

class Parent
{

public:

    virtual void Printfln()
    {
        std::cout << "Parent: void Printfln()..." << std::endl;
    }
};

class Child : public Parent
{
public:

    void Printfln()
    {
        std::cout << "Child: void Printfln()..." << std::endl;
    }
};

void run(Parent *p)
{
    p->Printfln();
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Parent p;
    Child c;

    run(&p);
    run(&c);

    return a.exec();
}

四、静态联编和动态联编

1、静态联编：在程序编译期间就能确定的具体的函数调用，如函数重载；

2、动态联编：在程序运行期间才能确定的具体的函数调用，如函数重写。

五、小结

1、函数重写只能发生在父类和子类之间；

2、多态是根据实际对象类型确定调用具体的函数；

3、virtual关键字是C++支持多态的唯一方式；

4、被重写的虚函数具有多种不同表现形态。

先看Java代码：

public class Example {
    public static void main(String[] args) {
        System.out.println("====人====");
        Person person = new Person("叽里呱啦","默认皮肤");
        person.say();
        person.showSkin();
        person.walk();
        person.eat();
        person.sleep();

        //多态
        System.out.println("====中国人====");
        Person chinese = new Chinese("中文","黄皮肤");
        chinese.say();
        chinese.showSkin();
        chinese.walk();
        chinese.eat();
        chinese.sleep();
				
        System.out.println("====美国人====");
        Person american = new American("英文","白皮肤");
        american.say();
        american.showSkin();
        american.walk();
        american.eat();
        american.sleep();
    }
}
class Person {
    String language;
    String skinColor;
    public Person() {}
    public Person(String language, String skinColor) {
        this.language = language;
        this.skinColor = skinColor;
    }
    public void say(){
        System.out.println("说"+this.language);
    }
    public void showSkin(){
        System.out.println(this.skinColor);
    }
    public void walk(){
        System.out.println("人走路");
    }
    public void eat(){
        System.out.println("人吃饭");
    }
    public void sleep(){
        System.out.println("人睡觉");
    }
}
class Chinese extends Person {
    public Chinese(){}
    public Chinese(String language, String skinColor) {
        super(language,skinColor);
    }
}
class American extends Person {
    public American(){}
    public American(String language, String skinColor) {
        super(language,skinColor);
    }
}

运行结果：

总结：多态的意义就是，当new出来的对象中自己“独特的”方法时，默认采用申明类型中“普遍的”方法，“多态”这一词的含义就来源于这种用于对创造的对象的广泛性的意义。

此文编写参考狄泰软件学院唐佐林老师的视频课程，如有错误之处，欢迎指正。

1、多态初认识

多态也就是面向对象中期望的行为。
（1） 根据实际的对象类型判断如何调用重写函数
（2） 父类指针（引用）指向
父类对象则调用父类中调用的函数
子类对象则调用子类中定义的重写函数
总的来说就是根据实际的对象类型决定函数调用的具体目标，同样的调用语句在实际运行时有多种不同的表现形态。

2、语法

通过关键字virtual来对函数进行声明
（1）被virtual声明的函数被重写后具有多态特性
（2）被virtual声明的函数叫虚函数
（3）要在父类中对函数进行声明

下面通过一个实例来理解。

#include<iostream>
#include<string>
using namespace std;

class Parent 
{
public:
	virtual void print()
	{
		cout<<"I am Parent."<<endl;
	}
	
};
class Child:public Parent
{
	void print()
	{
		cout<<"I am Child."<<endl;
	}
};

void how_to_print(Parent* p)
{
	p->print();
}
int main()
{
	Parent p;
	Child c;
	how_to_print(&p);
	how_to_print(&c);

	return 0;
}

分析：这里正常情况下会发生同名覆盖，但是将父类中的函数声明为虚函数后，就输出了期望的行为。

3、多态的意义

在程序运行过程中展现出动态的特性
函数重写必须实现多态，否则没有意义
多态是面向对象组件化程序设计的基础特性

4、理论中的概念

1. 静态联编
   在程序的编译期间就能够确定具体函数的调用
   如：函数重载
2. 动态联编
   在程序实际运行后才能确定具体的函数调用
   如：函数重写

下面通过实例来理解动态联编和静态联编

#include <iostream>
#include <string>

using namespace std;

class Parent
{
public:
    virtual void func()
    {
        cout << "void func()" << endl;
    }
    
    virtual void func(int i)
    {
        cout << "void func(int i) : " << i << endl;
    }
    
    virtual void func(int i, int j)
    {
        cout << "void func(int i, int j) : " << "(" << i << ", " << j << ")" << endl;
    }
};

class Child : public Parent
{
public:
    void func(int i, int j)
    {
        cout << "void func(int i, int j) : " << i + j << endl;
    }
    
    void func(int i, int j, int k)
    {
        cout << "void func(int i, int j, int k) : " << i + j + k << endl;
    }
};

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

int main()
{
    Parent p;
    
    p.func();         // 静态联编
    p.func(1);        // 静态联编
    p.func(1, 2);     // 静态联编
    
    cout << endl;
    
    Child c;
    
    c.func(1, 2);     // 静态联编
    
    cout << endl;
    
    run(&p);
    run(&c);
    
    return 0;
}

运行结果：

5、江湖恩怨

#include<iostream>
#include<string>
using namespace std;

class Boss
{
public:
	int fight()
	{
		int ret=10;
		cout<<"Boss::fight():"<<ret<<endl;
		return ret;
	}
};

class Master
{
public:
	virtual int eightswords()
	{
		int ret=8;
		cout<<"Master::eightswords():"<<ret<<endl;
		return ret;
	}
};

class newMaster:public Master
{
public:
	int eightswords()
	{
		int ret=Master::eightswords()*2;
		cout<<"Master::eightswords():"<<ret<<endl;
		return ret;
	}
};
void pk(Master* m,Boss* b)
{
	int zhuangzhu=m->eightswords();
	int ermo=b->fight();
	if(zhuangzhu<ermo)
	{
		cout<<"zhuangzhu is killed"<<endl;
	}
	else
	{
		cout<<"ermo is killed"<<endl;
	}
}

int main()
{
	Master zhuangzhu;
	Boss ermo;
	cout<<"zhuangzhu vs ermo"<<endl;
	pk(&zhuangzhu,&ermo);
	cout<<endl;
	newMaster shaozhuangzhu;
	cout<<"shaozhuangzhu vs ermo"<<endl;
	pk(&shaozhuangzhu,&ermo);
	
	return 0;
}

6、总结

函数重写只能发生在父类和子类之间
多态会根据实际对象的类型确定调用具体的函数
virtual关键字是c++中支持多态的唯一方式
被重写的虚函数可表现出多态的特性