C++多态

Starry_hello_world

已于 2025-03-11 12:42:38 修改

阅读量963

点赞数 11

CC 4.0 BY-SA版权

分类专栏： C++ 文章标签： c++ 笔记有问必答

于 2025-02-12 08:00:00 首次发布

本文链接：https://blog.youkuaiyun.com/Starry_tsx/article/details/145548606

C++ 专栏收录该内容

56 篇文章

订阅专栏

1.虚函数

这个地方的虚函数的virtual和前面虚拟继承的关键字virtual没有任何关联

只有成员函数才可以变成虚函数

虚函数可以完成重写（覆盖）

虚函数就是在函数前面＋一个virtual

我们先来看这串代码很神奇

func接受Person匿名对象和Student的匿名对象的切片（接收类型是Person）

我们前面讲过

派生类的切片是不能调用派生类的函数也就是不能调用 Student::BuyTicket

也就是这个地方基类和派生类都只能调用基类的Person::BuyTicket;

但是调用的确是不同的BuyTicket

正常来说这个地方是p去调用BuyTicket()

但是这个地方p是Person类型所以按照隐藏来算调用的也应该是Person::BuyTicket;

但是这个地方我们不＋Student::它也会自动调用Student::BuyTicket

2.多态

多态的条件

1.调用函数重写的虚函数

2.基类指针或者引用

多态 :不同对象传过去调用不同函数

多态调用的是看的指向的对象

普通对象看到是它的类型！

重写的条件本来是虚函数+三同（返回值相同函数名相同参数相同）但是有一些例外

这个地方的三同不包括this指针

1.派生类的函数前面可以不＋virtual （但是最好还是加上）

2.协变返回值可以不同但是要求返回值必须是父子关系和引用

（1）必须同时是父子关系不可颠倒过来（）

比如：父类的virtual函数返回值子类子类的virtual函数返回值是父类不可以

（2）要同时为指针和引用不可以一个是指针一个是引用

（3）可以不是本身类的父子类比如如下图

void func(const Person& p)
{
	p.Person::BuyTicket();
}

指定调用也会导致多态不满足

3.析构函数

析构函数可以是虚函数吗？为什么要是虚函数？

析构函数＋virtual 是不是虚函数重写？

是因为析构函数都被处理成destructor这个统一的名字了

为什么要构成重写呢？看下面这种场景

这个地方我们为什么不会去调用派生类的析构函数？

delete 本质上是调用p的析构函数再调用 operator delete(p)

但是这个地方p是普通Person 类型所以它只会调用Person的析构函数

不会调用Student析构函数如果Student自己特有的指针没有通过Student析构函数释放就会导致内存泄漏

我们期望上面两个delete p能够调用正确的析构函数而不是像普通类型一样

去调用其类型所属的析构函数

我们期望Person类和Student类的析构函数是一个多态调用而不是普通调用

所以这个地方要构成多态就要构成重写

要构成重写原本的析构函数可不可以？

当然不可以（要求三同函数名不同）所以要统一处理成destructor

4.C++ 11 override和final

1.final :修饰虚函数不能再被重写

修饰类 +final的类叫最终类最终类不能被继承

2.override:检查派生类虚函数是否重写了某个虚函数，如果没有重写编译器会报错

5.重载，覆盖（重写），隐藏（重定义）的对比

6.虚函数表

这个地方为什么sizeof(Base)是8？

因为这个地方有虚函数指针+对齐

这个地方和虚继承无关

虚表里面存的是虚函数的地址

虚函数本质上还是被放在代码段的

我们来看一下重写！

如果被重写了Johnson的虚函数指针就变成重写的虚函数指针（也就是把原来的虚函数指针覆盖了）

原本Johnson（子类）应该是父类继承过来的虚表地址应该指向父类的虚函数

但是被重写覆盖成新的虚表地址指向的是子类的虚函数！

因此调用的是不同的虚函数！

多态的本质就是根据不同的虚表去调用不同的虚函数

子类就是把它的切片也就是子类中父类那一部分

无论是父类还是被切片的子类看起来都是一样的

普通调用在编译的时候确定地址

多态则在运行时到指向对象的虚函数表中找调用的函数地址

7. 设计不能被继承的类

如何设计出一个无法被继承的类？

思路1：

把构造函数/析构函数私有化（这里以构造函数为例）

class A
{
public:
	static A Creat()
	{
		return A();
	}
private:
	A()
	{
	}
};
int  main(void)
{
	A::Creat();
	return 0;
}

但是这个地方就引发了一个问题就是先有鸡还是先有蛋的问题？

这个地方是现有对象才能用Creat函数但是你要有对象就要先构造先调用Creat

静态的可以解决这个问题（上图和下图但是代码都是静态的方法）

#include <iostream>
using namespace std;
class A {
public:
    static A Creat() {
        return A();
    }
private:
    A() {}
};

class B {};

int main() {
    // 使用静态函数创建非匿名对象
    A nonAnonymousObj = A::Creat();
    return 0;
}

析构函数也可以

#include<iostream>
using namespace std;

class A {
public:
    static void Destroy(A* obj) {
        delete obj;
    }

private:
    ~A() {
        cout << "析构" << std::endl;
    }
};

int main() {
    A* p = new A;
    A::Destroy(p);
    p = nullptr;
    return 0;
}

#include <iostream>

class A {
public:
    void Destroy() {
       // delete this;  这两种方法本质上是一致的
        this->~A();
        operator delete(this);
    }
private:
    ~A() {
        std::cout << "析构" << std::endl;
    }
};

int main() {
    A* p = new A;
    p->Destroy();
    p = nullptr;
    return 0;
}

思路2：

最终类 +final