[C++]——继承 & 深继承

最新推荐文章于 2024-07-13 19:27:27 发布

小小白啊_

最新推荐文章于 2024-07-13 19:27:27 发布

阅读量933

点赞数 11

分类专栏： C++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/weixin_50720782/article/details/140206970

版权

C++ 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、继承概念

(1)、定义

继承(inheritance)机制是面向对象程序设计使代码复用最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程，是类设计层次的复用。

(2)、继承方式

在继承方式中，不可见是指基类的私有成员虽然被继承到了派生类对象中，但是语法上限制派生类对象，不管在类里面还是类外面都不能去访问它

（3)、总结

基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式(成员在基类的访问限定符，继承方式)，public > protected>private。
使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，定义时，最好显示的写出继承方式。
在实际运用中一般使用都是public继承，几乎很少使用protetced / private继承，也不提倡使用protetced / private继承，因为protetced / private继承下来的成员都只能在派生一、继承概念类的类里面使用，实际中扩展维护性不强。

二、派生类和基类间的赋值

1.出现情况

（1）、派生类对象赋值给基类对象

派生类对象是可以赋值基类对象的，因为派生类对象本就存在基类成员。相反，基类成员就无法赋值给派生类成员，因为有些成员派生类有，而基类没有。

（2）、派生类对象的引用赋值给基类对象

派生类对象的引用赋值能够给基类对象，其中引用不许需要const，证明其赋值之间并没有发生隐式类型转换，产生临时对象。

（3）、派生类对象的指针赋值给基类对象

派生类对象的指针能够赋值给基类对象，这种情况与引用十分类似。

（4）、基类指针赋值给派生类指针

基类指针能够通过强转赋值给派生类指针，但是也可能造成越界访问。

2.总结

派生类对象可以赋值给基类的对象，基类的指针，基类的引用。
基类对象不能赋值给派生类对象。
基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI，dynamic_cast 来进行识别后进行安全转换。

三、继承的作用域

在继承体系中基类和派生类都有独立的作用域。子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用基类::基类成员显示访问）

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

派生类对象在调用构造函数时会先调用基类的构造函数，再调用派生类的构造函数。调用析构函数时会先调用派生类的析构函数，再调用基类的析构函数。
派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
编译器会对派生类与基类的析构函数名进行特殊处理，都会被处理成destrutor()，所以派生类与基类的析构函数构成隐藏关系。

五、继承中的友元与静态成员

（1）、继承中的友元

友元关系不能继承，也就是说父类的友元不是子类的友元，不能访问子类私有和保护成员。

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;
	Display(p, s);
	return 0;
}

（2）、继承中的静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员，静态成员被所有类对象包括起子类和子类的子类共享。无论派生出多少个子类，都只有一个static成员实例。

class Person
{
public:
	Person() 
    { 
        ++_count;
    }
	string _name; // 姓名
	static int _count; // 统计人的个数。
};
int Person::_count = 0;//静态成员初始化
class Student : public Person
{
protected:
	int _stuNum; // 学号
};
class Graduate : public Student
{
protected:
	string _seminarCourse; // 研究科目
};
int main()
{
	Person p;
	Student s;
	Graduate g;
	cout << &(p._name) << endl;
	cout << &(s._name) << endl;
	cout << &(g._name) << endl;
	cout << &(p._count) << endl;
	cout << &(s._count) << endl;
	cout << &(g._count) << endl;
	return 0;
}

总结：

非静态成员在不同基类与派生类中地址不同，这就说明他们在不同类是独立存在的。而非静态成员却恰恰相反，地址相同，证明基类与派生类都是用同一个静态成员。

六、菱形继承

（1）、菱形继承

1.单继承：一个子类只有一个直接父类的继承关系为单继承。

2.多继承：一个子类有两个或以上直接父类。

3.就是继承关系近似呈一个菱形形状

4.菱形继承会造成两个问题：数据冗余和二义性。

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";
}

（2）、菱形虚拟继承

class Person
{
public:
	string _name; // 姓名
};
//虚继承
class Student : virtual public Person
{
protected:
	int _num; //学号
};
//虚继承 
class Teacher : virtual public Person
{
protected:
	int _id; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; // 主修课程
};
void Test()
{
	Assistant a;
	 a._name = "peter"; 
}

八、虚拟继承原理

class A
{
public:
    int _a;
};
// class B : public A
class B : virtual public A
{
public:
    int _b;
};
// class C : public A
class C : virtual public A
{
public:
    int _c;
};
class D : public B, public C
{
public:
    int _d;
};
int main()
{
    D d;
    d.B::_a = 1;
    d.C::_a = 2;
    d._b = 3;
    d._c = 4;
    d._d = 5;
    return 0;
}

（1）.菱形继承

（2）.菱形虚拟继承

思考：

通过内存观察知道，原先数据冗余的部分存放成了一个地址，而数据冗余的a则存放在了最下面。那么这个地址又是什么呢？

总结：

这里地址指向的空间存放了一个数字，这个数字我们称为**偏移量。**通过这个偏移量我们就可以找到虚继承下来的共有数据的位置

通过上述分析我们明白在虚继承中，为了解决数据冗余和二义性的问题，派生类并不会直接存储基类，而是将基类放在一个公有的位置，然后在派生类中存放一个指向这公有位置偏移量的指针。这个指针我们将其称为虚基表指针，而这个偏移量存储位置我们将其称为虚基表。而每次通过派生类访问基类数据时，首先通过虚基表指针得到偏移量，然后再间接访问基类数据。