【C++】继承|切片|菱形继承|虚继承

面向对象语言有三大特性：封装，继承，多态。

封装：

1:数据和方法放到一起，把想给访问定义成公有，不想给你访问定义成私有和保护。

2：一个类型放到另一个类型里面，通过typedef 成员函数调整，封装另一个全新的类型。

比如STL库中的vector,list等，都是将一系列函数封装到一起。

继承：

允许一个类（称为子类或派生类）获取另一个类（称为父类或基类）的属性和行为。通过继承，子类可以重用父类的代码，同时还可以扩展和修改这些代码以满足自己的需求。

多态：

指的是同一个方法调用在不同的对象上可以表现出不同的行为。（下篇讲）

继承的语法

// 基类定义
class Base {
    // 成员变量和方法
};

// 派生类定义
//class 新类的名字:继承方式 继承类的名字{};
class Derived : public Base {
    // 派生类可以添加新的成员或覆盖基类方法
};

继承体现的是一种代码的复用，将大家都会有的数据，整合到一起形成一个新的类，大家都可以共享，避免了数据的重复。

class Person
{
public:
	void Print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;

	}
protected:
	string _name = "MM";  //姓名
	int _age = 18;  //年龄
};

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

int main()
{
	Student s;
	cout << "Student:";
	s.Print();
	return 0;
}

访问控制

使用public, protected, private关键字来控制成员的访问级别。

public,和protected继承，子类都可以直接访问使用；

protected，只能在类中，public,没限制，private,不能直接访问；

public>protected>private

继承的总结

1.基类private成员无论以什么方式继承到派生类中都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
2.基类private成员在派生类中不能被访问，如果基类成员不想在派生类外直接被访问，但需要在派生类中访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
3.基类的私有成员在子类都是不可见；基类的其他成员在子类的访问方式就是访问限定符和继承方式中权限更小的那个（权限排序：public>protected>private）。
4.使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，但最好显式地写出继承方式。

总结：

如果父类内是public成员和protected成员的话，继承后会根据继承方式的改变而将权限变小

二.继承的作用域

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

例1:成员变量的隐藏

class Person	//基类
{
protected:
	string _name = "MM";
	int _num = 123456;//身份证号
};
class Student :public Person
{
public:
	void Print()
	{
		cout << "姓名:" << _name << endl;
		cout << "学号:" << _num << endl;
		cout << "身份证号:" << _num << endl;			//构成隐藏，显示的是派生类成员
		cout << "身份证号:" << Person::_num << endl;			//显示用指定域名方式找到父类的成员变量
	}
protected:
	int _num = 202469;//学号	//成员和基类构成隐藏 (同名)
};
int main()
{
	Student s;
	s.Print();
	return 0;
}

例2：成员函数的隐藏

class Base	//基类
{
public:
	void func()
	{
		cout << "Base::func()" << endl;
	}
};
class Derive :public Base
{
public:
	void func()		//满足同名，构成隐藏
	{
		cout << "Derive::func()" << endl;
	}
};

int main()
{
	Derive d;
	d.func();
	return 0;
}

下面这个，可以看到明明继承了父类，但是还是会报错，因为两个构成了隐藏(同名)

class Base	//基类
{
public:
	void func()
	{
		cout << "Base::func()" << endl;
	}
};
class Derive :public Base
{
public:

	void func(int i)		//  注意这里！！！满足同名，构成隐藏 
	{
		cout << "Derive::func()" << endl;
	}
};

int main()
{
	Derive d;
	d.func();
	return 0;
}

总的来说，是局部优先原则，在这个程序中就是，先在子类中查找，子类中没有才会去父类中查找，但是在子类中找到了函数名。在这里不构成重载，因为重载要在同一作用域

三.切片

切片：派生类对象可以赋值给基类的对象 / 基类的指针 / 基类的引用。

基类对象不能赋值给派生类对象。

基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。

class Base
{
protected:
	string _name;
	string _sex;
	int _age;
};

class Derive:public Base
{
public:
	int _id;
};

int main()
{
	Derive d;
	Base* b = &d;	//指针
	Base b1 = d;	//对象
	Base& b2 = d;	//引用
	return 0;
}

四. 派生类的默认成员函数

构造函数

编译器会默认先调用父类的构造函数，再调用子类的构造函数。

因为会先调用基类，所以先要确保父类的默认构有效(有效传参，全省，满足初始化)

class Base
{
public:
	Base()
	{
		cout << "Base()" << endl;
	}

};
class Derive:public Base
{
public:
	Derive()	//默认构造函数，先构造基类 再构造派生类
	{
		cout << "Derive()" << endl;
	}
};

int main()
{
	Derive d;
	return 0;
}

析构函数

析构函数和构造函数相反。

编译器默认先调用子类的析构函数，再调用父类的析构函数。

注：派生类析构会自动调用基类的析构；

切勿在派生类主动调用基类析构,

如果是指针类型，那么同一块区域被析构两次就会造成野指针的问题。

class Base
{
public:
	Base()
	{
		cout << "Base()" << endl;
	}
	~Base()	
	{
		cout << "~Base()" << endl;
	}

};
class Derive:public Base
{
public:
	Derive()	//默认构造函数，先构造基类 再构造派生类
	{
		cout << "Derive()" << endl;
	}
	~Derive()		//会自动调用基类析构
	{
		cout << "~Derive()" << endl;	
		//Base::~Base();
	}
};
int main()
{
	Derive d;
	return 0;
}

拷贝构造

子类中调用父类的拷贝构造时，直接传入子类对象即可，父类的拷贝构造会通过“切片”拿到父类的那一部分

class Person
{
public:
	Person(string name = "MM")	//缺省  保证基类有效默认构造
		:_name(name)	//初始化列表
	{
		cout << "name:" << _name << endl;
	}
protected:
	string _name;
};
class Studen :public Person
{
public:
	Studen(int age = 1)
		:_age(age)
	{
		cout << "age:" << _age << endl;
	}
	Studen(Studen& s)
		:Person(s)			//派生类对象s 通过切片拿到基类中的值,传给基类
		, _age(s._age)			//取派生类特有的值
	{
		cout << s._age <<" " << s._name << endl;
	}

protected:
	int _age;
};
int main()
{
	Studen s;
	Studen s1(s);
	return 0;
}

赋值运算符重载

子类的operator=必须要显式调用父类的operator=完成父类的赋值。

因为子类和父类的运算符，编译器默认给与了同一个名字，所以构成了隐藏，所以每次调用=这个赋值运算符都会一直调用子类，会造成循环，所以这里的赋值要直接修饰限定父类.

class Person
{
public:
	Person(string name = "MM")	//缺省  保证基类有效默认构造
		:_name(name)	//初始化列表
	{
		cout << "name:" << _name << endl;
	}
	Person& operator=(Person& p)
	{
		if (this != &p)
		{
			cout << "调用基类=" << endl;
			_name = p._name;
		}
		return *this;
	}
protected:
	string _name;
};
class Studen :public Person
{
public:
	Studen(string name, int age)
		:_age(age)
	{

	}
	Studen(Studen& s)	//拷贝
		:Person(s)
		,_age(s._age)
	{

	}
	Studen& operator=(Studen& s)
	{
		if (this != &s)	//判断是否自己给自己赋值
		{
			cout << "调用子类" << endl;
			Person::operator=(s); //先给基类赋值
			_age = s._age;
			_name = s._name;
		}
		return *this;
	}
protected:
	int _age;
};
int main()
{
	Studen s("MM",18);
	Studen s1(s);
	Studen s2("mm", 100);
	s = s2;	
	return 0;
}

五.单继承和多继承

单继承

一个子类只有一个直接父类的继承关系。

多继承

一个子类有两个或以上直接父类的继承关系。

菱形继承

有了多继承，自然就会出现菱形继承，菱形继承是多继承的一种特殊情况。

菱形继承内数据冗余和二义性问题

class A {
public:
	string name;
};
class B :public A {	//类B 里面有了份类A的成员变量
public:
	int age;
};
class C :public A {  //类C 里面有了份类A的成员变量
public:
	string sex;
};
class D :public B, public C {  //类D继承了B,C 不仅拥有了这两个基类特有的成员变量，
										//也有了基类自己继承的成员变量 这里有了两份类A的成员变量
public:
	int id;
};
int main()
{
	D d;
	d.name = "MM";
	d.age = 18;
	d.sex = "男";
	d.id = 666;
	return 0;
}

类B,C都继承了类A的name，所以D不知道继承B的name还是C中的name

这也就是引出了代码冗余和二义性的问题。

解决方式

加修饰限定，指定类域；

	d.C::name = "MM";

使用虚函数，在继承方式前加上virtual。(在腰间使用)

class B :virtual  public A {
public:
	int age;
};
class C :virtual public A {
public:
	string sex;
};

六.虚继承

C++中的虚继承是一种特殊的继承方式，用于解决多重继承中的菱形继承问题。

在菱形继承中，一个基类被两个或多个派生类继承，然后这些派生类又共同派生出一个最终类。如果不使用虚继承，最终类将包含多个基类的副本，这会导致数据冗余和不一致性问题。

虚继承通过在派生类中共享基类的单一实例来解决这个问题。这意味着所有通过虚继承得到的基类子对象在内存中只有一份拷贝，所有派生类共享这个拷贝。