【C++进阶学习】第一讲——继承（下）---深入挖掘继承的奥秘
目录
1.隐藏
1.1隐藏的概念
1.2隐藏的两种方式
2.继承与友元
3、继承与静态成员
4.单继承和多继承
4.1单继承
4.2多继承
5.菱形继承
问题1：冗余性
问题2：二义性
6.虚拟继承
7.总结
1.隐藏
1.1隐藏的概念
在 C++ 中，继承是一种机制，使得子类可以继承父类的成员变量和成员函数。然而，当子类中出现和父类同名的成员变量或成员函数时，会发生一种特殊的现象，即隐藏。
隐藏是指：如果子类中出现了与父类同名的成员变量或成员函数，则子类中的这个成员会“隐藏”父类中的同名成员，使得父类中的同名成员在子类中不可见。
1.2隐藏的两种方式
成员变量隐藏：顾名思义是类中的成员函数被隐藏了
class Parent {
public:
int W;
};
class Child : public Parent {
public:
int W; // 此处的 W 会隐藏 Parent 中的 W
};
int main() {
Child c;
c.W = 10; // 此处修改的是 Child 中的 W，而不是 Parent 中的 W
return 0;
}成员函数隐藏：和成员变量隐藏一样，成员函数被隐藏
class Parent {
public:
void func() {
cout << "Parent::func()" << endl;
}
};
class Child : public Parent {
public:
void func() {
cout << "Child::func()" << endl;
}
};
int main() {
Child c;
c.func(); // 此处调用的是 Child 中的 func()，而不是 Parent 中的 func()
return 0;
}2.继承与友元
在C++中，友元关系不能被继承，因为友元关系是独立于类定义的，并不是类的成员。因此，如果在父类中声明了一个友元函数或友元类，子类无法继承这种关系。
class Student;
class Person
{
public:
friend void Display(const Person& p, const Student& s);
protected:
string _name; //
姓名
};
class Student : public Person
{
protected:
int _stuNum; //
学号
};
void Display(const Person& p, const Student& s)
{
cout << p._name << endl;
cout << s._stuNum << endl;
}
int main()
{
Person p;
Student s;
//
编译报错：
error C2248: “Student::_stuNum”:
⽆法访问
protected
成员
//
解决⽅案：
Display
也变成
Student
的友元即可
Display(p, s);
return 03、继承与静态成员
在 C++ 中，类可以包含静态成员变量和静态成员函数，其中静态成员变量属于类本身，而不是类的某个对象，因此它们可以在不创建类对象的情况下被访问。
当一个类继承另一个类时，子类可以继承其父类的静态成员，并且可以在子类中重新定义这些静态成员。在这种情况下，子类和父类各自拥有自己的静态成员变量，它们之间没有任何关系。
#include<iostream>
using namespace std;
class Parent {
public:
static int a;
};
int Parent::a = 1000; //静态成员的定义只能在类外进行
class Child : public Parent {
public:
static int a; //类中只能声明静态成员
};
int Child::a = 2000; //静态成员的定义只能在类外进行
int main() {
cout << Parent::a << endl; //输出1000
cout << Child::a << endl; //输出2000
return 0;
}此外，静态成员函数也可以继承，并且可以在子类中重新定义。在子类中重新定义父类的静态成员函数时，子类的静态成员函数会隐藏父类的静态成员函数，因此如果在子类中需要调用父类的静态成员函数，需要使用作用域运算符 :: 来显式地调用。
4.单继承和多继承
4.1单继承
单继承是指一个类只能继承自一个基类。这意味着派生类只能有一个直接的基类。
如下代码所示：
class Base {
public:
void baseFunction() {
cout << "Base function" << endl;
}
};
class Derived : public Base {
public:
void derivedFunction() {
cout << "Derived function" << endl;
}
};4.2多继承
多继承允许一个类继承自多个基类。这意味着派生类可以有多个直接的基类。
class Base1 {
public:
void base1Function() {
cout << "Base1 function" << endl;
}
};
class Base2 {
public:
void base2Function() {
cout << "Base2 function" << endl;
}
};
class Derived : public Base1, public Base2 {
public:
void derivedFunction() {
cout << "Derived function" << endl;
}
};5.菱形继承
C++中的菱形继承是指在类的继承关系中，存在两个或更多个直接或间接的基类，它们之间形成了一个类似菱形的结构。这种继承结构通常出现在多层继承中，当一个派生类同时从两个不同的基类继承到了同一个基类时，就可能导致问题。
问题1：冗余性
主要体现在代码的重复。在菱形继承中，派生类会继承两个基类的所有公共和私有成员。如果这些成员在两个基类中定义了相同的实现，那么在派生类中可能会有重复的代码，这不仅增加了代码量，还可能导致维护困难，因为需要在所有相关的实现中同步更新。
问题2：二义性
二义性是指在菱形继承的情况下，派生类可能会有两个或更多的基类提供了相同的函数或数据成员，这在调用时会导致编译器无法确定调用哪个版本。例如，如果基类A和B都有一个同名的函数，而在派生类中没有明确指定调用哪一个，就会产生二义性错误。
class Person
{
public :
string _name ; // 姓名
};
class Student : public Person
{
protected :
int _num ; //学号
};
class Teacher : public Person
{
protected :
int _id ; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected :
string _majorCourse ; // 主修课程
};
void Test ()
{
// 这样会有二义性无法明确知道访问的是哪一个
Assistant a ;
a._name = "peter";
// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
a.Student::_name = "xxx";
a.Teacher::_name = "yyy";
}6.虚拟继承
下面我们来讲解一种解决上面问题的方法——虚拟继承
虚继承是一种特殊的继承方式，用于解决菱形继承中的冗余性和二义性问题
class BaseClass {
public:
int var;
};
class LeftChild : public virtual BaseClass {
public:
// ...
};
class RightChild : public virtual BaseClass {
public:
// ...
};
class FinalChild : public LeftChild, public RightChild {
public:
// ...
};在上面的示例中，LeftChild 和 RightChild 都virtually继承自 BaseClass，这样在 FinalChild 继承 LeftChild 和 RightChild 时，就不会再继承 BaseClass 的两份副本，避免了冗余性问题。此时，BaseClass 的成员变量 var 在 FinalChild 中只有一份，并且不会发生二义性问题。
总之，C++ 通过虚继承解决了菱形继承中的冗余性和二义性问题，使得在使用继承时更加灵活和安全。
7.总结
以上是C++继承博主学习的全部内容，可能不全但是覆盖了继承的几乎知识点，后期主播会积极补充有关继承其他有关知识点，谢谢大家的关注和支持！
