当前位置：首页 > news >正文

C++ 多态和虚函数

news 2025/11/4 16:55:00

参考C++：多态详解_c++多态-CSDN博客

C++多态——虚函数_c++的a* a = new b()是什么意思-CSDN博客

一.多态的概念

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如 Student 继承了 Person。 Person 对象买票全价， Student 对象买票半价。

二.多态的定义及实现

2.1 重写/覆盖（动态多态）

重写/覆盖：子类中有一个跟父类完全相同的虚函数，子类的虚函数重写了基类的虚函数
即：子类父类都有这个虚函数 + 子类的虚函数与父类虚函数的函数名/参数/返回值都相同 -> 重写/覆盖（注意：参数只看类型是否相同，不看缺省值）

2.1.1 两个要求

被调用的函数必须是虚函数，子类对父类的虚函数进行重写（重写：三同（函数名/参数/返回值）+虚函数）
父类指针或者引用去调用虚函数。

2.1.2 虚函数

常见使用方法：

A *a = new B();
a->func();// 在这里，a虽然是指向A的指针，但是被调用的函数(func)却是B的!

若func()为虚函数，则优先调用B中的func()

若func()为不为虚函数，则优先调用A中的func()

若A *c = *a；c->func()；同上

若A d = *a；d.func()；则只执行A中的func() 原因：强制转化为A对象的空间，和B无关。

#include <iostream>
using namespace std;
class A{
public:virtual void Who(){cout << "I'm A" << endl;cout << "*********************************" << endl;}
};
class B :public A{
public:virtual void Who(){cout << "I'm B" << endl;cout << "*********************************" << endl;}
};
void test(A *a){cout << "test *a" << endl;a->Who();
}
void test(B *b){cout << "test *b" << endl;b->Who();
}void test(A a){cout << "test a" << endl;a.Who();
}
void test(B b){cout << "test b" << endl;b.Who();
}
int main(){B b;A *a = &b;				//等同于：A *a = new B();a->Who();				//输出 I'm Bb.Who();				//输出 I'm Btest(a);				//调用test(A *a),输出 I'm Btest(*a);				//调用test(A a),输出 I'm Atest(b);				//调用test(B b),输出 I'm Btest(&b);				//调用test(B *b),输出 I'm B
}

只需要在父类中使用virtual关键字即可

class A{
public:virtual void foo();
};class B: public A{
public:void foo();    // 没有virtual关键字!
};class C: public B{  // 从B继承，不是从A继承！
public:void foo();    // 也没有virtual关键字！
};

这种情况下，B::foo()是虚函数，C::foo()也同样是虚函数。因此，可以说， 基类声明的虚函数，在派生类中也是虚函数，即使不再使用virtual关键字。

class A{
public:void foo() { bar();}
private:virtual void bar() { ...}
};class B: public A{
private:virtual void bar() { ...}
};

在这个例子中，虽然bar()在A类中是private的，但是仍然可以出现在派生类中，并仍然可以与public或者protected的虚函数一样产生多态的效果。并不会因为它是private的，就发生A::foo()不能访问B::bar()的情况，也不会发生B::bar()对A::bar()的override不起作用的情况。

这种写法的语意是：A告诉B，你最好override我的bar()函数，但是你不要管它如何使用，也不要自己调用这个函数。

2.1.3 纯虚函数

如下声明表示一个函数为纯虚函数：

class A{
public:virtual void foo()=0;   // =0标志一个虚函数为纯虚函数
};

一个函数声明为纯虚后，纯虚函数的意思是：我是一个抽象类！不要把我实例化！纯虚函数用来规范派生类的行为， 实际上就是所谓的“接口”。它告诉使用者，我的派生类都会有这个函数

2.1.4 虚析构函数

析构函数也可以是虚的，甚至是纯虚的。例如：

class A{
public:virtual ~A()=0;   // 纯虚析构函数
};

在继承下，为了使子类析构函数得到正常使用，需要降级类的析构函数设置为虚析构函数。考虑下面的例子：

class A{
public:A() { ptra_ = new char[10];}~A() { delete[] ptra_;}        // 非虚析构函数
private:char * ptra_;
};class B: public A{
public:B() { ptrb_ = new char[20];}~B() { delete[] ptrb_;}
private:char * ptrb_;
};void foo(){A *a = new B;delete a;
}

在这个例子中，程序也许不会象你想象的那样运行，在执行delete a的时候，实际上只有A::~A()被调用了，而B类的析构函数并没有被调用！这样会造成内存泄露。

如果将上面A::~A()改为virtual，就可以保证B::~B()也在delete a的时候被调用了。因此基类的析构函数都必须是virtual的。

纯虚的析构函数并没有什么作用，是虚的就够了。通常只有在希望将一个类变成抽象类（不能实例化的类），而这个类又没有合适的函数可以被纯虚化的时候，可以使用纯虚的析构函数来达到目的。