我们在用C语言写代码的时候,一定希望重复性的代码越少越好,随着程序的组织越来越复杂,单纯靠main()函数中写功能代码会让代码越来越难以维护和扩展。所以我们函数来解决这个问题,一个函数就像一个小程序,可以从主函数中脱离出来,这使我们能够将复杂的任务划分为一个个简单、容易实现的小程序。从而来降低我们整个程序的整体复杂性。所以,函数让我们实现了一定程度上的代码复用。
那么在C++中,我们通过继承的机制来使我们的代码复用。
继承机制是面向对象程序设计使代码复用的最重要的手段,它允许程序员在保持原有类特性的基础上进行扩展,增强功能。这样产生的新的类,称作为派生类。继承呈现了面向对象程序设计的层次结构,体现了由简单到复杂的认知过程。
看一段代码:
#include <iostream>
using namespace std;
class Person
{
public:
char* _name;
char* _sex;
int _age;
public:
void Display()
{
cout<<"_name:"<<_name<<",_sex:"<<_sex<<",age:"<<_age<<endl;
}
};
class Student : public Person
{
public:
void BuyTicket()
{
cout<<"买半价票"<<endl;
}
};
int main()
{
Person male;
malex_name = "Jack";
male._sex = "男";
male._age = 28;
male.Display();
Student boy;
boy._name = "Tom";
boy._sex = "男";
boy._age = 8;
boy.Display();
return 0;
}
继承的定义格式:
在上面的代码中,基类就是Person类,派生类就是Student类,继承权限就是public
继承权限与访问限定符
总结一下:
1.基类private成员在派生类中是不能被访问的,如果基类成员不想在类外被直接访问,但需要在派生类中被访问,就定义为protected。可以看出,前面保护成员限定符是因为继承才出现的。
2.public继承是一个接口继承,保持 is-a 原则。每个父类可用的成员对子类也可以,因为每个子类对象也都是一个父类对象。
3.protected/private继承是一个实现继承,基类的部分成员并非能完全成为子类接口的一部分,是 has-a 的关系原则,所以非特殊情况下不会使用这两种继承关系,在绝大多数的场合下都是公有继承。
4.不管是哪种继承方式,在派生类内部都可以访问基类的公有成员和保护成员,基类私有的成员在子类中不可访问。
5.使用关键字class时默认的是private继承,使用struct时默认的是public继承,不过最好显示的写出继承方式。
6.在实际运用中都是使用public继承方式,极少情况下才会使用private/protected继承方式。
赋值兼容规则----public继承
1.子类对象可以赋值给父类对象
2.父类对象不能赋值给子类对象
3.父类的指针/引用可以指向子类对象
4.子类的指针/引用不能指向父类对象(可以通过强制类型转换完成,但不能调用调用成员函数,会报错)
我们通过代码来看看这几种情况
#include <iostream>
#include <string>
using namespace std;
class Person
{
public:
void Display()
{
cout << _name << endl;
}
protected:
string _name;
};
class Student : public Person
{
public:
int _num;
};
int main()
{
Person p;
Student s;
//1.子类对象可以赋值给父类对象
p = s;
//2.父类对象不能赋值给子类对象
//s = p;
//3.父类的指针或引用可以指向子类对象
Person* p1 = &s;
Person& r1 = s;
//4.子类的指针或引用不可以指向父类对象(但可以通过强制类型转换,但是不能调用成员函数,会报错)
Student* p2 = (Studen*)&p;
Student& r2 = (Student&)p;
//这里会发生什么?
//p2->_num = 10;
//r2._num = 20;
return 0;
}
如果我们用父类对象赋值给子类对象:
如果我们用子类的指针或引用去指向父类对象,在此我们强制类型转换可以完成。但是如果我们调用了成员,会出现什么?
程序虽然通过编译,但是在运行时会直接崩掉
继承中的作用域
1.在继承体系中基类与派生类都有独立的作用域。
2.子类和父类中有同名成员,子类成员将屏蔽父类对同名成员的直接访问。(在子类成员函数中,可以使用基类::基类成员 访问)
3.注意实际中在继承体系里最好不要定义同名的成员
派生类默认的成员函数
继承体系下,派生类如果没有显示定义六个默认的成员函数,编译器则会合成这个六个默认的成员函数。
之前在介绍这留个默认成员函数的时候说,如果没有显示定义,编译器会自动生成,这里又说是自动合成,那么有什么区别呢?
生成:不依赖与任何东西,只是编译器根据类的定义简单生成基于基础类型的默认成员函数。
合成:必须依赖基类,编译器根据基类的相应成员函数行为来合成派生类的默认成员函数。
构造派生类对象,调用派生类构造函数:
1.在派生类构造函数的初始化列表中完成基类对象的构造。
2.在派生类构造函数的初始化列表构造派生类自己的成员。
3.执行派生类构造函数的函数体。
所以,如果基类中有非缺省的构造函数,派生类必须显示给出自己的构造函数,并在其构造函数初始化列表的位置调用基类的构造函数,完成基类对象的构造,如果基类中构造函数是缺省的,派生类构造函数是否需要显示提供根据需求。
派生类对象的构造与析构
继承体系下派生类和基类构造函数的调用次序:
所以:
1.基类函数有非缺省构造函数,派生类必须要在初始化列表中显示给出基类名和参数列表
2.基类没有定义构造函数,则派生类也可以不用定义,全部使用缺省构造函数
3.基类定义了带有形参表构造函数,派生类就一定定义构造函数
继承与友元
友元关系不能继承,也就是说友元不能访问子类私有和保护成员
class Person
{
public:
friend void Display(Person& p,Student& s);
string _birthday;
protected:
string _name;
private:
int _age;
};
class Student : public Person
{
public:
int _houseNo;
protected:
int _stuNum;
private:
int _bedNo;
};
void Display(Person& p,Student& s)
{
cout<<p._birthday<<endl;
cout<<p._name<<endl;
cout<<p._age<<endl;
cout<<s._houseNo<<endl;
cout<<s._stuNum<<endl;
cout<<s._stuNum<<endl;
cout<<s._bedNo<<endl;
}
int main()
{
Person p;
Student s;
Display(p,s);
}
运行上面的代码后:
说明友元关系不能被继承。
继承与static静态成员
基类定义了static静态成员,则整个继承体系里面只有一个这样的成员,无论派生出多少个子类,都只有一个static成员实例。
class Person
{
public:
Person()
{
++_count;
}
protected:
string _name;
public:
static int _count;
};
int Person::_count = 0;
class Student : public Person
{
protected:
int _stuNum;
};
class Graduate : public Student
{
protected:
string _seminarCourse;
};
int main()
{
Student s1;
Student s2;
Student s3;
Graduate s4;
cout<<"人数 :"<<Person ::_count<<endl;
Student ::_count = 0;
cout<<"人数 :"<<Person :: _count<<endl;
}
继承体系下的派生类对象模型
单继承:
一个子类只有一个直接父类时称这个继承关系为单继承
多继承:
一个子类有两个或两个以上直接父类时成这个继承关系为多继承
#include <iostream>
using namespace std;
class B1{
public:
int _b1;
};
class B2
{
public:
int _b2;
};
class D : public B1,public B2
{
public:
int _d;
};
int main()
{
cout<<sizeof(D)<<endl;
D d;
d._b1 = 1;
d._b2 = 2;
d._d = 3;
}
这个代码中,D类继承了B1类和B2类,D类的大小应该是12,我们看看是12吗?
运行结果:
答案就是12,我们再来看看内存的情况。
菱形继承:
根据上图我们可以得到菱形继承的对象模型:
从这个对象模型看出,我们发现Person类对象存在两份,因此再访问继承基类的成员变量时,会存在二义性的问题。
将最顶层中的成员变量在其对象模型中存放了两份,派生类对象无法直接访问最顶层基类对象的成员。
所以,我们需要用虚拟继承来解决这个问题。
虚拟继承:在继承权限前加上virtual关键字即可构成虚拟继承。
虚拟继承的特点是,在任何派生类中的virtual基类总用同一个对象表示。