重载：本质上还是函数不一样，函数名称一样但是参数不一样
重写：本质上是重写原来函数，函数名称参数都一样，通过虚函数实现
多态：只要是同一函数名实现不同功能，在外看来都是多态
虚函数：用于实现重写
重定义： 是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
a 如果派生类的函数和基类的函数同名，但是参数不同，此时，不管有无virtual，基类的函数被隐藏。
b 如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有vitual关键字，此时，基类的函数被隐藏。
1.基类与子类之间可以重载吗？（重载仅类内部可用）
不可以，按照重载的定义在子类中写函数，那已经变成了重定义，原因是基类和子类作用域不同。
2.基类和子类之间可以重写吗？（重写仅类之间可用）
可以
3.基类内部可以重定义吗？（重定义仅类之间可用）
不可以，会报错，定义俩次。

注：在我看来除了返回值不同不可以将俩个函数看为是不相同的函数外，其余的，比如函数所处作用域，函数的参数类型，个数不同都可以看为不同的函数，既然是不同的函数那么就可以定义，并且分别调用。

#include<iostream> using namespace std; class Animal { public: void func1(int tmp)//用于函数重载 { cout << "I'm an animal " << tmp << endl; } void func1(const char *s)//函数的重载 { cout << "I'm an animal func1 " << s << endl; } virtual void func2(int tmp)//用于重写 { cout << "I'm virtual animal func2 " << tmp << endl; } void func3(int tmp)用于重定义 { cout << "I'm an animal func3 " << tmp << endl; } }; class Fish :public Animal { public: void func2(int tmp) //函数的重写， 覆盖父类的方法 override { cout << "I'm a fish func2 " << tmp << endl; } void func3(int tmp) { //函数的重定义 会隐藏父类同名方法． cout << "I'm a fish func3 " << tmp << endl; } void func3() { cout<<"I'm fish func3 "<<endl;//函数重定义，与基类func3不仅作用域不同，而且参数不同，也是子类中func3重载函数 } }; int main() { Fish fi; Animal an; an.func1("a"); an.func1(1); cout<<("*")<<endl; //参数类型不同直接调用 an.func2(2); fi.func2(2); cout<<("")<<endl; //重写函数的作用域不同 an.func3(3); fi.func3(3); cout<<("*")<<endl; //重定义函数的作用域不同 an.func3(3); fi.func3(); //重定义函数的作用域和参数均不同 return 0; } 

结果

讯享网
那么既然如此，重定义和重写的区别和作用究竟是啥呢？
在上面那种情况下，确定没啥区别，请看下面重头戏：

讯享网#include<iostream> using namespace std; class Animal { public: virtual void func2(int tmp)//用于重写 { cout << "I'm virtual animal func2 " << tmp << endl; } void func3(int tmp)用于重定义 { cout << "I'm an animal func3 " << tmp << endl; } }; class Fish :public Animal { public: void func2(int tmp) //函数的重写， 覆盖父类的方法 override { cout << "I'm a fish func2 " << tmp << endl; } void func3(int tmp) { //函数的重定义 会隐藏父类同名方法 cout << "I'm a fish func3 " << tmp << endl; } }; void xu_han_shu(Animal *fi_an)//指向虚函数方式对象的指针做为参数 { fi_an->func2(2); }; void chong_ding_yi(Animal *fi_an)//指向重定义方式对象的指针做为参数 { fi_an->func3(3) ; }; int main() { Fish fi; Animal an; Animal *ptr; ptr = &an; xu_han_shu(ptr); ptr = &fi; xu_han_shu(ptr); cout<<""<<endl; //虚函数方式 ptr = &an; chong_ding_yi(ptr); ptr = &fi; chong_ding_yi(ptr); //重定义方式 return 0; } 

总结：在我看来重写，在调用时候与前面的情况完全不同，原因就是它的函数在定义时候看来是一个，但是执行结果却有俩个，其他的都是定义时候就可以知道其有不一样的地方，所以虚函数方式，才有运行时编译这个说法。
根据运行时传入的参数，对象不同，去调用不同的函数。其实就是相当于一般的一个函数，传入的参数类型是一致的，但是传入的数值不同然后得到不同的结果，我觉得是一种扩展思想。当然也实现了多态。
底层原理为什么会这样：如果不用虚函数的办法，当你子类去继承父类时候会直接拷贝一份父类的数据过来， 再加上自己类中的重定义的函数
一、定义函数时决定的多态
1.重载(类内部）
二、运行时决定的多态
1.参数为一般 同类型：
一个函数，结果由传入的具体值决定
2.参数为类 同类型：（类之间）
一个函数，结果由传入的具体对象决定
三、
重定义只是简单的覆盖而已，没实现多态，和多态没关系，就是用子类的函数覆盖掉继承来自父类的同名函数，以实现该函数和父类不一样的功能，没啥技术含量。优先选虚函数法．554、

函数模板也是多态，而且是静态时多态

类模板也是静态时编译，也是多态