---

前言

前面几节学的基本是两块内容：第一块是C++的一些特性，比如重载、引用、函数参数值传递与地址传递。第二块是面向对象编程的三大特性的其一：封装。封装中涉及了格式、成员变量和成员函数、访问权限、实例化对象、构造函数与析构函数、成员变量与成员函数的存储位置、this指针、友元声明、operator声明的运算符重载等知识。

现在就要接触到面向对象编程的三大特性的其二：继承。

一、继承：继承的类除了拥有上一级类的共性，也拥有自己的特性。

继承的主要优势在于代码的重用性和扩展性。通过继承，子类可以直接使用父类的属性和方法，无需重新编写相同的代码。这样可以减少代码的冗余，并提高代码的可维护性。同时，子类还可以在继承的基础上添加自己的特性，以满足特定的需求。

在继承关系中，父类通常是一个更通用、抽象的类，而子类则是在父类基础上进行特化和扩展的类。子类可以通过继承获得父类的属性和方法，并且可以添加新的属性和方法，或者重写父类的方法以实现自己的逻辑。

继承还可以形成类的层次结构，使得代码的组织更加清晰和易于理解。通过继承，可以将类按照其关系进行分类和组织，形成一个类的层次结构，从而更好地组织和管理代码。
举个例子：

#include <iostream>
using namespace std;class Animal {
protected:string name;public:Animal(string name) {this->name = name;}void speak() {cout << "动物发出声音" << endl;}
};class Dog : public Animal {
private:string breed;public:Dog(string name, string breed) : Animal(name) {this->breed = breed;}void speak() {cout << "汪汪汪！" << endl;}void fetch() {cout << "狗狗正在追逐球" << endl;}
};int main() {Animal animal("动物");animal.speak();  // 输出：动物发出声音Dog dog("旺财", "哈士奇");dog.speak();  // 输出：汪汪汪！dog.fetch();  // 输出：狗狗正在追逐球return 0;
}

Animal类是父类，它有一个name属性和一个speak方法。Dog类是子类，它继承了Animal类，并且添加了一个新的属性breed（品种）和一个新的方法fetch（追逐）。

继承的语法：
class 子类: 继承方式 父类

子类也叫派生类，父类也叫基类。

二、继承方式：公有继承（public inheritance）、私有继承（private inheritance）和保护继承（protected inheritance）

1.公共继承

使用关键字public来指定继承方式。
①子类继承了父类的公开成员和保护成员，但不继承父类的私有成员（即不能访问）。
②父类的公开接口成员函数既可以让外部调用，也可以让子类调用。

2.保护继承

使用关键字protected来指定继承方式。
①子类继承父类的公开成员和保护成员，且在子类中都变为保护成员，父类的私有成员仍然不能访问
②父类的接口函数限制在子类和子类的派生类中，外部无法直接访问父类的成员

3.私有继承

使用关键字private来指定继承方式。
①子类继承父类的公开成员和保护成员，且在子类中都变为私有成员，父类的私有成员仍然不能访问
②私有继承将父类的接口隐藏起来，子类不能直接访问父类的成员函数，只能通过子类自己的公有成员或者友元函数来间接访问。

子类中无法访问父类私有的权限，但是可以访问公开和受保护的权限。
有几个注意的地方：
①保护权限的成员，只能在子类内部访问，而不能在外部的主函数里访问。
子类继承父类的protected变量，不能在主函数里用对象调用吗？
保护成员可以在子类内部和子类对象中访问，但不能在类外部直接访问。
②子类继承父类后，孙子类应该继承子类的哪些成员呢？
答：当子类继承父类后，孙子类会继承子类的所有成员，包括公有成员、保护成员和私有成员。孙子类可以直接访问子类的公有成员和保护成员，但无法直接访问子类的私有成员。继承的层次可以一直延续下去，每个子类都可以成为下一个子类的父类。

三、子类实例化对象后，父类继承的成员哪些属于子类对象？

儿子类继承了父类的三个不同权限的成员变量，自己有一个独特的成员变量，那sizeof（son）的结果到底是多少呢？
答案是子类的对象拥有了这四个变量的空间，即使父类有一个私有变量，子类只是不能访问，但实例化对象时也开辟了它的空间。

四、子类继承了父类后，子类的构造与析构函数怎么被继承使用呢？

1.继承的构造函数与析构函数执行顺序？

构造函数的继承：子类会继承父类的构造函数。当创建子类对象时，会先调用父类的构造函数，然后再调用子类自身的构造函数。这样可以确保父类的成员被正确初始化。

析构函数的继承：子类会继承父类的析构函数。当子类对象被销毁时，会先调用子类自身的析构函数，然后再调用父类的析构函数。这样可以确保父类的资源被正确释放。

2.父类如果写了构造函数，子类怎么写构造函数呢？

class father {
private:string name;int age;
protected:int money;
public:father() {name = "xiaogang";age = 38;money = 6000;address = "nanjing";}string address;
};

子类：

class son :public father {
public:son() {money = 5000;address = "beijing";height = 150;}int height;
};

也就是说，父类的构造函数在父类写好后，子类继承时就不能用默认构造函数去实例化对象了，而是要重新写一个含参的构造函数。

一定要注意一点：
子类的对象和父类的对象是完全不同的两个对象，他们各自的成员变量的地址是不同的。构造函数里面的赋值，也只是给自己的对象的成员变量赋值而已。

int main() {father f;son son1;cout << son1.address << endl;//儿子是北京cout << f.address << endl;//父亲是南京return 0;
}

五、父类子类出现同名成员变量处理方式

举个例子，父类有个成员变量叫friends，子类也有一个成员变量叫friends。任何通过子类的对象去访问父类的同名成员变量呢？
使用作用域声明：

son1.father::friends

class father {
private:string name;int age;
protected:int money;
public:father() {name = "xiaogang";age = 38;money = 6000;address = "nanjing";friends = "limiing";}string address;string friends;
};class son :public father {
public:son() {money = 5000;address = "beijing";height = 150;friends = "xiaohong";}int height;string friends;
};int main() {father f;son son1;cout << son1.father::friends << endl;return 0;
}

对象son1调用了父亲作用域下的成员变量。

六、多继承：一个类继承多个类

1.语法：class 子类 : 继承方式 父类1, 继承方式 父类2

比如：class C : public A, public B

#include <iostream>
using namespace std;// 基类A
class A {
public:void displayA() {cout << "This is class A" << endl;}
};// 基类B
class B {
public:void displayB() {cout << "This is class B" << endl;}
};// 派生类C，继承自类A和类B
class C : public A, public B {
public:void displayC() {cout << "This is class C" << endl;}
};int main() {C c;c.displayA();  // 调用继承自类A的成员函数c.displayB();  // 调用继承自类B的成员函数c.displayC();  // 调用派生类C自己的成员函数return 0;
}

2.缺点：如果不同父类存在变量或者函数重名的情况，子类就必须用作用域::来指定。可能会引起命名冲突和二义性问题。

七、菱形继承方式

总结：继承的重要性

继承是C++中的一个重要特性，被广泛应用于面向对象编程中。在实际开发中，继承被广泛用于代码复用和扩展性设计。

下面是一些继承的常见应用场景：

实现类的层次结构：通过继承，可以将类组织成层次结构，从而更好地组织和管理代码。

代码复用：通过继承，可以将一个类的成员函数和成员变量复用到另一个类中，从而减少代码量，提高代码的可维护性和可重用性。

多态性：通过继承和虚函数，可以实现多态性，即同一个函数在不同的派生类中具有不同的实现。

接口设计：通过继承和抽象类，可以定义接口，从而实现代码的松耦合和可扩展性。