•          需要注意的是，我们派生类的继承类型并不影响基类相关成员使用以及派生类成员使用。影响的是我们站在派生类外部再去通过派生类的接口访问它们，这个时候接口体现出的就是继承中的基类与派生类中添加的最小权限；
•         另外，别忘了基类对派生类来说会有点见外，愿意分享private成员继承给派生类，但是派生类却无法使用（就像那谁说的“钱是给……看的，不是给……花的”）。

•         相当来说派生类的限制访问域继承，在一定程度上来讲，由于接口性质的改变，变相是对于被继承成员的访问域的限制和缩小。

😎基类和派生类之间的转换：（赋值兼容转换）

代码展示： （public继承派生类赋值给基类指针）

class Person
{
protected:
	string _name; // 姓名
	string _sex; // 性别
	int _age; // 年龄
};

class Student : public Person
{
public:
	int _No; // 学号
};

int main()
{
	Student sobj;

	//1.派生类对象可以赋值给基类的指针 / 引用
	Person* pp = &sobj;
	Person& rp = sobj;
}

• 子类可以赋值构造父类，父类不可以赋值构造子类。

🤨隐藏规则：

1. 在继承体系中基类和派生类都有独立的作用域。
2. 派生类和基类中有同名成员，派生类成员将屏蔽基类同名成员的直接访问，这种情况叫隐藏（派生类成员函数中被隐藏的基类成员，可以使用 基类::基类成员 显示访问）。   
3. 需要注意都是如果是成员函数的隐藏，只需要函数名相同就构成隐藏
4. 注意在实际中在继承体系里面最好不要定义同名的成员~ 

• 🫡如果派生类和基类中拥有相同名称的成员：
•         派生类中使用同名成员时，编译器会优先调用派生类中的值就像我们函数中的临时变量一样，会先调用函数的，再调用全局的！
•         如果一定要在派生类中去调用基类中的同名成员！我们要指定定义域，基类::同名成员！

class Person_2
{
protected:
	string _name = "小李子"; // 姓名
    int _num = 111; // 身份证号
};

class Student_2 : public Person_2
{
public:
    void Print()
    {
        cout << " 姓名:" << _name << endl;
        cout << " 学号:" << _num << endl;		// 隐藏
        cout << " 基类 " << Person_2::_num << endl;
    }
protected:
    int _num = 999; // 学号
};

int main()
{
	Student_2 s;
	s.Print();

    return 0;
}

🫡A和B类中的两个func构成什么关系（）
A. 重载 B. 隐藏 C.没关系
🫡🫡下⾯程序的编译运⾏结果是什么（）
A. 编译报错 B. 运⾏报错 C. 正常运⾏
class A
{
    public:
        void fun()
        {
            cout << "func()" << endl;
        }
};
class B : public A
{
    public:
        void fun(int i)
        {
            cout << "func(int i)" <<i<<endl;
        }
};

int main()
{
    B b;
    b.fun(10);
    b.fun();
    return 0;
}

class A
{
    public:
        void fun()
        {
            cout << "func()" << endl;
        }
};
class B : public A
{
    public:
        void fun(int i)
        {
            cout << "func(int i)" <<i<<endl;
        }
};

int main()
{
    B b;
    b.fun(10);
    b.A::fun();
    return 0;
}

派生类中的默认成员函数：

前情提要：各个默认成员函数默认生成规则：

• 默认构造：写了任意构造 → 不生成
• 析构：写了析构 → 不生成
• 拷贝构造：写拷贝 / 移动相关 → 不生成
• 拷贝赋值：写拷贝 / 移动 + 有 const / 引用 → 不生成
• 移动构造：写拷贝 / 析构 / 赋值 任意 → 不生成
• 移动赋值：写拷贝 / 析构 / 赋值 + 有 const / 引用 → 不生成

• 当我们依赖系统默认的构造函数机制时：

• 在父类不存在默认构造函数时派生类成员的初始化顺序：

#include<iostream>

using namespace std;

class Person
{
public:
	Person(const char* name = "peter")
        : _name(name)
	{
        cout << "Person()" << endl;
	}
	//这个函数是派生类进行兼容类型转换时调用的
	Person(const Person& p)
		: _name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}
	
	Person& operator=(const Person& p)
	{
		cout << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;
	
		return *this;
	}
	
	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name; // 姓名
};

// 派生类
class Student : public Person
{
public:

protected:
	string _address;
	int _num; //学号
};

int main()
{
	Student s;
	return 0;
}

// 派生类
class Student : public Person
{
public:
	Student(const char* name, string address, int num)
		:_name(name),                     ←—————————————————————— ❌
		_address(address),
		_num(num)
	{

	}
protected:
	string _address;
    int _num; //学号
};

• 当我们依赖系统默认的拷贝构造函数机制时：

• 思考：我们调用派生类的拷贝构造，那么其中基类的拷贝构造所需要的参数，派生类对象怎么才能提供呢？

// 派生类
class Student : public Person
{
public:
    Student(const char* name, string address, int num)
        :Person(name),
        _address(address),
        _num(num)
    {
    
    }
    赋值兼容转换——切片切割出父类的成员，从而合理的传给父类。       
    Student(const Student& s)
        :Person(s),
        _address(s._address),
        _num(s._num)
    {
    
    }
protected:
	string _address;	
    int _num; //学号
};

int main()
{
	Student s("baby", "baby", 2);
    return 0;
}

• 幽默实现：由于隐藏的缘故，调用父类operator=函数，误调用到了自己。

	Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			operator=(s);
			_address = s._address;
			_num = s._num;
		}
		return *this;
	}

• 正确实现：

	Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			Person::operator=(s);
			_address = s._address;
			_num = s._num;
		}
		return *this;
	}

😗派生类析构函数：

• 错误函数：函数再次调用到了自己

	~Student()
	{
        ~Person();
	}

        在多态的一些场景这中构函数需要构成重写，重写的条件之一就是函数名相同。那么编译器会对析构函数名进行特殊处理，处理成destructor(),所以基类析构函数不加virtual的情况下，派生类析构函数和基类析构函数构成隐藏关系。

• 版本一

~Student() { }

• 版本二

• 我们观察到这里的一个对象调用了两次析构：

😉多继承与菱形继承问题：

• 例如下方我们的Person需要在Assitant中自行构造，虽然Person在Student和Teacher中也进行了构造，但并不会影响到我们Assitant中的_Person的值。

class Person
{
public:
	Person(int a)
		:_Person(a)
	{

	}
	int _Person;
};

class Student : virtual public Person
{
public:
	Student(int name, int num)
		:Person(name),
		_Student(num)
	{

	}
	int _Student;
};

class Teacher : virtual public  Person
{
public:
	Teacher(int name, int num)
		:Person(name),
		_teacher(num)
	{

	}
	int _teacher;
};

class Assitant : public Student, public Teacher
{
public:
	Assitant(int a, int b, int c)
		:Student(a, c),
		Teacher(a, b),
		Person(c)
	{

	}
	int _Assitant;
};

int main()
{
	Assitant At(1, 2, 3);
	cout << At._Person << endl;
	//At.Teacher::_Person = 2;
	//At.Student::_Person = 2;
	//At._Person = 1;
	return 0;
}

I / O流的库是标准的菱形继承：

•         白箱：关注内部结构与工作原理。

•         黑箱：关注外部功能与输入输出。

• 在新类中包含现有类的对象作为成员变量
• 通过调用成员对象的方法来实现功能复用
• 建立的是"has-a"（拥有）关系

#include <iostream>
#include <string>

// 旧的类 - 引擎
class Engine {
private:
    std::string type;
    
public:
    Engine(const std::string& engineType) : type(engineType) {}
    
    void start() {
        std::cout << type << " 引擎启动...嗡嗡嗡!" << std::endl;
    }
    
    void stop() {
        std::cout << type << " 引擎停止" << std::endl;
    }
};

// 旧的类 - 车轮
class Wheel {
private:
    int size;
    
public:
    Wheel(int wheelSize) : size(wheelSize) {}
    
    void rotate() {
        std::cout << size << "寸车轮开始旋转" << std::endl;
    }
};

// 新类 - 汽车（通过组合复用旧类）
class Car {
private:
    Engine engine;        // 组合：拥有一个引擎
    Wheel wheels[4];      // 组合：拥有四个车轮
    std::string brand;
    
public:
    // 在构造函数中初始化成员对象
    Car(const std::string& carBrand, const std::string& engineType, int wheelSize)
        : brand(carBrand), engine(engineType) {
        
        // 初始化四个车轮
        for(int i = 0; i < 4; ++i) {
            wheels[i] = Wheel(wheelSize);
        }
    }
    
    void start() {
        std::cout << brand << " 汽车启动：" << std::endl;
        engine.start();      // 调用成员对象的方法
        for(int i = 0; i < 4; ++i) {
            wheels[i].rotate();  // 调用成员对象的方法
        }
        std::cout << brand << " 开始行驶!" << std::endl;
    }
    
    void stop() {
        std::cout << brand << " 汽车停止：" << std::endl;
        engine.stop();
        std::cout << "汽车已停稳" << std::endl;
    }
};

// 使用示例
int main() {
    // 创建汽车对象，自动组合了引擎和车轮
    Car myCar("宝马", "V8", 18);
    Car yourCar("奥迪", "V6", 17);
    
    myCar.start();
    std::cout << "---" << std::endl;
    yourCar.start();
    std::cout << "---" << std::endl;
    myCar.stop();
    
    return 0;
}

😜思考：

为什么说继承会破坏封装：

实现一个不能被继承的类：

#include<iostream>
using namespace std;

class Base final
{
public:
    void func5() { cout << "Base::func5" << endl; }
protected:
    int a = 1;
private:
    //C98的方法
    /*Base() {}*/
};

//class Driver : public Base  ❌编译器报错
//{
//
//};

int main()
{
    return 0;
}