C++继承与多态详解-优快云博客

本文链接：https://blog.youkuaiyun.com/YiHeboy/article/details/126128921

本文详细介绍了C++中的继承概念，包括继承方式、继承的意义、子类对象的特性，以及子类构造函数、析构函数、拷贝构造和拷贝赋值的使用。此外，还探讨了名字冲突（隐藏）的问题。在多态部分，文章讲解了虚函数、覆盖、重载和隐藏的区别，以及多态的概念和虚析构函数的作用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

继承

在定义一个类的同时，可以继承另外一个类，继承即继承父类的属性以及方法

class Shape{
private:
    int x;
    int y;
public:
    Shape(int x = 0, int y = 0):x(x), y(y){}
    
};
//以下的Circle类继承了Shape类
class Circle: public Shape{
    
};

int main()
{
    Circle c;//实例化时，c拥有Shape的属性和方法
}

被继承的类称为父类（基类），继承自父类的类称为子类（派生类）

继承之后，子类拥有父类的属性和方法

C++允许多继承，一个子类继承多个父类，每个父类的继承方式可以不一样

class sam:继承方式1 基类1， 继承方式2 基类2， 继承方式3 基类3.....{

};

继承方式：

public 公开继承
protected 保护继承
private 私有继承
1. class缺省默认的继承方式private 缺省的访问控制属性 private
2. struct缺省默认继承方式是public 缺省的访问控制属性 public
继承方式对于继承的影响
- public公开继承
  - 把父类中public的属性继承到子类中依然在子类中属于public
  - 把父类中protected的属性继承到子类中依然是protected的属性
  - 把父类中private的属性继承到子类中依然是private的属性(子类中不可以访问)
- protected保护继承
  - 把父类中public的属性继承到子类中为protected的属性
  - 把父类中protected的属性继承到子类中保留protected的属性
  - 把父类中private的属性继承到子类中依然是private的属性(子类中不可以访问)
- private 私有继承
  - 把父类中public的属性继承到子类中为子类private属性
  - 把父类中protected的属性继承到子类中为private属性
  - 把父类中private的属性继承到子类中为private属性(子类不可以访问)

子类中的访问属性	父类public	父类中protected	父类中private
public继承	public	protected	private(子类不可访问)
protected继承	protected	protected	private(子类不可访问)
private继承	private	private	private(子类不可访问)

public公开继承	父类	本类继承父类	本类的子类	类外
public	可以	可以	可以	可以
protected	可	可	可	不行
private	可	不可	不可	不可

protected继承	父类	本类继承父类	本类的子类	类外
public	可以	可以	可以	不可
protected	可	可	可	不行
private	可	不可	不可	不可

private 继承	父类	本类继承父类	本类的子类	类外
public	可以	可以	不行	不行
protected	可	可	不行	不行
private	可	不可	不可	不可

继承的意义：

复用父类的代码

同时可以扩展父类功能

为多态提供基础

继承关系的本质

is A 的关系

子类拥有父类的全部属性和方法
- 一个对象拥有类一个对象的属性和方法，可以认为该对象就是这个类实例的对象
- 如：人类男人类继承人类女人类继承人类
  - 男人男人类的对象，也是人类的对象
子类时父类集合中的一个子集

class 类：继承列表{
   	 
};

子类对象

子类对象拥有父类全部的属性，但是如果父类中的属性为private的，子类虽然拥有，但是无法访问

子类对象在存储时，遵循对齐补齐原则

子类对象中存在基类对象，称为基类子对象

如果只有一个基类子对象时，那么所有的成员一起对齐补齐，当子类对象拥有多个基类子对象时，那么每个基类子对象会逐个进行对齐补齐

在多继承中，子类对象会按照继承顺序在子类对象中形成多i个基类子对象

子类 is A 父类对象

子类类型的指针都可以隐式转换为父类类型的指针，可以用父类类型的指针指向子类
子类类型的引用，都可以隐式转换为父类类型的引用可以用父类类型的引用引用子类对象
父类 *p = &子类对象事实上p指向的时父类类类型的基类子对象，可能和&子类对象的内存地址不一致，可能存在内存偏移，特别是多个基类子对象
父类 &r = 子类对象事实上r引用的时父类在子类对象中的基类子对象
父类 obj = 子类对象; obj 实际上是通过基类子对象拷贝构造的 obj是新构造的对象
obj = 子类对象用基类子对象给父类类型对象赋值

class A{
    char a;
};
class B {
	int b;
};
class C{
    char c;
};
class D:A,B,C{
    
}
int main()
{
	D d;
	A *pa = &d;
	B *pb = &d;
	C *pc = &d;

	A& ra = d;
	B& rb = d;
	C& rc = d;
}

子类/派生类的构造函数、析构函数、拷贝构造、拷贝赋值

子类构造函数

子类的构造函数，不论是自己提供的还是编译器提供的，会默认按继承顺序依次调用父类的无参构造函数用于构造基类子对象
如果父类中没有无参构造函数，或者需要显示调用父类中的构造函数，则需要在子类构造函数初始化列表中指明调用父类的有参构造。：父类名（实参列表）
构造函数的执行顺序：
1.按继承顺粗依次调用父类的构造函数构造基类子对象

2.按类类型成员的定义顺序，依次调用类类型成员的构造函数构造成员对象

3.调用构造体

子类的析构函数

子类的析构函数会默认调用父类的析构函数，用于析构该基类子对象

子类的析构函数也会默认调用类类型成员的析构函数用于析构成员对象

析构函数的执行顺序和构造函数的执行顺序相反

子类的拷贝构造

子类默认的拷贝构造函数会按照继承顺序，依次调用父类的拷贝构造函数拷贝基类子对象，然后按成员中类类型的拷贝构造函数按照定义顺序依次调用

如果自己实现子类拷贝构造函数，需要注意拷贝基类子对象和成员对象

需要在拷贝构造函数的初始化列表中显式调用父类的拷贝构造函数和成员的拷贝构造函数

class s:public f1, public f2{
private:
    A a;
    B b;
    C c;
public:
    s(){}
    s(const s& ss):f1(ss), f2(ss), a(ss.a), b(ss.b){}
    s& operator = (const s &ss){
        f1::operator=(ss);
        f2::operator=(ss);
        a = ss.a;
        b = ss.b;
        c = ss.c
    }
}

子类的拷贝赋值函数

子类默认的拷贝赋值函数，按照继承吮吸依次调用父类的拷贝赋值函数，然后按成员的定义顺序依次调用类类型成员的拷贝复制函数
如果自己实现子类的拷贝赋值函数，则需要手动调用父类的拷贝赋值函数和类类型成员的拷贝构造函数

因为是手动实现的，所以先后顺序不一定和默认相同

子类移动构造

子类移动赋值

名字冲突 — 隐藏

子类中同名的属性和函数会隐藏父类中同名的属性和函数（还有虚函数可以会覆盖，这种情况目前不考虑）
子类中的函数和从父类中继承下来的函数不会构造重载，即使函数名相同，参数列表不同也不会构造重载
隐藏 — 子类中隐藏父类中同名的属性和方法
解隐藏
- 子类对象.父类名::属性子类对象.父类名::方法名
- this->父类名::属性 this->父类名::方法名

用父类指针指向子类对象

事实上指向的是基类子对象，和真正的子类会存在一些内存偏移
用父类指针指向子类对象时，只能访问父类的成员，调用父类的方法
父类类型指针，指向子类对象时，不能直接隐式转换为子类类型的指针
- 静态类型转换 static_cast<> 能计算子类类型的起始地址
- 强制类型转化（）能计算子类类型的起始地址
- 重解释类型转换 reinterpret_cast<>不能正确得到子类对象的内存地址，地址不会偏移

父类指针 *p = new 子类对象（）;

此时delete p

父类指针是继承的第一个父类，只会调用该父类的析构函数，造成内存泄漏
父类指针不是继承第一个父类，则会引发段错误

在释放时，需要通过类型转换为子类类型

delete （子类*)p；
delete static_cast<子类*>p;

用父类类型的引用引用子类对象

事实上引用的是子类对象中的基类子对象
用父类类型的引用引用子类对象时，只能引用父类类型中的属性和方法
子类类型的引用可以隐式转换为父类类型的引用，
反之则必须用静态类型转换才能正确计算子类类型的位置

多态

虚函数 virtual

一个类的成员函数可以声名为虚函数，即在该函数前加virtual
- 全局函数、构造函数、静态函数、内联函数不能声名为虚函数
- 析构函数可以声名为虚函数，且往往会这样做
一个函数若声名为虚函数，则子类可以在继承这个类时，可以为该虚函数提供覆盖的版本
- 重写虚函数

覆盖（重写）

子类重写父类中同类型的虚函数
- 同父类中函数为虚函数，子类重写的版本也为虚函数（子类中可不加virtual）
- 函数名相同
- 参数列表相同
  - 对于常规类型，是否有const都能构成覆盖
  - 对于指针和引用类型，常属性不能构成覆盖
- 返回值类型相同
  - 基础数据类型/类类型-----------》必须相同
  - 如果是类类型的指针或引用，子类重写版本的返回值类型可以是父类返回值类型的子类类型
  - 函数的常属性必须一致
  - 子类重写版本不能声名更多的异常声名

重载、隐藏、覆盖的区别

重载overload：要求载同一个作用域下，函数名相同，参数列表不同

需要同一个类里面定义的成员函数，函数名相同，与virtual无关，与返回值无关，参数列表不同

隐藏：如果父类中的同名函数不是虚函数，不论参数列表和返回值类型，都构成隐藏

如果父类中的函数是虚函数，除了覆盖的情况，都构成隐藏

覆盖override：是子类覆盖父类中同名的虚函数，

一定是子类覆盖父类的虚函数，若父类中的函数不是虚函数则构不成覆盖
要求覆盖版本的函数函数名相同，返回值类型（如果是类类型的指针或引用，子类重写版本的返回值类型可以是父类返回值类型的子类类型的指针或者引用），参数列表相同（常规/指针、引用），函数的常属性相同
若覆盖版本的函数名相同，参数列表相同，则会对返回值类型有要求，不满足则报错