继承的概念与定义
假设我们要写一个学校的管理系统,那么我们首先需要确定一些角色:
学生,老师,宿管,保安…这样我们就需要为每个角色实现一个类,并在类中确定其属性.但是我们发现,无论是哪个角色,都会有:姓名,年龄,电话等通用的属性.所以我们可以定义一个类叫做person,让角色的类去继承这个person类.从这里我们可以看出,继承本质完成的是类与类之间的复用.
class Person
{
public:
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
protected:
string _name;//姓名
int _age;//年龄
};
class Student : public Person
{
protected:
int _stdid;//学号
};
可以看到我们的代码中写道
class Student : public Person
其中Student是子类(派生类),Person是父类(基类).

并且我们用public规定了继承方式,实际上三种访问限定符都可以作为继承方式的规定,规则如下

我们可以发现,无论是什么方式的继承,父类的私有成员在派生类中都是不可见的,所以如果这个成员需要被子类使用,就不能写成private,而是protected.
NOTE
实际上面的表格我们进行一下总结会发现,除了基类的私有成员在子类都是不可见,基类的其他成员在子类的访问方式=Min(成员在基类的访问限定符,继承方式),
public > protected > private。比如:父类中的成员是
public的,但是在子类是用protected进行继承,那么最终父类成员就是protected的.
对于继承,class的默认继承方式是private,而struct的默认继承是public,在实际的场景下,我们基本使用的都是public继承.
基类和派生类对象赋值转换
这个讨论的实际上是子类和父类对象的赋值兼容规则.
1.子类对象可以赋值给父类对象/指针/引用.
Student s;
Person p;
p = s;//直接赋值
Person* ptr = &s;//指针赋值
Person& ref = p;//引用赋值
这个过程叫做切片/切割.对于派生类来说,一部分是继承的父类成员,一部分是自己的成员,所以赋值给父类实际上就是把自己的那部分丢掉.这个过程就像是在进行切片,如果是指针赋值,实际上对于父类来说,它也只能看到属于自己类的那个部分,这也类似于切片


那么反过来可以吗?不行,原因是父对象缺少了子对象的一部分成员.但是引用和指针有的时候是可以的.但是需要强转,并且要求父类的指针指向子类对象,后面多态的时候会详细说明
Student* sptr = (Student*)&p;//指针赋值
Student& ref = p;//引用赋值
继承中的作用域
在继承当中,基类和派生类都有独立的作用域,这就意味着,父类和子类可以有同名的成员.那么在访问的时候,访问的到底是哪一个类?答案是遵循就近原则,在调用方法的时候优先在该方法自己的类中寻找.
class Person
{
public:
protected:
string _name="peter";
int _age=0;
};
class Student : public Person
{
public:
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
protected:
int _stdid;//学号
int _age=999;
};
此时调用Print打印的age为999,说明访问的是子类的age.此时称为:子类的成员隐藏(或者重定义)了父类的成员.如果一定要访问父类的,指定作用域即可
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << Person::_age << endl;
}
如果父类和子类都有Print这个函数,那么子类也会把父类的函数隐藏.
class A {
public:
void fun()
{
cout << "fun" << endl;
}
};
class B :public A
{
void fun(int i)
{
cout << "fun" << i << end;
}
};
只要函数名相同就会构成隐藏,与其他无关,这里B的fun也能隐藏A的fun.
派生类的默认成员函数
对于派生类来说,它本质也是一个类,是类就会有类和对象.
构造函数
首先是构造函数和析构函数,对于派生类来说,它由两个部分组成,父类的部分和自己的部分,在进行构造的时候,父类的部分会调用父类的构造函数进行初始化,派生类的部分调用派生类的部分进行初始化.
class Person
{
public:
Person(const char* name)
{
cout << "Person()" << endl;
}
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
protected:
string _name="peter";
int _age=999;
};
class Student : public Person
{
public:
Student(const char* name,int id)
:Person(name),_stdid(id)
{
cout << "Student()" << endl;
}
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << Person::_age << endl;
}
protected:
int _stdid;//学号
int _age=0;
};
对于派生类来说,它并不能直接初始化父类,而是必须在派生类的构造函数去调用父类的构造函数进行初始化.
class Person
{
public:
Person(const char* name="peter",int age=0)
:_name(name),_age(age)
{
}
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
protected:
string _name;
int _age;
};
class Student : public Person
{
public:
Student(const char* name="peter", int id = 00001)
:Person(name),_stdid(id)
{
}
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
protected:
int _stdid;//学号
};
对于拷贝构造,如果我们不写就会调用编译器自己生成的拷贝构造函数,这个函数会去调用父类的拷贝构造.如果要自己写,我们原来的写法是
Student(const Student& s)
:_name(s._name), _stdid(s._stdid)
{
}
但是发现会报错,原因是,父类对象不能自己去初始化,只能调用父类的拷贝构造,但是调用父类的拷贝构造就需要父类的成员,这应该怎么获取?
Student(const Student& s)
:Person(s), _stdid(s._stdid)
{
}
实际上直接传子类就可以,原因是前面讲过基类和派生类的赋值规则,将子类传给父类会自动进行切割,只保留父类的部分.
那么赋值和拷贝构造类似,在赋值过程中父类部分需要单独调用父类的赋值,子类则自己完成赋值
Student& operator=(const Student& s)
{
if (this != &s)
{
Person::operator=(s);
_stdid = s._stdid;
}
return *this;
}
注意这里一定要指定作用域是Person类的作用域,不然会默认调用子类的operator=导致死递归.
析构函数
派生类析构的时候会调用父类函数的析构函数.但是我们在写的时候发现个问题
~Student()
{
~Person();
cout << "~Student()" << endl;
}

原因是:子类和父类的析构函数会构成隐藏,因为编译器会将析构函数统一处理成destructor,这样的处理和多态有关.所以为了能够调用,我们也要指定作用域
~Student()
{
Person::~Person();
cout << "~Student()" << endl;
}

但是这是不是哪里不对劲,我创建一个Student对象,结构出现了两个~Person,说明多了一次析构,那么应该去除哪一个?答案是第一个,那么我们来分析一下这个析构是怎么产生的
int main()
{
Student s("jack",0002);
s.Print();
return 0;
}
由于系统是一个栈,所以定义的时候满足LIFO,我构造的时候是先调用父类构造,再构造子类,那么析构的时候就应该先析构子类,再析构父类.所以我们这么写的时候
~Student()
{
Person::~Person();
cout << "~Student()" << endl;
}
实际上是在子类进行析构过程中又调了一次父类析构,导致多了一次.
~Student()
{
cout << "~Student()" << endl;
}
所以说,析构函数并不需要我们进行显式调用,而是会自动调用.因为这样才能保证先析构子类,再析构父类,以满足栈的结构特征.

补充:如何设计一个不能被继承的类?只要让它在继承的时候不能成功构造父类即可,所以我们把构造函数私有化.这样子类在调用父类的构造函数的时候就无法调用.
继承和友元
友元关系不能被继承,也就是说基类友元不能访问子类私有和保护成员.
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;
}
void main()
{
Person p;
Student s;
Display(p, s);
}

原因是Display是父类的友元,但不是子类的友元,所以不可以访问_stdNum,如果要正常使用,需要在Student类中声明Display的友元.
继承与静态成员
父类定义了static静态成员,则整个继承体系里面只有一个这样的成员,所有子类和成员共享这一个静态成员.
class A
{
public:
static int count;
};
int A::count = 0;
class B :public A
{
public:
};
int main()
{
B b;
B c;
b.count = 1;
c.count = 2;
cout << "b.count=" << b.count << endl;
cout <<"c.count=" << c.count;
return 0;
}

复杂的菱形继承及菱形虚拟继承
一个类直接继承一个父类类就叫做单继承,比如老师类继承人类

在日常生活中,一个人往往有多种角色,这就意味着这个人需要继承多个类.此时称为多继承,比如研究生助教既是老师又是学生.


对于多继承来说,子类的空间包含两个继承的父类和子类本身的内容,空间地址是连续的,如上图
多继承本身没有问题,但是一旦不注意就可能产生菱形继承

菱形继承存在的问题是:Student和Teacher都对Person进行了继承,所以我构造一个Assistant类就会构造出两个Person类,这样就导致了数据冗余和二义性(出现了两个Person,访问Person成员的时候不知道访问的哪一个).
为了解决这个问题,官方引入了一个关键字virtual,虚拟继承,在Student和Teacher继承Person时使用虚拟继承即可解决.

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; // 主修课程
};
那么虚继承是如何解决这个问题的?我们现来简化一些这个问题
class A
{
public:
int _a;
};
class B : public A
{
public:
int _b;
};
class C : public A
{
public:
int _c;
};
class D : public B, public C
{
public:
int _d;
};
那么我用D创建一个对象,这个对象是多大?答案是20,A里面一个int是4字节,B继承A,C继承A,加上自己的int对象,一共是8字节,D继承B和C,加上自己的int对象,一共是20字节,我们进入内存监视可以看到
int main()
{
D d;
d.B::_a = 1;
d.C::_a = 2;
d._b = 3;
d._c = 4;
d._d = 5;
return 0;
}

现在我们加上虚继承.重新计算它的大小
class A
{
public:
int _a;
};
class B : virtual public A
{
public:
int _b;
};
class C : virtual public A
{
public:
int _c;
};
class D : public B, public C
{
public:
int _d;
};

反而还变得更大了?

我们发现,a既没有放到b里面,也没有放到c里面,而是在最底下的一个公共区域.而b中多了一个00837b48,c中多了一个00837b54(由于是小端机,高位在高地址,所以要倒着读).这两个数据就像两个指针,我们去查看这两个地址

0c是12,14是20,刚好对应了那两个地址到a的偏移量.(从0x006FFBF8到a存放的位置0x006FFC0C差了20字节,从0x006FFC00到0x006FFC0C差了16字节).
有个问题,为什么不把偏移量直接放在存地址那个位置,反而要用指针去进行指向一块新的地址.我们发现存的地址有两个字节,这意味着这块空间不单单是存储偏移量的,还会有其他东西要存到这个空间里.存储偏移量的往往是一张表,这个表就被称为虚基表,a被称为虚基类.
还有一个问题,我虚继承前只有20个字节空间,现在虚继承后反而有24个字节,意义何在.实际上它比常规直接继承会多一点开销用于存储偏移量的地址.如果我们的成员变量不再是int类型,而是一个空间开销较大的类型,浪费的容量就远高于存储地址的开销了.
现在我将_a修改为`_a[1000]

可以看到,使用虚继承 节省了一个_a[1000]的开销,即4000字节,但是由于B类和C类共两个类虚继承了A类,所以需要两个地址去存储距离A的偏移量,共\(2\times 4=8\)字节,所以一共是\(4000+3*4(子类的成员)+8=4020\)
一句话总结一下:虚继承将虚基类存储到最下方,每个继承这个类的父类利用指针去虚基表中查找距离该类的偏移量.
尽管有解决方案,不到万不得已,不要将类的继承设计成菱形继承,多继承都尽量少用. 多继承可以说是C++语言的缺陷之一.
继承和组合
class A{}
class B:public A
{}
这样的关系就叫做继承
class A{};
class B{
A a;
}
这样的关系叫做组合,二者都完成了类层次上的复用.对于继承来说,它是一种白箱复用,父类对于子类基本上是透明的,这就导致继承一定程度上破坏了父类的封装,因为继承下来的父类在子类中是可以直接对父类成员进行访问的.而组合是一种黑箱复用,子类并不能直接访问父类,父类依然保存着它的封装.
组合的类耦合度更低,继承的类则是一种高耦合.

