C++三大概念要分清--重载，隐藏（重定义），覆盖（重写）

转自：http://blog.csdn.net/gogogo_sky/article/details/72860426

重载，隐藏（重定义），覆盖（重写）—这几个名词看着好像很像，不过其实一样都不一样！！

综述：

一、重载：

（1）
概念：在同一个作用域内；函数名相同，参数列表不同（参数个数不同，或者参数类型不同，或者参数个数和参数类型都不同），返回值类型可相同也可不同；这种情况叫做c++的重载！

注意：c语言没有函数重载的机制；

详见：http://blog.csdn.net/gogogo_sky/article/details/72807123

（2）举例：

#include

using namespace std;
int Add(int a,int b)
{
    return a+b;
}
float Add(float a,float b)
{
    return a+b;
}
int main()
{
    cout<4,5)<//调用 int Add(int a,int b)
    cout<2.5f,3.7f)<//调用 float Add(float a,float b)
    return 0;
}
 
 
   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
    
    
    
    
15
    
    
    
    
16
    
    
    
    
17
   
   
   
   

此时，两个函数Add();在同一作用域，函数名相同都是Add，参数类型不同；就构成了c++中的函数重载；

（3）c++函数重载达到的效果：调用函数名相同的函数，会根据实参的类型和实参顺序以及实参个数选择相应的函数；
（4）c++函数重载是一种静态多态（又叫做静态联编，静态绑定，静态决议）

二、覆盖（又叫重写）

（1）说覆盖之前先说一个概念：
虚函数：类的成员函数前面加virtual关键字，则这个成员函数称为虚函数

（2）覆盖（重写）的前提条件：父类函数为虚函数；

（3）覆盖（重写）的概念：当在子类中定义了一个与父类完全相同的虚函数时，则称子类的这个函数重写（也称覆盖）了父类的这个虚函数。

（4）什么是在子类中定义了一个与父类完全相同的虚函数：
有两种情况：

• 1.就是说子类中的虚函数和父类中的虚函数，函数名，参数个数，参数类型，返回值类型都相同；这种情况下子类的这个虚函数重写的父类中的虚函数，构成了重写；

• 2、协变—是说子类中的虚函数和父类中的虚函数，函数名，参数个数，参数类型都相同，只是返回值类型不同；父类的虚函数返回父类的指针或者引用，子类虚函数返回子类的指针或者引用；这种情况下子类的这个虚函数也重写了父类中的虚函数，也构成了重写；——我们把这种特殊的情况叫做协变

注意：

在子类中定义了一个与父类虚函数完全相同的函数，那么这个子类的函数就是重写了父类的虚函数，此时这个子类的函数就是虚函数，如果不显示的加上virtual修饰，编译器也会默认为虚函数；

（5）覆盖（重写）达到的效果：

• 1.在子类中重写了父类的虚函数，那么子类对象调用该重写函数，调用到的是子类内部重写的虚函数，而并不是从父类继承下来的虚函数；（这其实就是动态多态的实现）；

• 2.在子类中重写了父类的虚函数，如果用一个父类的指针（或引用）指向（或引用）子类对象，那么这个父类的指针或用引用调用该重写的虚函数，调用的是子类的虚函数；相反，如果用一个父类的指针（或引用）指向（或引用）父类的对象，那么这个父类的指针或用引用调用该重写的虚函数，调用的是父类的虚函数

（6）举例1：普通重写+函数重载

//普通重写+函数重载
#include
using namespace std;
class Person//父类
{
public:
    virtual void BuyTickets()//父类虚函数
    {
        cout<<" 买票-全票"<< endl;
    }
protected :
    string  _name; // 姓名
};

class Student : public Person//子类
{
public:
     void BuyTickets()//子类虚函数
    {
        cout<<" 买票-半价"<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
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
    
    
    
    
15
    
    
    
    
16
    
    
    
    
17
    
    
    
    
18
    
    
    
    
19
    
    
    
    
20
    
    
    
    
21
    
    
    
    
22
    
    
    
    
23
    
    
    
    
24
    
    
    
    
25
    
    
    
    
26
    
    
    
    
27
    
    
    
    
28
    
    
    
    
29
    
    
    
    
30
    
    
    
    
31
    
    
    
    
32
    
    
    
    
33
    
    
    
    
34
    
    
    
    
35
    
    
    
    
36
    
    
    
    
37
    
    
    
    
38
    
    
    
    
39
    
    
    
    
40
    
    
    
    
41
    
    
    
    
42
    
    
    
    
43
    
    
    
    
44
    
    
    
    
45
    
    
    
    
46
    
    
    
    
47
    
    
    
    
48
    
    
    
    
49
   
   
   
   

分析：

在子类中的函数 void BuyTickets()和父类的虚函数virtual void BuyTickets()，他们的函数名相同都为BuyTickets，参数相同都为空，返回值都相同为void，所以此时子类中的函数void BuyTickets()重写了父类的虚函数virtual void BuyTickets()；那么这是即使子类的函数void BuyTickets()不加关键字virtual修饰，编译器默认它为虚函数；
父类的指针Person* p（或引用Person&p）指向（或引用）子类对象s，那么这个父类的指针或用引用调用该重写的虚函数，调用的是子类的虚函数；
相反，用一个父类的指针Person* p（或引用Person&p）指向（或引用）父类的对象p，那么这个父类的指针或用引用调用该重写的虚函数，调用的是父类的虚函数

其中：

void Fun (Person* p)
{
   p->BuyTickets();
}
void Fun (Person&p)
{
    p.BuyTickets();
}
 
 
   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
   
   
   
   

这两个哈数构成了函数重载

举例二：协变重写+函数重载

//（协变）重写+函数重载

#include
using namespace std;
class Person//父类
{
public:
    virtual  Person& BuyTickets()//父类虚函数
    {
        cout<<"成人买票-全票"<return *this;
    }
public:
  string  _name; // 姓名
};

class Student : public Person//子类
{
public:
    virtual Student& BuyTickets()//子类虚函数
    {
        cout<<"学生买票-半票"<return *this;
    }
public:
    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
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
    
    
    
    
15
    
    
    
    
16
    
    
    
    
17
    
    
    
    
18
    
    
    
    
19
    
    
    
    
20
    
    
    
    
21
    
    
    
    
22
    
    
    
    
23
    
    
    
    
24
    
    
    
    
25
    
    
    
    
26
    
    
    
    
27
    
    
    
    
28
    
    
    
    
29
    
    
    
    
30
    
    
    
    
31
    
    
    
    
32
    
    
    
    
33
    
    
    
    
34
    
    
    
    
35
    
    
    
    
36
    
    
    
    
37
    
    
    
    
38
    
    
    
    
39
    
    
    
    
40
    
    
    
    
41
    
    
    
    
42
    
    
    
    
43
    
    
    
    
44
    
    
    
    
45
    
    
    
    
46
    
    
    
    
47
    
    
    
    
48
    
    
    
    
49
    
    
    
    
50
   
   
   
   

三、隐藏（重定义）

（1）隐藏（重定义）概念：

是指在不同的作用域中（分别在父类和子类中），函数名相同，不能构成重写的都是重定义。

（2）隐藏（重定义）的使用范围：

重定义的不光是类的成员函数，还可以是类的成员变量；

（3）隐藏（重定义）的直接效果：

如果在父类和子类中有相同名字的成员；那么在子类中。会将父类的成员隐藏；隐藏以后的直接效果就是：无论在子类的内部或者外部（通过子类成员）访问该成员；全都是访问子类的同名成员； 如果在子类内部或者外部（通过子类成员）访问同名的成员函数，则需要根据函数调用的规则来调用子类的同名成员函数；否则调用失败；

#include
using namespace std;

class A
{
protected:
    A(int x=2)
        :_a(x)
    {}
//public:
//  //1
//     void show()
//  {
//      cout<<"A::shou()"<
//  }

//public:
//  //2
//  virtual void show()
//  {
//      cout<<"A::shou()"<
//  }
public:
    //3
    void show(int a)
    {
        cout<<"A::shou()"<public:
    int _a;
};
class B:public A
{
public:
    B(int x=1)
        :_a(x)
    {}
//public:
//  //1
//  void show(int b)
//  {
//      cout<<"B::shou()"<
//  }
//public:
//  //2
//  void show(int a)
//  {
//      cout<<"B::shou()"<
//  }
public:
    //3
    void show(int a,int b)
    {
        cout<<"B::shou()"<public:
    int _a;
};

int main()
{
    B b;
    cout<<(b._a)<1);
    return 0;
}
 
 
   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
    
    
    
    
15
    
    
    
    
16
    
    
    
    
17
    
    
    
    
18
    
    
    
    
19
    
    
    
    
20
    
    
    
    
21
    
    
    
    
22
    
    
    
    
23
    
    
    
    
24
    
    
    
    
25
    
    
    
    
26
    
    
    
    
27
    
    
    
    
28
    
    
    
    
29
    
    
    
    
30
    
    
    
    
31
    
    
    
    
32
    
    
    
    
33
    
    
    
    
34
    
    
    
    
35
    
    
    
    
36
    
    
    
    
37
    
    
    
    
38
    
    
    
    
39
    
    
    
    
40
    
    
    
    
41
    
    
    
    
42
    
    
    
    
43
    
    
    
    
44
    
    
    
    
45
    
    
    
    
46
    
    
    
    
47
    
    
    
    
48
    
    
    
    
49
    
    
    
    
50
    
    
    
    
51
    
    
    
    
52
    
    
    
    
53
    
    
    
    
54
    
    
    
    
55
    
    
    
    
56
    
    
    
    
57
    
    
    
    
58
    
    
    
    
59
    
    
    
    
60
    
    
    
    
61
    
    
    
    
62
    
    
    
    
63
    
    
    
    
64
    
    
    
    
65
    
    
    
    
66
    
    
    
    
67
   
   
   
   

程序中所标明的1，2，3三种情况都是成员隐藏！