C++继承

我们在用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基类总用同一个对象表示。