一 理解继承
继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段,它允许程序员在保持原有类特性的基础上进行扩展,增加功能,这样产生新的类,称派生类。继承呈现了面向对象程序设计的层次结构,体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用,继承是类设计层次的复用。
using namespace std;
class person {
public:
person() {
cin >>_name >> _age >> _sex;
}
protected:
string _name;
int _age;
string _sex;
};
class teacher :public person {
public:
teacher() {
cin >> _id;
}
void print() {
cout << _name << ' ' << _age << ' ' << _sex << ' ' << _id << endl;
}
protected:
int _id;
};
int main() {
teacher p1;
p1.print();
return 0;
}
teacher 是一个 person 满足继承关系 ,继承了person类的所有成员,提高了代码的复用性。
继承关系中 person叫作父类或者基类,teacher 叫作person的派生类
二 继承方式
继承方式有三种: public 继承,protect 继承 ,protected 保护,private 私有
他们于类成员的访问限定符虽然关键字一样,意义却不一样
有三个要点
1.基类的private成员无论以什么继承方式来继承,都在派生类中不可见。
"不可见的含义"
i.虽然被继承 ,但是无论类外还是类里都不可访问
ii.被继承下来的“可见”函数,仍然可以访问
using namespace std;
class person {
public:
person():_name("张三"),_sex("男"),_age(19) { ; }
void print() {
cout << _name << ' ' << _sex << ' ' << _age << ' ' << endl;
}
private:
string _name;
int _age;
string _sex;
};
class teacher :public person {
;
};
int main() {
teacher p1;
p1.print();//可以访问被继承下来的私有成员
return 0;
}
2.除了基类的private成员外 继承结果取继承方式 与 基类中访问限定符的较小权限
3. protect 成员 与 private 成员 一样 只能在类里访问,在类外不可以访问,可以推测出,protect这个关键字就是为了继承而设计的。
三 特殊成员
1.友元
友元不可被继承
2.静态成员
由于静态成员储存在静态区:
静态成员可以被继承 继承规则遵循普通变量 ,但一个变量名只能对应一个,即所有派生类继承下来的静态成员和基类的那个静态成员是 同一个地址下的同一个变量 。
四 继承中的作用域
1.子类可以直接访问继承下来的父类成员(除私有不可见)
2.子类成员与继承下来的父类成员有独立的作用域,若成员名相同 不会报错,而是屏蔽父类成员的直接访问,这种情况叫作“隐藏”或“重定义”,访问需指定作用域为父类名,注意基类和派生类的成员函数只要同名就会触发隐藏,不能构成重载!
#include<iostream>
#include<string>
using namespace std;
class person {
public:
protected:
int _age;
};
class teacher : public person {
public:
teacher() :_age(19) {
person::_age=_age;
}
int _age;
};
五 切片规则
继承中的特殊语法 ,即 子类对象/子类地址可以直接赋值给父类类型的对象和引用,/指针
也叫做切片(切割)
1.被赋值后的父类指针 指向 子类中继承下来的父类部分
2.被赋值后的父类引用 为 子类中继承下来的父类部分 的引用
3.赋值的父类对象会调用赋值重载(传参时二次切片)后与 被子类中的父类部分赋值
teacher t1;
//切片
person p1 = t1;
person& rp = t1;
person* pp = &t1;
p1.print();
rp.print();
pp->print();
四 默认成员函数
派生类除了析构,都满足“先父后子”的规则,析构相反。
1.在实例化时必须先自动调用 父类的"默认构造函数" 构造继承下来的父类成员,再执行子类的构造函数,若父类没有默认构造函数,则需在子类初始化列表中 显示调用。
2.在析构 结束后 自动调用 父类的析构函数。
using namespace std;
class person {
public:
person(const char* name,const char* sex,int age):_name(name),_sex(sex),_age(age) { ; }
void print() {
cout << _name << ' ' << _sex << ' ' << _age << ' ' << endl;
}
private:
string _name;
int _age;
string _sex;
};
class teacher :public person {
public:
teacher():person("张三","男",19) {//满足初始化子类前,必须先初始化好父类成员的原则,故不能在函数体内调用父类构造函数。
;
}
~teacher() {//先自动调用了person的析构
;
}
};
int main() {
teacher p1;
p1.print();//可以访问被继承下来的私有成员
return 0;
}
3.在子类赋值重载之前 自动调用 父类的赋值重载(传参时切片)处理继承下来的父类部分
4.在子类的拷贝构造前 自动调用 父类的拷贝构造 (传参时切片)处理继承下来的父类部分
五 菱形继承问题
这种情况叫作菱形继承
#include<iostream>
#include<string>
using namespace std;
class person {
public:
person(int age) : _age(age) { ; }
private:
int _age;
};
class teacher : public person {
public:
teacher() :person( 19) {;}
};
class student : public person {
public:
student() :person(17) { ; }
};
class worker : public teacher, public student {
public:
worker() :_age(20){ ; }
int _age;
};
int main() {
worker w1;
return 0;
}
普通菱形继承带来的两个问题
1.空间浪费
age年龄作为人的属性存了三份
2.二义性
这时候访问成员必须要带作用域,存在歧义。
虚继承和虚基类
为解决菱形继承带来的问题,C++引入了虚基类,可以在间接继承共同基类时,只保留一份基类成员。
声明方式
在继承方式前加上 virtual 关键字
虚基类不是在声明基类时声明,而是在声明派生类,通过指定虚拟继承方式声明的。
虚基类的初始化与存储位置
虚基类只初始化一次,储存在最后继承的子类中,由最后继承的子类初始化。
虚拟继承方式
子类的成员变为
虚基表指针+子类成员
或
虚基表指针+子类成员+虚基类成员,有没有虚基类成员取决于此类是否是最后的派生类,虚基表里存的虚基类的成员与子类地址的偏移量
3.一个类可以有多个虚基类他们连续存储 它的虚基表指针指向第一个虚基类的偏移量
#include<iostream>
#include<string>
using namespace std;
class person {
public:
person(int age) : _age(age) { ; }
private:
int _age;
};
class teacher : virtual public person {
public:
teacher(int age) :person(age) { ; }
};
class student : virtual public person {
public:
student(int age) :person(age) { ; }
};
class worker :virtual public teacher,virtual public student {
public:
worker() :_age(20),teacher(19),student(20),person(30){ ; }
int _age;
};
1.worker同时是 person teacher student 三个类共同的最后派生类 所以worker的虚基表指针指向第一个虚基类的偏移量
2.而 teacher 的不是其父类person的最后派生类,所以它里面没有虚基类,只有虚基表指针,指向person的偏移量
student同理
最合理解决方法
只让teacher和 student使用虚继承
class worker :public teacher, public student {
public:
worker() :_age(20),teacher(19),student(20),person(30){ ; }
int _age;
};
这样worker只是 person的最后派生类 person 是worker的虚基类,其他不变。
相比全部使用虚拟继承的方式 少了一个瞎折腾的虚基表指针,提高效率 节省空间。