1.1 覆盖隐藏重载
重载，隐藏（重定义），覆盖（重写）—这几个名词看着好像很像，不过其实一样都不一样！！
1.1.1 重载：
（1）
概念：在同一个作用域内；函数名相同，参数列表不同（参数个数不同，或者参数类型不同，或者参数个数和参数类型都不同），返回值类型可相同也可不同；这种情况叫做c++的重载！
注意：c语言没有函数重载的机制；
（2）举例：
#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; } |
此时，两个函数Add();在同一作用域，函数名相同都是Add，参数类型不同；就构成了c++中的函数重载；
（3）c++函数重载达到的效果：调用函数名相同的函数，会根据实参的类型和实参顺序以及实参个数选择相应的函数；
（4）c++函数重载是一种静态多态（又叫做静态联编，静态绑定，静态决议）
1.1.2 覆盖（又叫重写）
（1）说覆盖之前先说一个概念：
虚函数：类的成员函数前面加virtual关键字，则这个成员函数称为虚函数
（2）覆盖（重写）的前提条件：父类函数为虚函数；
（3）覆盖（重写）的概念：当在子类中定义了一个与父类完全相同的虚函数时，则称子类的这个函数重写（也称覆盖）了父类的这个虚函数。
（4）什么是在子类中定义了一个与父类完全相同的虚函数：
有两种情况：
1.就是说子类中的虚函数和父类中的虚函数，函数名，参数个数，参数类型，返回值类型都相同；这种情况下子类的这个虚函数重写的父类中的虚函数，构成了重写；
2、协变—是说子类中的虚函数和父类中的虚函数，函数名，参数个数，参数类型都相同，只是返回值类型不同；父类的虚函数返回父类的指针或者引用，子类虚函数返回子类的指针或者引用；这种情况下子类的这个虚函数也重写了父类中的虚函数，也构成了重写；——我们把这种特殊的情况叫做协变
注意：
在子类中定义了一个与父类虚函数完全相同的函数，那么这个子类的函数就是重写了父类的虚函数，此时这个子类的函数就是虚函数，如果不显示的加上virtual修饰，编译器也会默认为虚函数；
（5）覆盖（重写）达到的效果：
1.在子类中重写了父类的虚函数，那么子类对象调用该重写函数，调用到的是子类内部重写的虚函数，而并不是从父类继承下来的虚函数；（这其实就是动态多态的实现）；
2.在子类中重写了父类的虚函数，如果用一个父类的指针（或引用）指向（或引用）子类对象，那么这个父类的指针或用引用调用该重写的虚函数，调用的是子类的虚函数；相反，如果用一个父类的指针（或引用）指向（或引用）父类的对象，那么这个父类的指针或用引用调用该重写的虚函数，调用的是父类的虚函数
（6）举例1：普通重写+函数重载
//普通重写+函数重载
#include<iostream> using namespace std; class Person//父类 { public: virtual void BuyTickets()//父类虚函数 { cout<<" 买票-全票"<< endl; } protected : string _name; // 姓名 };
class Student : public Person//子类 { public: void BuyTickets()//子类虚函数 { cout<<" 买票-半价"<<endl ; } protected : int _num ; //学号 }; void Fun (Person* p) { p->BuyTickets(); } void Fun (Person&p) { p.BuyTickets(); } void Test () { Person p ; Student s; Fun(p); Fun(s);
Fun(&p); Fun(&s); } int main() { Test(); return 0; } |
1.1.3 隐藏（重定义）
（1）隐藏（重定义）概念：
是指在不同的作用域中（分别在父类和子类中），函数名相同，不能构成重写的都是重定义。
（2）隐藏（重定义）的使用范围：
重定义的不光是类的成员函数，还可以是类的成员变量；
（3）隐藏（重定义）的直接效果：
如果在父类和子类中有相同名字的成员；那么在子类中。会将父类的成员隐藏；隐藏以后的直接效果就是：无论在子类的内部或者外部（通过子类成员）访问该成员；全都是访问子类的同名成员；如果在子类内部或者外部（通过子类成员）访问同名的成员函数，则需要根据函数调用的规则来调用子类的同名成员函数；否则调用失败；
#include<iostream> using namespace std; class A { protected: A(int x=2) :_a(x) {} //public: // //1 // void show() // { // cout<<"A::shou()"<<endl; // } //public: // //2 // virtual void show() // { // cout<<"A::shou()"<<endl; // } public: //3 void show(int a) { cout<<"A::shou()"<<endl; } public: int _a; }; class B:public A { public: B(int x=1) :_a(x) {} //public: // //1 // void show(int b) // { // cout<<"B::shou()"<<endl; // } //public: // //2 // void show(int a) // { // cout<<"B::shou()"<<endl; // } public: //3 void show(int a,int b) { cout<<"B::shou()"<<endl; cout<<_a<<endl; } public: int _a; };
int main() { B b; cout<<(b._a)<<endl; b.show(1); return 0; } |
程序中所标明的1，2，3三种情况都是成员隐藏！