重载，隐藏（重定义），覆盖（重写）—这几个名词看着好像很像，不过其实一样都不一样！！
综述：
一、重载：
（1）概念：在同一个作用域内；函数名相同，参数列表不同（参数个数不同，或者参数类型不同，或者参数个数和参数类型都不同），返回值类型可相同也可不同；这种情况叫做c++的重载！
（2）举例：
#include "stdafx.h"
#include<iostream>
using namespace std;
int Add(int a, int b)
{
return a + b;
}
float Add(float a, float b)
{
return a + b;
}
int main()
{
cout << Add(4, 5) << endl;//调用 int Add(int a,int b)
cout << Add(2.5f, 3.7f) << endl;//调用 float Add(float a,float b)
return 0;
}
/*
输出结果：
9
6.2
*/此时，两个函数Add();在同一作用域，函数名相同都是Add，参数类型不同，就构成了c++中的函数重载。
（3）总结：c++函数重载达到的效果：调用函数名相同的函数，会根据实参的类型和实参顺序以及实参个数选择相应的函数。c++函数重载是一种静态多态（又叫做静态联编，静态绑定，静态决议）。
二、覆盖（又叫重写）
（1）概念：当在子类中定义了一个与父类完全相同的虚函数时，则称子类的这个函数重写（也称覆盖）了父类的这个虚函数。
（2）什么是在子类中定义了一个与父类完全相同的虚函数：
有两种情况：
- 1.就是说子类中的虚函数和父类中的虚函数，函数名，参数个数，参数类型，返回值类型都相同；这种情况下子类的这个虚函数重写的父类中的虚函数，构成了重写。
- 2.协变—是说子类中的虚函数和父类中的虚函数，函数名，参数个数，参数类型都相同，只是返回值类型不同；父类的虚函数返回父类的指针或者引用，子类虚函数返回子类的指针或者引用；这种情况下子类的这个虚函数也重写了父类中的虚函数，也构成了重写；——我们把这种特殊的情况叫做协变。
（3）覆盖（重写）达到的效果：
- 1.在子类中重写了父类的虚函数，那么子类对象调用该重写函数，调用到的是子类内部重写的虚函数，而并不是从父类继承下来的虚函数；（这其实就是动态多态的实现）；
- 2.在子类中重写了父类的虚函数，如果用一个父类的指针（或引用）指向（或引用）子类对象，那么这个父类的指针或引用将调用该子类重写的虚函数；相反，如果用一个父类的指针（或引用）指向（或引用）父类的对象，那么这个父类的指针或引用将调用父类的虚函数
（4）举例一：普通重写+函数重载
//普通重写+函数重载
#include "stdafx.h"
#include<iostream>
using namespace std;
class Base
{
public:
virtual void Print()//父类虚函数
{
printf("This is Class Base!\n");
}
};
class Derived1 :public Base
{
public:
void Print()//子类1虚函数，重写了父类的虚函数
{
printf("This is Class Derived1!\n");
}
};
class Derived2 :public Base
{
public:
void Print()//子类2虚函数，重写了父类的虚函数
{
printf("This is Class Derived2!\n");
}
};
int main()
{
Base Cbase;
Derived1 Cderived1;
Derived2 Cderived2;
Cbase.Print();
Cderived1.Print();
Cderived2.Print();
cout << "---------------" << endl;
Base *p1 = &Cbase;
Base *p2 = &Cderived1;
Base *p3 = &Cderived2;
p1->Print();
p2->Print();
p3->Print();
}
/*
输出结果：
This is Class Base!
This is Class Derived1!
This is Class Derived2!
---------------
This is Class Base!
This is Class Derived1!
This is Class Derived2!
*/举例二：协变重写+函数重载
//（协变）重写+函数重载
#include "stdafx.h"
#include<iostream>
using namespace std;
class Base
{
public:
virtual Base &Print()//父类虚函数
{
printf("This is Class Base!\n");
return *this;
}
};
class Derived1 :public Base
{
public:
Derived1 &Print()//子类1虚函数，重写了父类的虚函数
{
printf("This is Class Derived1!\n");
return *this;
}
};
class Derived2 :public Base
{
public:
Derived2 &Print()//子类2虚函数，重写了父类的虚函数
{
printf("This is Class Derived2!\n");
return *this;
}
};
int main()
{
Base Cbase;
Derived1 Cderived1;
Derived2 Cderived2;
Cbase.Print();
Cderived1.Print();
Cderived2.Print();
cout << "---------------" << endl;
Base *p1 = &Cbase;
Base *p2 = &Cderived1;
Base *p3 = &Cderived2;
p1->Print();
p2->Print();
p3->Print();
}
/*
输出结果：
This is Class Base!
This is Class Derived1!
This is Class Derived2!
---------------
This is Class Base!
This is Class Derived1!
This is Class Derived2!
*/（5）总结：覆盖（重写）的两个必要条件：父类函数为虚函数，并且父类和子类函数的函数名、参数个数、参数类型等都必须相同。
三、隐藏（重定义）
（1）概念：是指在不同的作用域中（分别在父类和子类中），函数名相同，不能构成重写的都是重定义。
（2）隐藏（重定义）的使用范围：
重定义的不光是类的成员函数，还可以是类的成员变量；
（3）隐藏（重定义）的直接效果：
如果在父类和子类中有相同名字的成员，那么在子类中，会将父类的成员隐藏；隐藏以后的直接效果就是：无论在子类的内部或者外部（通过子类成员）访问该成员；全都是访问子类的同名成员； 如果在子类内部或者外部（通过子类成员）访问同名的成员函数，则需要根据函数调用的规则来调用子类的同名成员函数；否则调用失败。
（4）举例：
#include "stdafx.h"
#include<iostream>
using namespace std;
class Base
{
public:
Base(int x=1) :value(x) {}
void Print1()//父类函数不是虚函数
{
cout << "Base Print1():" << value << endl;
}
virtual void printf2()//父类函数是虚函数
{
cout << "Base Print2():" << value << endl;
}
int value;
};
class Derived :public Base
{
public:
Derived(int x=2) :value(x) {}
void Print1()//父类函数不是虚函数，则同名子类函数不管相不相同，都可构成“隐藏”
{
cout << "Derived Print1():" << value << endl;
}
void Print2(int a)//父类函数是虚函数，则同名子类函数必须不完全相同，才构成“隐藏”，否则就是“重载”
{
cout << "Derived Print2():" << value << endl;
a = 0;
}
int value;//子类成员数据，隐藏了子类的同名数据
};
int main()
{
Derived Cderived;
cout << Cderived.value << endl; //调用子类的成员数据
Cderived.Print1(); //调用子类的Print1()函数
Cderived.Print2(1); //调用子类的Print2()函数
}
/*
输出结果：
2
Derived Print1():2
Derived Print2():2
*/（5）总结：注意覆盖（重写）和隐藏（重定义）不要搞混了。
参考：
原文地址：https://www.cnblogs.com/linuxAndMcu/p/10292417.html