# 继承与赋值兼容

> [!info] 学习导航
> 返回：[[C++ 学习指南]]
> 前置知识：[[计算机系/C++/06 类与对象基础|类与对象基础]]、[[计算机系/C++/09 运算符重载|运算符重载]]

面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。

当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为**基类**，新建的类称为**派生类**。

继承代表了 **is a** 关系。

## 基类 & 派生类

一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名，形式如下：

```cpp
class derived-class: access-specifier base-class
```

其中，访问修饰符 access-specifier 是 **public、protected** 或 **private** 其中的一个，base-class 是之前定义过的某个类的名称。如果未使用访问修饰符 access-specifier，则默认为 private。

## 访问控制

派生类可以访问基类中所有的非私有成员。因此基类成员如果不想被派生类的成员函数访问，则应在基类中声明为 private。

我们可以根据访问权限总结出对于一个类不同的访问类型，如下所示：

（这只是访问控制，与派生类的继承方式为什么无关，继承方式决定的从派生类对象访问继承自基类的成员时，这些成员的访问控制如何变化）

| **访问** | **public** | **protected** | **private** |
| -------- | ---------- | ------------- | ----------- |
| 同一个类 | yes        | yes           | yes         |
| 派生类   | yes        | yes           | no          |
| 外部的类 | yes        | no            | no          |

一个派生类继承了所有的基类方法，但下列情况除外：

- 基类的构造函数、析构函数和拷贝构造函数。
- 基类的重载运算符。
- 基类的友元函数。

### 继承构造函数的注意事项

```cpp
class Base {
public:  int x;
protected: int y;
private:  int z;
};
class Derived : public Base {
// 在派生类内部：
  void foo() {
    x; // ✅ public成员可访问
    y; // ✅ protected成员可访问
    z; // ❌ private成员不可访问
  }
};
// 外部函数
void bar() {
  Base b;
  b.x; // ✅ public成员可访问
  b.y; // ❌ protected成员不可访问
  b.z; // ❌ private成员不可访问
}
```

## 继承类型

**继承方式（public / protected / private）控制的是：**

**“从派生类对象访问继承自基类的成员时，这些成员的访问控制如何变化”**


当一个类派生自基类，该基类可以被继承为 **public、protected** 或 **private** 几种类型。继承类型是通过上面讲解的访问修饰符 access-specifier 来指定的。

我们几乎不使用 **protected** 或 **private** 继承，通常使用 **public** 继承。当使用不同类型的继承时，遵循以下几个规则：

- **公有继承（public）：**当一个类派生自**公有**基类时，基类的**公有**成员也是派生类的**公有**成员，基类的**保护**成员也是派生类的**保护**成员，基类的**私有**成员不能直接被派生类访问，但是可以通过调用基类的**公有**和**保护**成员来访问。
- **保护继承（protected）：** 当一个类派生自**保护**基类时，基类的**公有**和**保护**成员将成为派生类的**保护**成员。
- **私有继承（private）：**当一个类派生自**私有**基类时，基类的**公有**和**保护**成员将成为派生类的**私有**成员。

**3. 继承方式**

| **基类成员访问权限** | **公有继承（public）**    | **保护继承（protected）** | **私有继承（private）** |
| -------------------- | ------------------------- | ------------------------- | ----------------------- |
| **public**           | 在派生类中仍为 **public** | 降级为 **protected**      | 降级为 **private**      |
| **protected**        | 仍为 **protected**        | 仍为 **protected**        | 降级为 **private**      |
| **private**          | **不可见**                | **不可见**                | **不可见**              |

```cpp
class Base {
public:
  int a;
protected:
  int b;
private:
  int c;
};
class Derived_public : public Base {
  void test() {
    a = 1; // ✅ OK
    b = 2; // ✅ OK
// c = 3; // ❌ Error: private成员不能被派生类访问
  }
};
class Derived_protected : protected Base {
  void test() {
    a = 1; // ✅ OK
    b = 2; // ✅ OK
  }
};
class Derived_private : private Base {
  void test() {
    a = 1; // ✅ OK
    b = 2; // ✅ OK
  }
};
```

上面的三种继承方式在成员**“继承过来后对外可见性”**不同：

| **继承方式**                                               | **Base::a 在 Derived 中变成**    | **外部能否访问   Derived::a** |      |      |
| ---------------------------------------------------------- | -------------------------------- | ----------------------------- | ---- | ---- |
| public                                                     | public                           | ✅ 可以                        |      |      |
| protected                                                  | protected                        | ❌ 不行                        |      |      |
| private                                                    | private                          | ❌ 不行                        |      |      |
| **概念**                                                   | **控制什么？**                   |                               |      |      |
| **成员访问修饰符** /访问控制(public / protected / private) | 控制“谁能访问这个成员”           |                               |      |      |
| **继承方式**  (public / protected / private)               | 控制“这个成员在派生类中的可见性” |                               |      |      |
|                                                            |                                  |                               |      |      |

外部函数要访问类成员，必须遵守该成员的访问控制：

- public 成员：✅ 外部函数可以访问。
- protected 或 private：❌ 不能直接访问，除非是友元（friend）。

继承方式（**public**/**protected**/**private**）是基类成员在派生类中的 **最高访问权限上限**。

基类成员的最终权限 = **min(基类成员原始权限, 继承方式)**。


私有继承的话，基类成员（公有、保护、私有）成为了派生类的私有成员；访问控制和派生类自己的私有成员一致

保护继承的话，基类的公有、保护成员变成了派生类的保护成员。访问控制和派生类自己的保护成员一致。


```cpp
class Date {
public:
Date(int y, int m, int d); // 没有默认构造函数
};
class Person : public Date { // Person 继承 Date
public:
// 必须在初始化列表中调用 Date 的构造函数
  Person(int y, int m, int d) : Date(y, m, d) {}
};
```

| **情况**             | **是否必须用初始化列表？** | **原因**                 |
| -------------------- | -------------------------- | ------------------------ |
| 基类没有默认构造函数 | **必须**                   | 必须显式调用基类构造函数 |
| **const** 成员       | **必须**                   | 不能赋值，只能初始化     |
| 引用成员             | **必须**                   | 必须在创建时绑定         |
| 无默认构造的类成员   | **必须**                   | 无法默认构造             |


## 多继承

多继承即一个子类可以有多个父类，它继承了多个父类的特性。

C++ 类可以从多个类继承成员，语法如下：

class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…

```cpp
{
```

<派生类类体>

```cpp
};
```

其中，访问修饰符继承方式是 **public、protected** 或 **private** 其中的一个，用来修饰每个基类，各个基类之间用逗号分隔，如上所示。

## 虚继承

多继承(环状继承),A->D, B->D, C->(A，B)，例如：

```cpp
class D{......};
class B: public D{......};
class A: public D{......};
class C: public B, public A{.....};
```

这个继承会使D创建两个对象,要解决上面问题就要用虚拟继承格式

格式：**class 类名: virtual 继承方式 父类名**

```cpp
class D{......};
class B: virtual public D{......};
class A: virtual public D{......};
class C: public B, public A{.....};
```

虚继承--（在创建对象的时候会创建一个虚表）在创建父类对象的时候

A:virtual public D

B:virtual public D

**实例：**

```cpp
#include <iostream>
using namespace std;
// 基类
class D
{
public:
  D(){cout<<"D()"<<endl;}
  ~D(){cout<<"~D()"<<endl;}
protected:
  int d;
};
class B:virtual public D
{
public:
  B(){cout<<"B()"<<endl;}
  ~B(){cout<<"~B()"<<endl;}
protected:
  int b;
};
class A:virtual public D
{
public:
  A(){cout<<"A()"<<endl;}
  ~A(){cout<<"~A()"<<endl;}
protected:
  int a;
};
class C:public B, public A
{
public:
  C(){cout<<"C()"<<endl;}
  ~C(){cout<<"~C()"<<endl;}
protected:
  int c;
};
int main()
{
  cout << "Hello World!" << endl;
  C c; // D, B, A ,C
  cout<<sizeof(c)<<endl;
  return 0;
}
```

虚基类的最终子孙类对象只建立一份虚基类部分对象，虚基类部分对象构造方法在最终建立的ui先子孙类构造函数中指明，中间类部分对象构造时将不在构造虚基类部分对象

如果虚基类中定义有带参数的构造函数，并且参数没有默认值，且没有定义无参构造函数，则在虚基类的直接派生类和简介拍摄雷达构造函数初始化表中都需要对虚基类初始化

子类的函数会出现在初始化列表中。原因在于子类能够从基类继承的内容限制上。

我们知道，一个派生类继承了所有的基类方法，但下列情况除外：

- 基类的构造函数、析构函数和拷贝构造函数。
- 基类的重载运算符。
- 基类的友元函数。

因此，我们不能够在子类的成员函数体中调用基类的构造函数来为成员变量进行初始化。例如这样子是不可以的

```cpp
// 派生类
class Rectangle: public Shape
{
  public:
Rectangle(int a,int b)
   {
    Shape(a,b);
   }
};
```

但我们可以把基类的构造函数放在子类构造函数的初始化列表上，以此实现调用基类的构造函数来为子类从基类继承的成员变量初始化。

```cpp
#include <iostream>
using namespace std;
// 基类
class Shape
{
  public:
Shape(int w,int h)
   {
    width=w;
    height=h;
   }
  protected:
   int width;
   int height;
};
// 派生类
class Rectangle: public Shape
{
  public:
```

   Rectangle(int a,int b):Shape(a,b)

```cpp
   {
```

​

```cpp
   }
};
```

派生类在继承基类的成员变量时，会单独开辟一块内存保存基类的成员变量，因此派生类自己的成员变量即使和基类的成员变量重名，但是也不会引起冲突。如下代码：

```cpp
#include <iostream>
using namespace std;
// 基类
class A
{
public:
  A(){n = 0;};
  ~A(){};
  int getA(){ return n;};
  void setA(int t){ n = t;};
private:
  int n;
};
// 派生类
class B :public A
{
public:
  B(){ n = 0;};
  ~B(){};
  int getB(){ return n;};
  void setB(int t){ n = t;};
private:
 int n;
};
int main(int argc, char * argv[])
{
  B b;
  b.setA(10); // 设置基类的成员变量n
  cout<<"A::n "<<b.getA()<<endl;
  cout<<"B::n "<<b.getB()<<endl;
  b.setB(9); // 设置派生类的成员变量n
  cout<<"A::n "<<b.getA()<<endl;
  cout<<"B::n "<<b.getB()<<endl;
  return 0;
}
```

结果如下：

A::n 10

B::n 0

A::n 10

B::n 9


构造函数调用顺序：基类 > 成员类 > 派生类；

多继承派生类： 基类构造顺序 依照 基类继承顺序调用

类成员：依照 类成员对象 定义顺序 调用成员类构造函数

```cpp
#include <iostream>
using namespace std;
class Shape { // 基类 Shape
public:
  Shape() {
    cout << "Shape" << endl;
  }
  ~Shape() {
    cout << "~Shape" << endl;
  }
};
class PaintCost { // 基类 PaintCost
public:
  PaintCost() {
    cout << "PaintCost" << endl;
  }
  ~PaintCost() {
    cout << "~PaintCost" << endl;
  }
};
// 派生类
class Rectangle : public Shape, public PaintCost // 基类构造顺序 依照 继承顺序
{
public:
  Rectangle() :b(), a(), Shape(), PaintCost(){
    cout << "Rectangle" << endl;
  }
  ~Rectangle() {
    cout << "~Rectangle" << endl;
  }
  PaintCost b; // 类成员变量构造顺序 依照 变量定义顺序
  Shape a;
};
int main(void)
{
  Rectangle Rect;
  return 0;
}
```

结果：

Shape

PaintCost

PaintCost

Shape

Rectangle

~Rectangle

~Shape

~PaintCost

~PaintCost

~Shape


## 构造与析构顺序

1、 对于两个独立的类，构造函数和析构函数的顺序相反

```cpp
#include <iostream>
using namespace std;
class A
{
public:
  A() { cout << "Agouzao\n"; }
  ~A() { cout << "Axigou\n"; }
};
class B
{
public:
  B() { cout << "Bgouzao\n"; }
  ~B() { cout << "Bxxigo\n"; }
};
int main()
{
  A a; // 先定义
  B b; // 后定义
  return 0;
}
```

Agouzao

Bgouzao

Bxxigo

Axigou

2、 单继承下，对于基类、成员类和派生类的构造函数，也是构造函数和析构函数相反

```cpp
using namespace std;
#include <iostream>
class Member
{
public:
  Member() { cout << "Membergouzao\n"; }
  ~Member() { cout << "Memberxigou\n"; }
};
class Base
{
public:
  Base() { cout << "Basegouzao\n"; }
  ~Base() { cout << "Basexigou\n"; }
};
class Derived : public Base
{
  Member m; // 成员对象
public:
  Derived() { cout << "Derivedgouzao\n"; }
  ~Derived() { cout << "Derivedxigou\n"; }
};
int main()
{
  Derived d;
  return 0;
}
```

Basegouzao

Membergouzao

Derivedgouzao

Derivedxigou

Memberxigou

Basexigou

3、 多继承下在2的基础上

**构造顺序**：按继承声明顺序调用基类构造函数
 **析构顺序**：按继承声明逆序调用基类析构函数、

4**成员对象的析构顺序**

**构造顺序**：按成员声明顺序调用构造函数
 **析构顺序**：按成员声明逆序调用析构函数

**5. 为什么析构顺序要与构造顺序相反？**

1. **资源依赖**：派生类可能依赖基类或成员对象的资源，必须先释放派生类自己的资源。
2. **栈式管理**：C++对象生命周期遵循栈的规则（后进先出）。
3. **安全性**：避免悬空指针或资源泄漏（例如派生类析构时若基类已销毁，访问基类成员会导致未定义行为）。

6、程序执行结束前，调用析构函数将数组中各个对象元素释放，释放顺序与创建对象的顺序相反。


基类指针指向派生类对象时，如果基类析构函数不是虚函数，只会调用基类的析构函数。

```cpp
#include <iostream>
using namespace std;
class A {
public:
  A() { cout << "A"; }
  ~A() { cout << "~A"; }
};
class B : public A {
public:
  B() { cout << "B"; }
  ~B() { cout << "~B"; }
};
int main() {
  A *a = new B();
  delete a;
  return 0;
}
```

同名覆盖原则

派生类覆盖基类


## 赋值兼容原则

在公有继承下，派生类或子孙类对象也是一种特殊的基类对象，具有基类对象的属性和公有函数。因此，在需要基类对象的场合，派生类对象或子孙类对象也可以满足需要。这称为赋值兼容原则。

、对于对象指针类型。指针变量类型用于存放对象的地址，指向对象。

指针类型变量可以指向本类对象，还允许基类指针变量指向派生类对象或子孙类对象，但不可以指向祖先类对象；

基类指针变量作为形参时，实参可以是指向本类对象那个的指针、指向派生类对象或子孙类对象的指针，不可以是在祖先类对象的指针。

函数对象返回对象指针类型时，函数可以返回本类对象的指针，派生类对象或子孙类对象的指针，但不可以返回祖先类对象的指针。

赋值时，可以给本类对象指针类型的变量赋值本类对象指针、派生类对象指针或子孙类对象指针，但不可以将祖先类对象的指针赋值给子孙类对象指针类型的变量。

首先考虑率对象指针类型。

赋值兼容原则指出：

1、对于对象指针类型。指针变量类型用于存放对象的地址，指向对象。

指针类型变量可以指向本类对象，还允许基类指针变量指向派生类对象或子孙类对象，但不可以指向祖先类对象（即将祖先类对象的指针赋值给基类指针）；

“指向“的意思即可以将此类对象的指针赋值给此类指针变量

即：

基类指针变量作为形参时，实参可以是指向本类对象的指针、指向派生类对象或子孙类对象的指针，不可以是在祖先类对象的指针。

函数对象返回本类对象指针类型时，函数可以返回本类对象的指针，派生类对象或子孙类对象的指针，但不可以返回祖先类对象的指针。

赋值时，可以给本类对象指针类型的变量赋值本类对象指针、派生类对象指针或子孙类对象指针，但不可以将祖先类对象的指针赋值给子孙类对象指针类型的变量。（？这句话有问题）

基类指针可以指向派生类对象（向上转型，“上“指的是派生类对象指针可以向上转型到基类指针，安全，因为派生类必然包含基类部分）

派生类指针不能指向基类对象（向下转型，“下“指的是基类指针不能向下转型到派生类指针，不安全，因为基类可能不包含派生类的扩展部分）

![img](data:image/png;base64,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)

```cpp
class Base { /* ... */ };
class Derived : public Base { /* ... */ };
Base *pBase; // 基类指针
Derived objDerived;
pBase = &objDerived; // ✅ 合法：基类指针指向派生类对象
Derived *pDerived;
Base objBase;
pDerived = &objBase; // ❌ 错误：派生类指针不能指向基类对象
pDerived = static_cast<Derived*>(&objBase); // ⚠️ 危险！仅当确定 objBase 实际是 Derived 时才安全
pDerived = dynamic_cast<Derived*>(&objBase); // ✅ 更安全（但 objBase 必须是多态类，即含虚函数）
#include <iostream>
using namespace std;
class Animal {
public:
  virtual void speak() { cout << "Animal sound\n"; }
};
class Dog : public Animal {
public:
  void speak() override { cout << "Woof!\n"; }
  void fetch() { cout << "Fetching stick\n"; }
};
int main() {
  Animal *pAnimal; // 基类指针
  Dog dog; // 派生类对象
  pAnimal = &dog; // ✅ 合法：基类指针指向派生类对象
  pAnimal->speak(); // 输出 "Woof!"（多态调用）
// pAnimal->fetch(); ❌ 错误：Animal 类没有 fetch() 方法
}
```

基类指针接收派生类指针，实参是派生类指针

```cpp
void makeSound(Animal *pAnimal) {
  pAnimal->speak();
}
int main() {
  Dog dog;
  makeSound(&dog); // ✅ 合法：传递派生类指针给基类指针参数
}
```

函数返回基类指针（实际上返回派生类指针）

```cpp
Animal* createAnimal(bool isDog) {
  if (isDog) {
    return new Dog(); // ✅ 合法：返回派生类指针
  }
  return new Animal();
}
int main() {
  Animal *pAnimal = createAnimal(true);
  pAnimal->speak(); // 输出 "Woof!"
  delete pAnimal;
}
```

对象切片问题。call()参数按值传递，生成的是A的副本，虚函数机制失效。


C++可以将对象赋值给同类对象变量，与前面讨论的对象指针、对象引用不同。

C++允许将对象赋值给基类变量，但实际复制到是基类的部分子对象，切片现象。

## 相关内容
- [[计算机系/C++/11 多态与虚函数|多态与虚函数]]

---

## 学习导航
- 上一篇：[[计算机系/C++/09 运算符重载|运算符重载]]
- 返回目录：[[C++ 学习指南]]
- 下一篇：[[计算机系/C++/11 多态与虚函数|多态与虚函数]]