文章目录
📖 前言
我们知道C++语言是一门面向对象编程的语言，而面向对象编程有三大特性，它们分别是：
- 封装
- 继承
- 多态
在此之前我们已经学习了封装，下面通过和面向过程编程对比来体现封装的好处。
两种设计对比而言：
狭义的角度对比：
例如，我们设计一个 Stack - 栈 分别用C语言和C++来设计：
C语言设计的相对于C++而言设计的并不是很好（仅从语法层面比较），因为C语言没有封装，使用者可以对栈进行随意访问，从规范的角度来说不是那么好。而C++则是进行了封装，因为其通过访问限定符 + 类 的方式来进行封装，因为类中的数据和方法（函数）放在了一起，再用访问限定符的限制。
广义的角度对比：
例如，我们迭代器的设计：
如果没有迭代器，容器的访问只能暴露底层。暴露底层结构就有问题：使用复杂，使用成本高，对使用者的要求也很高（要求使用者懂得底层原理）。
迭代器的使用是封装了容器的底层结构，不暴露底层结构情况，提供统一的访问容器的方式，降低使用的成本，简化了使用者的使用成本，因为上层的使用方式都一样。
适配器模式：
通过利用其他容器的特性来适配要实现的容器，例如，stack/queue/priority_queue等容器的实现，都是复用了其他容器。
同时面向对象不止三大特性，还有其他特性，例如：反射（C++没有，java有），抽象。
本文将介绍面向对象编程的另一大特性：继承。
继承是在更高的维度来设计类。
1. 继承的介绍
1.1 继承的引入：
假如我们用C++来设计一个图书管理系统，在实现的过程中，我们对角色封装成类。
我们要实现的角色类有：学生、老师、图书管理员、保洁员等。
我们先来实现学生类和老师类：
我们发现：
- 有些数据和方法（函数）是每个角色都有的 – 重复设计了
- 有些数据和方法（函数）是每个角色独有的
我们写代码讲究的是复用。
- 例如，当要实现相同的功能时，我们将功能等价的代码提取成了函数，每次执行相同的一段指令的时候只需调用函数即可。
- 若是类的设计重复了，那我们也要想办法去提取。
所以为了要解决上述的问题，C++用继承的方式对共同的类进行提取。
1.2 继承的概念：
概念：
继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。
1.3 继承的定义格式：
继承的形象定义：
- 继承的本质是类设计角度的复用
- 我们形象的将上面的Person类叫做：父类 / 基类
- 将Student类和Teacher类叫做：子类 / 派生类
继承的格式：
2. 继承的使用
2.1 继承的样例：
使用方式 - - 举个栗子：
class Person
{
public:
void Print()
{
cout << "name:" << _name << endl;
cout << "tel:" << _tel << endl;
}
protected:
string _name; //姓名
string _tel; //电话
string _address; //地址
};
class Teacher : public Person
{
protected:
int _age;
string _workId;
};
class Student : public Person
{
protected:
int _age;
string _stuId;
};
int main()
{
Student s;
Teacher t;
s.Print();
t.Print();
return 0;
}
通过监视窗口来看：
通过监视窗口可见，s和t两个对象，分别都继承了Person的成员变量，对象中是不存方法的（实际存在代码段），子类也去（代码段）复用了成员函数。
2.2 继承的方式：
C++在这里设计的很复杂，又设计了三种继承方式。
父类成员有三种访问限定符，子类继承父类又有三种继承方式，两两一组合，所以组合出来就有9种组合方式！
继承关系和访问限定符：
继承基类成员访问方式的变化：
总结如下：
- 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
- 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
- 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public>protected>private。
- 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
- 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承， 也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。
总结提炼：
- 先将基类的 私有成员 和 公有/保护成员 分成两类去看待
- 基类的私有成员在子类都是不可见
- 基类中其他成员的访问方式是 （成员在基类的访问限定符，继承方式）当中，权限小的那一个
- 权限关系我们可以认为是：public > protected > private
- 父类的私有成员也会被继承过来，只是语法限制其不能访问。
- 不可见意思是：在类外面和类里面都不能访问。
- 之前我们学的，保护和私有 都是在类外面不能访问，在类里面可以访问，没有区别
- 但是在继承这里是有区别的，如果父类的成员是保护（protected）且继承关系不是private，子类可以用，如果父类成员是私有（private）子类不能用。
C++早起设计想复杂了，实际中父类成员基本都是保护和公有，继承方式都是公有继承，很少会用到保护和私有继承（场景极少）。
证明父类私有成员确实被继承下来的程序：
class Person
{
protected:
//private:
string _name; //姓名
string _tel; //电话
string _address; //地址
};
class Student : public Person
{
protected:
int _age;
string _stuId;
};
int main()
{
Student s;
cout << sizeof(s) << endl;
return 0;
}
无论父类成员是 私有（private）还是 保护（protected）子类的大小都是一样的 --> 116
3. 基类和派生类对象赋值转换（重点）
- 派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用
- 这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。
- 有的地方也叫向上转换，子在下父在上，派生类在下基类在上的转换。
- 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。
- 但是必须是基类的指针是指向派生类对象时才是安全的。
这个过程是天然支持的没有类型转换。
切割 / 切片 举例：
class Person
{
public:
string _name; //姓名
string _tel; //电话
string _address; //地址
int _age; //年龄
};
class Student : public Person
{
string _stuId;
};
class Teacher : public Person
{
string _workId;
};
int main()
{
Person p;
Student s;
s._name = "张三";
s._tel = "12345";
s._address = "学校";
p = s;
Person& rp = s;
Person* ptr = &s;
return 0;
}
对象赋值切片可以理解为是将值依次赋值过去。
如何理解引用和指针的切片？
- rp是子类当中，父类那一部分的别名
- 指针是指向子类中父类的那一部分，但是指针类型向后看的大小是切出来的一部分
并且这三者地址是一样的：
- 赋值兼容的规则是建立在 public（公有）继承的基础上
- 因为成员变量在继承下来时，可能已经变成了保护的或者是私有的
- 赋值给父类对象有可能就变成父类的公有成员了，这样不太合理
- 父类/基类 对象赋值给 子类/派生类 对象是不可以的
- 只能向上去赋值（切片），不能向下赋值
- 也就是说子能给父，父不能给子
- 通过强转的话，对象不能强转，基类/父类 的指针可以强转成 子类/派生类的指针 或者是引用也可以（过程涉及到dynamic_cast了解 – 这样才安全），以后学习会讲到
实际当中很少遇到父类转子类，基本上都是子类转父类。
4. 继承中的作用域
- 在继承体系中基类和派生类都有独立的作用域。
- 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，
也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问） - 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
- 注意在实际中在继承体系里面最好不要定义同名的成员。
这里相当于就近原则（局部有限），先调用离自己近的。
成员变量同名的隐藏：
class Person
{
protected:
string _name = "小李子";
int _num = 111;
};
class Student : public Person
{
public:
void Print()
{
cout << "姓名:" << _name << endl;
cout << "子类的身份证号:" << _num << endl;
//告诉编译器直接去父类中找
cout << "父亲类的身份证号:" << Person::_num << endl;
}
protected:
int _num = 999;
};
int main()
{
Student s1;
s1.Print();
return 0;
};
s1中有两个_num，一个是父类的，一个是自己的：
成员函数同名的隐藏：
//成员函数同名 -- 两个func的关系是隐藏
class A
{
public:
void func()
{
cout << "A::func()" << endl;
}
};
class B : public A
{
public:
void func()
{
cout << "B::func()" << endl;
}
};
int main()
{
B b;
b.func();
//指定作用域去调用
b.A::func();
return 0;
}
特殊情况比较：
class A
{
public:
void fun()
{
cout << "A::func()" << endl;
}
};
class B : public A
{
public:
void fun(int i)
{
cout << "B::func()" << endl;
}
};
int main()
{
B b;
//b.func();//编译报错 -- 因为b隐藏了父类的，只认识func(int i)，不传参数就报错了
b.A::func();
b.func(1);
return 0;
}
注意：
- A::fun 和 B::fun 的关系是 -> 隐藏
- 在不同的作用域中，函数名可以相同，例如：vector的push_back和list的push_back，没有任何关系，虽然同名但是在不同的作用域，函数名的修饰规则还会加入所在的域
- 函数重载要求在同一个作用域，在不同的作用域不是重载
所以如果是成员函数的隐藏，只需要函数名相同就构成了隐藏
建议：
在继承里面，成员变量和成员函数最好都不要定义成同名的。
扫一扫
940
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
