C++之继承

继承的概念及定义

继承的概念

继承(inheritance)机制是⾯向对象程序设计使代码可以复⽤的最重要的⼿段，它允许我们在保持原有 类特性的基础上进⾏扩展，增加方法(成员函数)和属性(成员变量)，这样产⽣新的类，称派⽣类。继承 呈现了⾯向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的函数层次的 复⽤，继承是类设计层次的复⽤。

eg：我们在写学生管理系统中，需要去定义学生，老师，后勤工作人员等结构体

那么学生有他的名字，电话号码，地址，年龄，学号等

//学生类
class Student
{
	string _name;//名字

	int _tel;//电话

	string _addrss;//地址

	int _age;//年龄

	int _stuid;//学号

};

老师也有他的名字，电话，地址，年龄+工号

//老师类
class Teacher
{
	string _name;//名字

	int _tel;//电话

	string _addrss;//地址

	int _age;//年龄

	int _workid;//工号
};

但是我们在设计的时候，会发现有很多重复的信息，如果我们一个一个的去打，那岂不是效率会很低？那么我们如何去提升我们的效率呢？此时继承就诞生了

我们先将重复的信息提取出来，新建一个类

class Person
{
	string _name;//名字

	int _tel;//电话

	string _addrss;//地址

	int _age;//年龄
};

此时，我们可以使用Student和Teacher将Person去进行复用

class Student;class Person
{
	int _stuid;
};

class Teacher;class Person
{
	int _workid;
};

但是一般成员变量会设置成私有的，Student、Teacher不好去访问Person的成员，所以C++就设计出来了类

//父类
class Person
{
public:
	//进入校园/图书挂/实验室刷二维码等身份认证
	void identity()
	{
		cout << "void identity()" << _name << endl;
	}
protected:
	string _name = "张三";
	string _address;
	string _tel;
private:
	int _age = 18;
};

//子类
class Student :public Person
{
public:
	//学习
	void study()
	{
		//identity();
	}
protected:
	int _stuid;
};

class Teacher :public Person
{
public:
	//授课
	void teaching()
	{

	}
protected:
	string title;
};

int main()
{
	Student s;
	Teacher t;

	s.identity();
	t.identity();
	return 0;
}

继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分，Student继承了Person，Student中就拥有了Person成员，Person叫做父类或者基类，Student叫子类或者派生类

继承定义

定义格式

我们可以看到Student是派生类，public是继承方式，Person是基类

继承关系和访问限定符

继承基类成员访问方式的变化

那么在继承当中，基类成员访问方式是怎么变化的呢？

我们首先设定权限大小；

public->protected->private

类成员/继承方式	public继承	protected继承	private继承
基类的public成员	派生类的public成员	派生类的protected成员	派生类的private成员
基类的protected成员	派生类的protected成员	派生类的protected成员	派生类的private成员
基类的private成员	在派生类不可见	在派生类不可见	在派生类不可见

我们可以通过表格总结出基类继承给子类的成员的访问方式的变为：min(访问方式，继承方式)，访问方式变为，父类中的访问方式和继承方式中，取权限最小的。

下面我们看一下这个代码

//父类
class Person
{
public:
	//进入校园/图书挂/实验室刷二维码等身份认证
	void identity()
	{
		cout << "void identity()" << _name << endl;
	}
protected:
	string _name = "张三";
	string _address;
	string _tel;
private:
	int _age = 18;
};

//子类
class Student :public Person
{
public:
	//学习
	void study()
	{
		identity();//共有的
		_name = "frank";//protected，类内部可以访问_name
		_age = 20;//error，不可见，对象的物理空间上他是存在的，但是语法上不允许子类使用
	}
protected:
	int _stuid;
};

int main()
{
	Student s;
	s.study();
	return 0;
}

我们将基类成员name设为保护，age设置成私有，派生类继承方式为public，所以name在子类中访问方式变为了保护，所以类内部可以访问name，age在子类中的访问方式变为了不可见，注意这里的不可见的意思是：对象物理空间上他是存在的，但是语法上不允许子类使用，如果我们去修改age是会发生编译错误的

实际上，C++在早期设计继承方式和访问限定符时，考虑复杂，把各种情况都考虑进去了，但是实际的使用中，用的最多的是public继承。基类成员访问限定符设置成public或者protected。虽然C++设计的复杂，但是我们尽量用简单的。继承中，一个类尽量不要使用private。因为private在子类中不可见，尽量用protected

总结：

1. 基类private成员在派⽣类中⽆论以什么⽅式继承都是不可⻅的。这⾥的不可⻅是指基类的私有成员 还是被继承到了派⽣类对象中，但是语法上限制派⽣类对象不管在类⾥⾯还是类外⾯都不能去访问 它。

2. 基类private成员在派⽣类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派⽣类 中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。

3. 实际上⾯的表格我们进⾏⼀下总结会发现，基类的私有成员在派⽣类都是不可⻅。基类的其他成员 在派⽣类的访问⽅式==Min(成员在基类的访问限定符，继承⽅式)，public >protected> private。

4. 使⽤关键字class时默认的继承⽅式是private，使⽤struct时默认的继承⽅式是public，不过最好显 ⽰的写出继承⽅式。

5. 在实际运⽤中⼀般使⽤都是public继承，⼏乎很少使⽤protetced/private继承，也不提倡使⽤ protetced/private继承，因为protetced/private继承下来的成员都只能在派⽣类的类⾥⾯使⽤，实 际中扩展维护性不强。

基类和派生类对象赋值转换(切片)

我们写这样的类：

class Person
{
protected:
	string _name = "张三";
	string _sex;
	string _age;
};

class Student :public Person
{
public:
	int _No;
};

那么我们创建一个基类，创建一个子类

int main()
{
	Student s;
	Person p = s;//子类赋值给父类对象
}

我们将子类赋值给父类对象这样是可以的，子类赋值给父类的这个过程称为切割或者切片：

同时还可以是指针和引用：

int main()
{
	//子类对象可以赋值给父类对象/指针/引用
	Person* pp = &s;
	Person& rp = s;
}

pp指向父类这一部分的成员，rp是父类这一部分的别名

那么我们如果将父类对象赋值给子类对象呢？

int main()
{
    Student s;
    Person p;
	//基类对象不可以赋值给派生类，这里会编译报错
	s = p;
}

这样子是错误的，父类对象不可以赋值给子类对象

总结：

1、public继承的派⽣类对象可以赋值给基类的指针/基类的引⽤。这⾥有个形象的说法叫切⽚或者切 割。寓意把派⽣类中基类那部分切出来，基类指针或引⽤指向的是派⽣类中切出来的基类那部分。

2、基类对象不能赋值给派⽣类对象。

继承中的作用(隐藏)

我们继续看一下代码：

// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆
class Person
{
protected :
    string _name = "小李子"; // 姓名
    int _num = 111; // 身份证号
};
class Student : public Person
{
public:
void Print()
{
    cout<<" 姓名:"<<_name<< endl;
    cout<<" 身份证号:"<<Person::_num<< endl;
    cout<<" 学号:"<<_num<<endl;
}
protected:
	int _num = 999; // 学号
};
void Test()
{
    Student s1;
    s1.Print();
};

可以看到基类和子类中有相同名字的成员变量，那么不妨想一下，我们在打印的时候，是打印父类的num还是子类的num呢？

我们可以发现打印l子类的num，这里有一个隐藏的概念：

当子类和父类有同名成员的时候，子类成员会隐藏父类成员，这个称为隐藏或者重定义

那么当我们打印基类的num成员了话，我们需要指定类域：

cout<<" 学号:"<<Person::_num<<endl;

我们可以发现，学号发生了改变，它打印了父类的num

继续看一个代码

class A
{
public:
    void func()
    {
        cout << "func()" << endl;
    }
};
class B :public A
{
public:
    void func(int i)
    {
        cout << "func(int i)" << endl;
    }
};
int main()
{
    B b;
    b.func(10);
    b.A::func();//调用父类的话需要指定作用域
}

和前面的成员变量一样，成员函数也是相同的道理，这里构成隐藏，要是想访问父类的成员函数就需要指定类域

很多人会误解这里的func函数构成重载，但是这里的函数重载的前提要求是在同一个作用域，所以A和B类func函数构成隐藏关系，只要函数名相同就构成隐藏。建议自己定义尽量不要在父子类中定义同名成员变量和函数

总结：

1. 在继承体系中基类和派⽣类都有独⽴的作⽤域。

2. 派⽣类和基类中有同名成员，派⽣类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏。（在派⽣类成员函数中，可以使⽤基类::基类成员显⽰访问）

3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。

4. 注意在实际中在继承体系⾥⾯最好不要定义同名的成员。

派生类的默认成员函数

6个默认成员函数，我们会讲解前四个，默认成员函数："默认"的意思就是，我们不写，编译器会给我们自动生成一个，那么在派生类中，默认成员函数又是如何实现的呢？

构造函数

class Person
{
public:
    //构造函数
    Person(const char* name = "peter")
        : _name(name)
    {
        cout << "Person()" << endl;
    }
protected:
    string _name;
};
class Student : public Person
{
public:
    //默认生成的构造函数行为
    //1、内置类型->不确定
    //2、自定义类型->调用默认构造
    //3、继承父类成员看作一个整体对象，要求调用父类的默认构造
private:
    int _id;
    string _address;
};
int main()
{
    Student s;
    return 0;
}

我们这里可以发现我们没有定义父类对象，但是打印显示，调用了父类的构造函数，为什么呢？是因为子类构造函数我们不写，编译器会默认生成构造函数，那么默认构造函数会这样去处理：

1、继承的父类成员调用父类的构造默认函数初始化

2、自己的自定义类型成员（调用自定义类型的构造函数）

3、自己的内置类型成员，不处理（除非给了声明时的缺省值）

我们调式可以发现，确实是这样的

父类里的_name已经初始化了，内置类型并没有处理，_address调用string类的默认构造函数函数进行初始化。

如果父类写了带参数的构造函数（并且没有写默认构造函数），我们就必须自己实现子类的构造函数来正确初始化父类部分，否则会报错父类没有合适的默认构造函数

在显示写子类构造函数时，对父类的成员初始化时，需要注意的是父类被看成一个整体：

Student(const char* name,int id,const char* address)
    :_id(id)
    ,_address(address)
{}

那么我们怎么给父类的成员进行初始化呢？将父类看成一个整体：

Student(const char* name,int id,const char* address)
	:Person(name)    
    ,_id(id)
    ,_address(address)
{}

注意：

不在初始化列表显示的调用父类的构造函数初始化的话，编译器会调用默认的构造函数去初始化

拷贝构造函数

class Person
{
public:
    //构造函数
    Person(const char* name = "peter")
    	  : _name(name)
     {
     	cout<<"Person()" <<endl;
     }
    //拷贝构造函数
    Person(const Person& p)
     : _name(p._name)
    {
     	cout<<"Person(const Person& p)" <<endl;
    }
protected:
	string _name;
};
class Student : public Person
{
public:
private:
    int _id;
    string _address;
};
int main()
{
    Student s;
    Student s1(s);
    return 0;
}

我们可以看到它调用了父类的拷贝构造函数，子类拷贝构造函数我们不写编译器默认生成

默认生成的拷贝构造函数会这样处理：

1、继承的父类成员调用父类的拷贝构造函数初始化

2、自己的自定义类型成员(调用自定义类型的拷贝构造函数)

3、自己的内置类型成员，进行值拷贝

那么我们又如何去实现呢？我们怎么对父类的那一部分进行拷贝呢？前面我们说过切片，这里就用上了

Student(const Student& s)
       :Person(s)//切片  这里不写会调用默认构造函数
       ,_id(s._id)
       ,_address(s._address)
{}

如果这里不写person(s)，这里会调用默认构造函数：

如果要自己实现，就要类似这样去处理，但是像这里的Student是不需要自己去实现的，默认实现就够用了，只有当子类中存在深拷贝问题才需要自己去实现

赋值重载函数

class Person
{
public:
	//赋值重载
     Person& operator=(const Person& p)
     {
         cout<<"Person operator=(const Person& p)"<< endl;
         if (this != &p)
         _name = p ._name;

     	return *this ;
	 }
protected:
	string _name;
};
class Student : public Person
{
public:
private:
    int _id;
    string _address;
};
int main()
{
    Student s;
    Student s1;
    s1 = s;
    return 0;
}

子类赋值重载函数我们不写编译器自动生成，默认生成的赋值重载函数会这样处理：

1、继承的父类成员调用父类的赋值重载函数

2、自己自定义类型成员(调用自定义类型的赋值重载函数)

3、自己的内置类型成员，进行值拷贝

那么需要自己实现呢？就这样实现：

Student& operator=(const Student& s)
{
    if(this != &s)
    {
        _id = s._id;
        _address = s._address;
        operator=(s);
    }
    return *this;
}

但是，我们运行的时候，我们可以发现，我们的代码崩了，原因是

子类的operator=和父类的operator=构成了隐藏，并且这里发生了切片，所以需要指定作用域

Student& operator=(const Student& s)
{
    if(this != &s)
    {
        _id = s._id;
        _address = s._address;
        Person::operator=(s);//切片
    }
    return *this;
}

析构函数

class Person
{
public:
    //构造函数
    Person(const char* name = "peter")
    	  : _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:
private:
    int _id;
    string _address;
};
int main()
{
    Student s;
    Student s1;
    s1 = s;
    return 0;
}

当我们不去显示写析构函数时：

析构函数我们不写编译器默认生成，默认生成的析构函数会

1、继承的父亲成员调用父类的析构函数

2、自己的自定义类型成员(调用自定义类型的析构函数)

3、自己的内置类型成员，不会处理

如果要自己实现呢？

~Student()
{
    ~Person();
    //清理子类的资源
}

这样是错误的，因为子类析构函数和父类析构函数构成隐藏，因为编译器会对析构函数名做特殊处理，所有类的析构函数名都会被处理成统一名字destructor(),为什么编译器会做这样的处理呢？因为析构函数在底层要构成多态的重写

我们需要加类域：

~Student()
{
    Person::~Person();
    //清理子类的资源
}

但是我们发现多析构了，为什么呢？因为子类的析构函数在执行结束之后会自动调用父类的析构函数

为了保证先构造的后释放，因为在构造函数中规则是父类是先被构造的，然后在构造子类的，所以子类的析构函数在执行结束之后会自动调用父类的析构函数，这样才能保证子类先调用后析构函数清理，再调用父类的析构函数

所以我们不需要去写显示的析构函数，因为编译器在子类析构执行完后自动的去调用

~Student()
{
    //清理子类的资源
    //自动的调用父类的析构
}

继承和友元

class Person
{
public:
    friend void Print(const Person& p,const Student& s);
protected :
    string _name = "张三"; // 姓名
};
class Student : public Person
{
protected:
	int _num = 999; // 学号
};
void Print(const Person& p,const Student& s)
{
    cout<<" 姓名:"<<p._name<< endl;
    cout<<" 学号:"<<s._num<<endl;
}
void Test()
{
    Person p;
    Student s;
    Print(p,s);
};

我们看到Print函数是基类的友元，那么友元关系可以继承吗？

友元关系不能继承，基类的友元不能访问子类私有和保护成员

继承与静态成员

基类定义了static的静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例。基类静态成员属于整个继承体系的类，属于这些类的所有对象

class Person
{
public:
	string _name;
	static int _count;
};
int Person::_count = 0;
class Student : public Person
{
protected:
	int _stuNum;
};

int main()
{
	Person p;
	Student s;
	//这⾥的运⾏结果可以看到⾮静态成员_name的地址是不⼀样的
	//说明派⽣类继承下来了，⽗派⽣类对象各有⼀份
	cout << &p._name << endl;
	cout << &s._name << endl;
}

我们可以看到非静态成员是name地址是不一样的，因为它被继承下来了，父类和子类都各自有一份

class Person
{
public:
	string _name;
	static int _count;
};
int Person::_count = 0;
class Student : public Person
{
protected:
	int _stuNum;
};

int main()
{
	Person p;
	Student s;
	//这⾥的运⾏结果可以看到静态成员_count的地址是⼀样的
	//说明派⽣类和基类共⽤同⼀份静态成员
	cout << &p._count << endl;
	cout << &s._count << endl;
	return 0;
}

运行结果，我们可以看到静态成员count的地址是一样的，说明我们的子类和父类公用一个静态成员

class Person
{
public:
	string _name;
	static int _count;
};
int Person::_count = 0;
class Student : public Person
{
protected:
	int _stuNum;
};

int main()
{
	Person p;
	Student s;
	cout << Person::_count << endl;
	cout << Student::_count << endl;
	return 0;
}

而我们的在共有的情况下，父类和子类指定类域都可以访问静态成员

菱形继承和菱形虚拟继承

菱形继承

单继承：一个子类只有一个直接父类时，这个继承关系叫单继承

多继承：⼀个派⽣类有两个或以上直接基类时称这个继承关系为多继承，多继承对象在内存中的模型 是，先继承的基类在前⾯，后⾯继承的基类在后⾯，派⽣类成员在放到最后⾯。

菱形继承：菱形继承是多继承的⼀种特殊情况。

菱形继承并不一定是固定这样的菱形形状才是菱形继承，在Teacher和Assitant类直接加一层关系也是可以的，只要有这个大体形状就可以

只看这个图

我们可以发现，多继承是C++的一个坑，由多继承衍生出来菱形继承，但是在早期设计的时候，没有办法，java后续直接就不支持多继承了，多继承本身没有问题，但是支持多继承，就可能出现菱形继承，我们可以发现Assistant类中，会有两份Person成员，一份是Student继承下来的，一份是Teacher继承下来的，这样造成了数据冗余和⼆义性

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";
    // 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
    a.Student::_name = "xxx";
    a.Teacher::_name = "yyy";
}

当我们对_name去写的时候，这样会有二义性编译器无法明确知道访问的那个一个_name

所以需要显示指定访问哪个父类的成员可以解决二义性问题

a.Student::_name = "xxx";
a.Teacher::_name = "yyy";

但是这样并没有解决数据冗余的问题，为了解决这个问题，就出现了菱形继承

菱形虚拟继承

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 ; // 主修课程
};
void Test ()
{
    Assistant a ;
    a._name = "peter";
}

菱形虚拟继承解决了数据冗余和二义性问题，虽然在监视窗口看着有三分，其实这里的name只有一份，监视窗口为了方便我们进行变量的查看，进行了优化，我们改其中一个，其他两个也会发生变化

实际中，一般情况下，建议不要设计出菱形继承，那么就不会用菱形虚拟继承，就不会有这么多的问题。

继承和组合

class A
{
public:
	void func(){}
protected:
	int _a;
};
//B继承了A，可以复用A
class B : public A
{
protected:
	int _b;
};
//C组合A，也可以复用A
class C
{
private:
    int _c;
    A _a;
};

A和B是继承关系，而A和C是组合关系，public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。B类复用A类是白箱复用(B里面既可以用A公有成员，也可以用保护的成员，也就是说，A所有成员对于B都是透明的，随便用，关联度高，A的改变，基本都会影响B，A的封装对B是不太起作用的)，而C类复用A类是黑箱复用(C里面只能用A公有的成员，A的保护成员私有成员对C是不透明的，那么C和A关联度就低，A的改变对C的影响小，A的封装对C是起作用的)

所以B和A之间是一种强关联关系，C和A之间是一种弱关联关系

软件设计类之间关系或者模块间强调：

高内聚(类里面的成员之间关联度很高)，低耦合(类和类之间关联度很低)，实际开发中，项目很大，需要多个人协作才能完成，比如张三和李四，张三维护的模块是A、B、C，李四维护的模块是D、E，高内聚的意思就是ABC三个模块之间需要联系紧密一些比较好，DE模块之间也是需要联系紧密一些比较好，而张三和李四维护的模块又需要关联度低一些，否则如果张三在修改一个模块时，李四的模块可能也收到了影响。

注意：

实际中，虽然组合比继承更好，但是也不是说，就不用继承，一般建议，需要清楚类和类之间的关系，如果类之间更符合is-a关系，建议用继承。如果类之间更符合has-a，建议用组合；如果不明确，既可以看作是is-a关系，也可以是has-a的关系，则用组合

Person和Student以及Person和Teacher构成is-a的关系：

//Person和Student Person和Teacher构成is-a的关系
class Person
{
protected:
    string _name = "张三"; // 姓名
    string _sex = "男"; // 性别
};
class Student : public Person
{
protected:
    int _num;//学号
};
class Teacher : public Person
{
protected:
    int _workID;//工号
};

轮胎和车构成has-a关系

// Tire和Car构成has-a的关系
class Tire
{
protected:
    string _brand = "Michelin"; // 品牌
    size_t _size = 17; // 尺寸
};
class Car
{
protected:
    string _colour = "白色"; // 颜色
    string _num = "陕ABIT00"; // 车牌号
    Tire _t; // 轮胎
};