隐藏

-----------------siwuxie095

在 C++ 中有两个非常重要但又特别容易混淆的概念，即覆盖和隐藏

这里主要介绍隐藏

如下：

父类 A 中有成员函数 ABC()，子类 B 公有继承了父类 A，且在

子类 B 中定义了同名的成员函数 ABC()，而子类 B 又继承了父

类 A 的成员函数 ABC()，这时，子类 B 的 ABC() 就会隐藏掉父

类 A 的 ABC()

隐藏的特性也主要体现在：当实例化子类 B 的对象时，使用该

对象只能直接访问到子类 B 中的 ABC()，而无法访问到父类 A

中的 ABC()

从使用的体验上来说，父类 A 中的 ABC() 就似乎被隐藏起来了，

但实际上，因为父类 A 中的 ABC() 确实被继承到子类 B 中，并

且可以通过特殊的手段访问到父类 A 中的 ABC()，于是将这种特

性称之为隐藏

当然，同名的隐藏，不仅限于成员函数，从语法的角度上来说，

同名的数据成员，也具有隐藏的特征

只不过，因为存在父子关系的两个类之间的数据成员，如果同名，

也没有什么实际的意义，所以在实际的使用中十分罕见

综上，归纳为三个关键字，即：

看如下实例：

定义一个人类：Person 和一个士兵类：Soldier，士兵类公有继承了

人类，且士兵类中定义了一个同名的成员函数：play()，因为士兵的玩

法和普通人的玩法会有所不同

在使用时：

soldier.play() 调用的是 Soldier 中自己定义的 play()，而如果想通过 soldier

对象调用到父类 Person 中的 play()，就要使用：soldier.Person::play()

在定义数据成员时，将父类和子类的数据成员定义的同名了，如：code，

即编号。这种定义习惯非常不好，在概念上容易混淆

如果想要访问 code，往往会在成员函数中去访问，因为这两个数据成员

都定义在 protected 下，用实例化的对象无法直接访问到

在 Soldier 类中的 work() 函数中访问 code：

当使用好一点的命名方法，其实就可以避免同名的情况，如：使用

m+下划线+数据类型+名字的形式（m 即 member）

具体到这里就是：m_strCode 和 m_iCode，于是就不会有重名的情况

程序：

Person.h：

#include <string>

using namespace std;

class Person

{

public:

Person();

void play();

protected:

string m_strName;

};

Person.cpp：

#include "person.h"

#include <iostream>

using namespace std;

//include 包含头文件时，使用双引号和尖括号的不同：

//（1）使用双引号时，计算机会在当前程序的目录下寻找头文件

//（2）使用尖括号时，计算机会在程序的默认库中搜索头文件

//鼠标悬停到头文件上，右键->打开文档，就可以到达该头文件定义的地方

Person::Person()

{

m_strName = "Merry";

}

void Person::play()

{

cout << "Person--play()" << endl;

cout << m_strName << endl;

}

Soldier.h：

#include "person.h"

class Soldier :public Person

{

public:

Soldier();

void play();//同名成员函数

void work();

protected:

string m_strName;//同名数据成员

};

Soldier.cpp：

#include "Soldier.h"

#include <iostream>

using namespace std;

Soldier::Soldier()

{

}

void Soldier::play()

{

cout << "Soldier--play()" << endl;

m_strName = "Jim";

//会覆盖掉父类构造函数中对m_strName的初始化的值

Person::m_strName = "Jack";

cout << m_strName << ":" << Person::m_strName << endl;

}

void Soldier::work()

{

cout << "Soldier--work()" << endl;

}

main.cpp：

#include <stdlib.h>

#include "Soldier.h"

using namespace std;

//父子关系成员同名（数据成员和函数成员）隐藏

int main(void)

{

Soldier soldier;

soldier.play();

soldier.work();

//Person的play()本来应该打印其构造函数中初始化的Merry

//但是在实例化子类对象时，先调用父类构造函数后调用子类构造函数，

//所以后来子类对象调用自己的play()时，把父类的m_strName的值覆盖掉了

//打印的就是Jack，而不是Merry了

//如果注释掉子类的play()中的 Person::m_strName = "Jack";

//打印的依然是 Merry

soldier.Person::play();

system("pause");

return 0;

}

//如果将Soldier类的play()函数加个参数x（只起区别作用）

//Soldier类中： void play(int x);

//main()函数中： Soldier.play(7); Soldier.play();

//这是错误的，无法调用父类Person的play()函数

//只能通过 soldier.Person::play(); 来访问

//即两个即便参数不同只要同名就只能隐藏而无法形成重载

【made by siwuxie095】