1.继承的概念和定义继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用
通过继承，子类可以重用父类的代码，这有助于减少代码冗余和复杂性，并增加代码的可复用性
子类和父类是继承关系中的两个基本概念：
简单来说，父类是派生过程的起点，提供了基础的属性和方法，而子类是继承的结果，它可以扩展和定制继承来的属性和方法。通过这种方式，子类和父类形成了一种层次结构，允许更高层次的代码重用和泛化
例如下面的例子：
父类包含一些通用的属性，人名和年龄，派生类继承自父类但具有不同的额外特性或方法
class Person
{
public:
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
protected:
string _name = "jason"; // 姓名
int _age = 18; // 年龄
};
class Student : public Person
{
protected:
int _stuid; // 学号
};
class Teacher : public Person
{
protected:
int _jobid; // 工号
};继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了Student和Teacher复用了Person的成员。
下面我们使用监视窗口查看Student和Teacher对象，可以看到变量的复用。调用Print可以看到成员函数的复用
int main()
{
Student s;
Teacher t;
s.Print();
t.Print();
return 0;
}
继承的定义格式：
继承关系和访问限定符：
继承基类成员的访问方式变化类成员/继承方式 | public继承 | protected继承 | private继承 |
|---|---|---|---|
基类的public成员 | 派生类的public成员 | 派生类的protected成员 | 派生类的private成员 |
基类的protected成员 | 派生类的protected成员 | 派生类的protected成员 | 派生类的private成员 |
基类的private成员 | 在派生类中不可见 | 在派生类中不可见 | 在派生类中不可见 |
我们前面知道，类里面可以访问它的成员，但是private继承下，子类是无法访问父类的成员的
class Person
{
public:
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
protected:
string _name = "jason"; // 姓名
private:
int _age = 18; // 年龄
};我们这个类，拥有三个成员
class Student : public Person
{
Student()
{
_name = "peter";
}
protected:
int _stuid; // 学号
};在我们这个子类中，我们可以访问除了父类私有成员的其他成员，父类的私有成员父类自己可以用，子类不可以直接使用
但是可以间接使用，比如我用子类来调用上面的Print函数，
class Student : public Person
{
void Fun()
{
_name = "abc";
Print();
}
protected:
int _stuid; // 学号
};
class Student : protected Person
{
public:
void Fun()
{
_name = "abc";
Print();
}
protected:
int _stuid; // 学号
};公有的Print函数遇到protected继承变成保护类，无法外部直接调用：
保护是类外面不能访问，类里面还可以访问
在实际运用中一般使用都是
public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强
2.基类和派生类对象赋值转换class Person
{
protected:
string _name; // 姓名
string _sex;// 性别
int _age; // 年龄
};
class Student : public Person
{
public:
int _No; // 学号
};Student sobj;
// 1.子类对象可以赋值给父类对象/指针/引用
Person pobj = sobj;
Person* pp = &sobj;
Person& rp = sobj;每一个子类对象都是一个特殊的父类对象
当派生类对象被赋值给基类对象时会发生。在切片过程中，派生类对象的部分（通常是额外添加的成员变量和方法）会被忽略，只有基类中定义的部分会被复制到基类对象中。因此，派生类特有的成员变量和方法不会出现在基类对象中，就像它们被“切掉”了一样
在代码中：
class Student : public Person
{
public:
int _No; // 学号
};
void Test()
{
Student sobj;
// 1.子类对象可以赋值给父类对象/指针/引用
Person pobj = sobj; // 切片发生在这里
Person* pp = &sobj; // 没有切片，因为 pp 指向的是一个 Student 对象
Person& rp = sobj; // 没有切片，因为 rp 引用的是一个 Student 对象
}Person pobj = sobj; 中，由于 pobj 是 Person 类型的对象，sobj（一个 Student 对象）被赋值给 pobj 时，Student 类特有的 _No 成员被“切掉”，不会体现在 pobj 中。因此，pobj 中无法反映出 sobj 的完整状态和行为。
Person* pp = &sobj; 中，pp 是指向 Person 类型的指针，但它实际上指向了派生类 Student 的对象 sobj，没有发生切片，因为指针指向的是完整的 Student 对象。
Person& rp = sobj; 中，rp 是一个引用 Person 类型，它引用了 sobj，同样没有发生切片，因为引用关联的是 sobj 的完整实体。
实际上，在行 Person& rp = sobj; 中，引用 rp 的确是 Person 类型，但它并不导致对象切片。引用实际上并不拥有它所引用的对象，而只是提供另一个名称来访问现有对象。因此，当我们通过基类引用访问派生类对象时，并没有创建新的对象，也没有丢失派生类的任何部分。
在这行代码中：
Person& rp = sobj;rp 实际上是对 sobj （它是一个 Student 类型的对象）的另一个访问方式。即使 rp 被声明为 Person 类型的引用，它实际引用的还是 sobj 的完整实体（包含 Person 部分和 Student 特有的部分）。但是，通过 rp 只能直接访问 sobj 中由 Person 定义的成员，Student 特有的成员（如 _No）不可以通过 rp 直接访问，除非进行了适当的强制转换
例子：
Person& rp = sobj;
rp._name = "Name"; // 可以访问，因为_name是Person的成员
// rp._No = 123; // 错误！无法访问，因为_No是Student特有的成员，即使它实际上存在于sobj中即使我们通过基类引用或指针操作对象，派生类对象的完整信息（所有成员变量和函数）仍然都在内存中，没有丢失。使用引用和指针时不会发生切片
对象切片的问题仅在派生类对象被赋值给另一个基类类型的对象时才会发生，比如当派生类对象被传值给一个基类对象的函数参数，或者通过赋值构造一个新的基类对象。这时候派生类特有的信息实际上会被切割掉并不会出现在新的基类对象中。在使用引用或指针时，这种情况并不会发生
dynamic_cast 来进行识别后进行安全转换3.继承中的作用域class Person
{
protected:
string _name = "a"; // 姓名
int _num = 111; // 身份证号
};
class Student : public Person
{
public:
void Print()
{
cout << " 姓名:" << _name << endl;
cout << " 身份证号:" << Person::_num << endl;
cout << " 学号:" << _num << endl;
}
protected:
int _num = 999; // 学号
};
void Test()
{
Student s1;
s1.Print();
};这段代码展示了成员隐藏，以及如何在派生类中访问基类的被隐藏成员的概念。
Student 类中，成员函数 Print 试图访问名称为 _num 的成员变量。由于派生类中存在同名成员，派生类的 _num 会隐藏基类的同名成员。
Print 方法中使用 Person::_num 来访问基类 Person 中的 _num 成员。
输出结果将是：
姓名: a
身份证号: 111
学号: 999class A
{
public:
void fun()
{
cout << "func()" << endl;
}
};
class B : public A
{
public:
void fun(int i)
{
fun();
cout << "func(int i)->" << i << endl;
}
};B中的fun和A中的fun 不是构成重载，因为不是在同一作用域 B中的fun和A中的fun 构成隐藏，成员函数满足函数名相同就构成隐藏
class B : public A
{
public:
void fun(int i) // 接受一个整型参数
{
fun(); // 编译器将会提示错误：找不到不带参数的 "fun" 函数。
cout << "func(int i)->" << i << endl;
}
};在这个代码中，试图调用基类 A 的 fun 函数。然而，由于派生类 B 提供了一个参数不同的版本 fun(int)，所以基类 A 中的 fun 函数在派生类 B 的作用域中被隐藏了。C++ 规则规定，如果派生类提供了和基类同名的函数，基类中同名的函数在派生类的作用域就不再可见了
因此，在 B 类的成员函数 fun(int) 中，调用 fun() 试图无参数调用被隐藏的同名函数会无法编译，因为编译器认为我们试图调用 fun(int) 这个版本，但没有提供参数，导致参数不匹配
修复
为了调用基类 A 的 fun 函数，我们必须显式地使用作用域解析运算符 :: 来指明我们想要调用的函数属于基类作用域：
class B : public A
{
public:
void fun(int i)
{
A::fun(); // 正确：调用基类 `A` 中的 `fun`
cout << "func(int i)->" << i << endl;
}
};这样，当我们在类 B 的 fun(int i) 函数中调用 A::fun() 时，它将成功地调用基类 A 无参数的 fun 函数，然后输出整型参数 i 的值。
如果你希望在派生类中保留对基类中同名函数的访问能力（不希望隐藏），可以使用 using 声明在派生类中导入基类中的函数：
class B : public A
{
public:
using A::fun;
void fun(int i)
{
fun(); // 正确：由于 "using A::fun;"，此处调用的是基类 `A` 中的 `fun`
cout << "func(int i)->" << i << endl;
}
};在实际编程中，为了避免混淆，通常不建议在派生类中使用与基类成员同名的变量。
本节内容到此结束！感谢大家阅读！
