一.继承的概念和定义
1.1继承的概念
继承机制是面向对象程序设计使代码可以复用重要手段,它允许程序员在保持原有类特性的基础上扩展,增加功能。这样产生的新类称为派生类。继承体现了面向对象程序设计的层次结构,体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用,继承时类设计层次的复用。
#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
protected:
string _name = "heart_angke";//名字
int _age = 18; //年龄
};
/*继承后父类的Person的成员(成员函数+成员变量)都会变成子类的一部分。
这里体现了Student和Teacher服用了Person的成员。这里我们可以使用监视窗口
查看Student和Teacher的对象,可以看到变量的复用和成员函数的复用。*/
class Student : public Person
{
protected:
int _stuid; //学号
};
class Teacher : public Person
{
int _jobid; //工号
};
int main()
{
Student s;
Teacher t;
s.Print();
t.Print();
system("pause");
}
通过监视窗口我们可以看到s和t中有Person成员,而且在调用print函数时,都是调用的基类中的Print函数。
1.2 继承的定义
1.2.1 继承的定义格式
下面我们可以看到Person是父类,也称作基类。Student是子类,也称作派生类。
class Student : public Person
{
public:
int _stuid; //学号
int _major; //专业
};
1.2.2继承关系和访问限定符
继承方式:1、public继承。 2、protected继承。 3、private继承。
访问限定符:1、public访问。 2、protected访问。 3、private访问。
1.2.3继承基类成员访问方式的变化。
总结:
1、基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是继承到了派生类对象中,但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
2、基类private成员在派生类中是不能被访问的,如果基类成员不想在类外面被直接访问,但需要在派生类中能访问,就定义为protected。可以看出保护成员限定符是因为继承才出现的。
3、总结上面的表格我们可以发现。基类的私有成员在子类中都是不可见的,基类的其他成员在子类的访问方式==Min(成员在基类的访问限定符,继承方式),public>protected>private
4、使用关键字class时默认的继承方式是private,使用struct时默认的继承方式是public,不过最好显示的写出继承方式
5、在实际运用中一般都是public继承,几乎很少使用protected/private继承。
#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
void Print()
{
cout << _name << endl;
cout << _age << endl;
}
protected:
string _name;
private:
int _age;
};
//class Student : protected Person
//{
//protected:
// int _stnum;
//};
//class Student : public Person
//{
//protected:
// int _stnum;
//};
class Student : private Person
{
protected:
int _stnum;
};
int main()
{
Student s;
s.Print();
return 0;
}
1、使用私有继承时的报错:
error C2247: “Person::Print”不可访问,因为“Student”使用“private”从“Person”继承
2、使用公有继承可正常编译。
3、使用保护继承
error C2247: “Person::Print”不可访问,因为“Student”使用“protected”从“Person”继承
二、基类和派生类对象赋值转换
- 派生类对象可以赋值给基类的对象/基类的指针/基类的引用。这种方式叫做切片。
- 基类对象不能赋值给派生类对象
- 基类的指针可以通过强制类型转换赋值给派生类指针,但是必须是基类的指针是指向派生类对象时才是安全的。这里如果基类是多态类型,就会出现问题,这里的问题可以看我的另外一篇博客(C++:多态)
#include<iostream>
#include<string>
using namespace std;
class Person
{
protected:
string _name;
string _sex;
int _age;
};
class Student : public Person
{
public:
int _num;
};
int main()
{
//Student s;
子类对象可以赋值给父类对象/指针/应用
//Person p = s;
//Person* pp = &s;
//Person& rp = s;
//基类对象不能赋值给派生类对象
/*Student s;
Person p;
s = p;*/
//error C2679: 二进制“=”: 没有找到接受“Person”类型的右操作数的运算符(或没有可接受的转换)
//基类的指针可以通过强制类型转换赋值给派生类的指针。
//Student s;
//Person p;
//Person* pp = &s;
//Student* ps = (Student*)pp;//这种情况是可以转换的
//ps->_num = 10;
Person p;
Person* pp = &p;
Student* ps = (Student*)pp;//这种情况转换时虽然可以,但是会存在越界访问的问题
ps->_num = 10;
return 0;
}
总结:
1、在继承中,子类对象一定不可以给父类对象赋值。
2、指针和引用:父可以给子,但访问是会发生越界访问。
三、继承中的作用域
- 在继承体系中基类和派生类都有独立的作用域。
- 子类和父类中有同名成员,子类成员将屏蔽父类对同名成员的直接访问。这种情况较隐藏,也叫重定义。(在子类成员函数中,可以使用 基类::基类成员 显示访问)
- 需要注意的是如果是成员函数的隐藏,只需要函数名相同就构成影藏。访问基类的同名函数,要显示访问。
- 注意:在实际中,在继承体系中最好不要定义同名成员。
#include<iostream>
#include<string>
using namespace std;
class Person
{
protected:
string _name = "汪洋";
int _num = 111;
};
/*这里呢,Student的_num和Person的_num构成隐藏关系,可看出这样代码
虽然能执行,但是非常容易混淆*/
class Student : public Person
{
public:
void Print()
{
cout << "姓名:" << _name << endl;
cout << "身份证号:" << Person::_num << endl;
cout << "学号:" << _num << endl;
}
protected:
int _num = 999;
};
int main()
{
Student s;
s.Print();
system("pause");
return 0;
}
#include<iostream>
using namespace std;
/*
B中的fun和A中的fun不构成重载,因为不是在同一作用域
B中的fun和A中的fun构成隐藏,成员函数满足函数名相同就构成隐藏
*/
class A
{
public:
void fun()
{
cout << "func()" << endl;
}
};
class B : public A
{
public:
void fun(int i)
{
A::fun();
cout << "fun(int i)->" << i << endl;
}
};
int main()
{
B b;
b.fun(10);
system("pause");
return 0;
}
四、派生类的默认成员函数
6个默认成员函数,“默认”的意思就是我么不写,编译器会自动生成一个,那么在派生类中,这几个成员函数是如何产生的呢?
- 1 派生类的构造函数必须调用基类的构造函数初始化基类的一部分成员,如果基类没有默认的构造函数,则必须在派生类构造函数的初始化列表阶段显示调用。(类似创建匿名对象形式的显示调用)
- 2 派生类的拷贝构造函数必须调用基类的拷贝构造函数完成基类的拷贝初始化.(在初始化列表把子类对象传给父类,去显示的调用父类的拷贝构造)
- 3 派生类的operate=必须要调用基类的operate=完成基类的复制
- 4 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类的成员,因为这样才能保证派生类对 象先清理派生类成员在清理基类成员的顺序。(子类的析构和父类的析构成隐藏,在子类中会自动调用父类的析构先定义的后析构对象存在于栈上***交给程序员不能很好的保证析构的顺序)
- 5 派生类对象初始化先调用基类构造在调派生类构造
- 6 派生类对象析构清理,先调用派生类析构,在调基类的析构。
#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
Person(const char* name = "heart_angle")
:_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:
Student(const char* name, int num)
:Person(name)
,_num(num)
{
cout<<"Student()"<<endl;
}
Student(const Student& s)
:Person(s)
,_num(s._num)
{
cout<<"Student(const Student& s)"<<endl;
}
Student& operator=(const Student& s)
{
cout<<"Student& operator=(cosnt Student& s)"<<endl;
if(this != &s)
{
Person::operator =(s);
_num = s._num;
}
return *this;
}
~Student()
{
cout<<"~Student()"<<endl;
}
protected:
int _num;
};
int main()
{
Student s1("tom", 18);
Student s2(s1);
Student s3("rose", 17);
return 0;
}
上面的代码运行结果:
常见面试题:
实现一个不能被继承的类?
//c++98中构造函数私有,派生类中调不到基类的构造函数,无法继承
class NonInherit
{
public:
static NonInherit GetInstance()
{
return NonInherit();
}
private:
NonInherit();
};
//c++11给出了新的关键字
class NonInherit final
{};
五、继承与友元
友元关系不能继承,也就是说基类友元不能访问子类私有保护成员
#include<iostream>
#include<string>
using namespace std;
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;
}
int main()
{
Person p;
Student s;
Display(p,s);
return 0;
}
执行上面的代码,报错如下:
六、继承与静态成员
基类定义了static成员,则整个继承体系里面只有一个这样的成员,无论派生出多少个子类,都只有一个static成员实例.
基类的非静态成员会变成子类的一部分,静态成员不会.
#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
Person()
{
++_count;
}
public:
static int _count;
protected:
string _name;
};
int Person::_count = 0;
class Student : public Person
{
protected:
int stuNum;
};
class Graduate : public Student
{
protected:
string _seminaCourse;
};
int main()
{
Student s1;
Student s2;
Student s3;
Graduate s4;
cout<<"人数:"<<Person::_count<<endl;
Student::_count=0;
cout<<"人数:"<<Person::_count<<endl;
return 0;
}
该程序输出结果如下:
七、复杂的菱形继承与菱形虚拟继承
单继承:一个子类只有一个直接父类时趁这个继承关系为单继承。
多继承:一个子类有两个或两个以上直接父类称这个继承关系为多继承
菱形继承:菱形继承是多继承的一种特殊情况。
菱形继承的问题:从下面的对象成员模型构造,可以看出菱形继承有数据冗余和二义性的问题.在Assistant的对象中Person成员有两份。
#include<iostream>
#include<string>
using namespace std;
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;
};
int main()
{
//这样会有二义性,无法明确知道访问的是哪一个
Assistant a;
a._name = "peter";
return 0;
}
执行上面的代码,会发生报错:error C2385: 对“_name”的访问不明确
解决方法:
int main()
{
//需要显示指定访问的是哪个父类的成员可以解决二义性的问题,但是
//无法解决数据冗余的问题.
Assistant a;
a.Student::_name = "xxx";
a.Teacher::_name ="yyyy";
return 0;
}
虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上图的继承关系,在Student和Teacher的继承的Person时使用虚拟继承。
虚拟继承解决数据冗余和二义性的原理探究:
下图是菱形继承的内存对象模型:这里可以看到数据冗余。
为了研究虚拟继承原理,我们给出了一个简单的菱形继承体系,在借助内存观察窗口观察对象成员的模型.
下图是菱形虚拟继承的内存对象模型:这里可以分析出D对象中将A放到了对象组成的最下面,这个A同属于B和C,那么B和C如何去找公共的A呢?这里是通过了B和C的两个指针,指向的一张表。这两个指针叫虚基表。虚基表中存的偏移量,通过偏移量找到下面的A。
//有人可能会有疑问,为什么D中的B和C部分要去找属于自己的A?那我们可以看一下下面的赋值发生时,d是不是要去找B/C成员中的A才能赋值成功呢。
D d;
B b = d;
C c = d;
下图是上面的Person关系菱形虚拟继承的原理解释:
八、继承的总结与反思
1、很多人说C++语法复杂,其实继承就是一个体现,有了多继承,就存在菱形继承,有了菱形继承就有菱形虚拟继承,底层实现就很复杂,所以一般不建议设计出多继承,一定不要设计出菱形继承。
2、继承与组合:
- public继承是一种is-a的关系,也就是说每个派生类对象都是一个基类对象。
- 组合是一种has-a的关系。假设B组合了A,每个B对象中都有一个A对象.
- 优先使用对象组合,而不是类继承.
- 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常称为白象复用,术语:“白箱”是相对可视性而言:在继承方式中,基类的内部细节对子类可见。继承一定程度破坏了基类的封装,基类的改变对派生类有很大的影响。派生类和基类间的依赖关系强,耦合度高。
- 对象组合是类继承之外的另一种复用选择,新的更复杂的功能可以通过组装和组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格称为黑箱复用。因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现,组合类之间没有很强的依赖关系,耦合度低,优先使用对象组合有助于你保持每个类被封装.
- 实际尽量多去用组合。组合耦合度低,代码维护性好。不过继承也有用武之地。另外要实现多态,也必须用继承.
// Car和BMW Car和Benz构成is-a的关系
class Car{
protected:
string _colour = "白色"; // 颜色
string _num = "陕ABIT00"; // 车牌号
};
class BMW : public Car{
public:
void Drive() {cout << "好开-操控" << endl;}
};
class Benz : public Car{
public:
void Drive() {cout << "好坐-舒适" << endl;}
};
// Tire和Car构成has-a的关系
class Tire{
protected:
string _brand = "Michelin"; // 品牌
size_t _size = 17; // 尺寸
};
class Car{
protected:
string _colour = "白色"; // 颜色
string _num = "陕ABIT00"; // 车牌号
Tire _t; // 轮胎
}
面试题补充:
多继承中的指针偏移问题?
class Base1 {
public:
int _b1;
};
class Base2 {
public:
int _b2;
};
class Derive : public Base1, public Base2 {
public:
int _d;
};
int main()
{
// A. p1 == p2 == p3
// B. p1 < p2 < p3
// C. p1 == p3 != p2
// D. p1 != p2 != p3
Derive d;
Base1* p1 = &d;
Base2* p2 = &d;
Derive* p3 = &d;
return 0;
}
分析,上面的代码,指针在32平台上是4个字节,存储类对象时,只存对象的起始的4个字节的大小。因此p1和p3中都存的是d的首地址。