如何通过基类指针容器访问C++派生类的专属方法？

问题重现 #

我创建了基类Base和三个派生类A、B、C，用存储Base*的vector存放这些派生类的动态对象，但无法通过容器访问派生类的专属方法（比如C类的getSobregarga），相关代码如下：

#include <iostream>
#include <vector>
#include <ctime>
using namespace std;

class Base{
protected:
    string placa;
    int ano_de_registro;
public:
    Base(){};
    Base(string _placa, int _ano_de_registro):placa(_placa),ano_de_registro(_ano_de_registro){};

    const string &getPlaca() const {
        return placa;
    }

    int getAnoDeRegistro() const {
        return ano_de_registro;
    }

};

class A: public Base{
    int cubicaje;
    int caballos_de_fuerza;
    int contaminacion;//0==minimo, 1==normal y 2==excesivo

public:
    A(){};
    A(string _placa, int _ano_de_registro, int _cubicaje, int _caballos_de_fuerza, int _contaminacion):Base(_placa,_ano_de_registro),cubicaje(_cubicaje),caballos_de_fuerza(_caballos_de_fuerza),contaminacion(_contaminacion){};

    int getCubicaje()  {
        return cubicaje;
    }

    int getCaballosDeFuerza()  {
        return caballos_de_fuerza;
    }

    int getContaminacion()  {
        return contaminacion;
    }

};

class B: public Base{
    int cubicaje;
public:
    B(){};
    B(string _placa, int _ano_de_registro, int _cubicaje):Base(_placa,_ano_de_registro),cubicaje(_cubicaje){};

    int getCubicaje() const {
        return cubicaje;
    }
};


class C: public Base{
    int cantidad_de_ejes;
    int sobregarga;
public:
    C(){};
    C(string _placa, int _ano_de_registro,int _cantidad_de_ejes, int _sobregarga):C(_placa,_ano_de_registro),cantidad_de_ejes(_cantidad_de_ejes),sobregarga(_sobregarga){};

    int getCantidadDeEjes() {
        return cantidad_de_ejes;
    }

    int getSobregarga() const {
        return sobregarga;
    }
};


int main() {
    srand(time(NULL));
    int a1,c1,c2,sc,cb,ct,cde, r1, vs;
    vector<string> Placas={"A1R 112","F5U-597","A1A-004","D5B-193","EUA-123","A8D-457","FCD-784","F0X-694","SLA-249","EBD-608",};
    vector<Base*> Vehiculos;
    for (int i=0;i<10;i++){
        r1=rand()%3;
        vs=rand()%Placas.size();
        a1=rand()%22+2000;
        c1=rand()%10;
        c2=rand()%10;
        cb=rand()%10;
        ct=rand()%3;
        cde=rand()%4+3;
        sc=rand()%10;
        A* carro=new A(Placas.at(vs),a1,c1,cb,ct);
        Vehiculos.push_back(carro);
    
        B* moto=new B(Placas.at(vs),a1,c2);
        Vehiculos.push_back(moto);

        C* camion=new C(Placas.at(vs),a1,cde,sc);
        Vehiculos.push_back(camion);
    }

    Vehiculos.at(0)->getSobrecarga;
    return 0;
}

核心原因 #

vector中存储的是Base*类型指针，C++的静态类型检查机制会认为指针指向的是Base类对象，因此只能调用Base类中定义的方法，派生类的专属方法在编译阶段是不可见的。

解决方案 #

1. 使用dynamic_cast进行安全类型转换 #

dynamic_cast可以在运行时检查指针的实际指向类型，转换成功后即可调用派生类专属方法。使用前需要给基类添加至少一个虚函数（通常添加虚析构函数，同时避免内存泄漏）：

步骤1：修改Base类添加虚析构

class Base{
protected:
    string placa;
    int ano_de_registro;
public:
    Base(){};
    Base(string _placa, int _ano_de_registro):placa(_placa),ano_de_registro(_ano_de_registro){};
    // 添加虚析构函数，满足多态要求
    virtual ~Base() = default;

    const string &getPlaca() const {
        return placa;
    }

    int getAnoDeRegistro() const {
        return ano_de_registro;
    }
};

步骤2：使用dynamic_cast访问专属方法

int main() {
    // ... 原有代码省略

    // 遍历容器访问派生类方法
    for (auto* vehiculo : Vehiculos) {
        // 判断是否为C类对象
        if (C* camion = dynamic_cast<C*>(vehiculo)) {
            cout << "Sobregarga: " << camion->getSobregarga() << endl;
        }
        // 同理处理A类
        else if (A* carro = dynamic_cast<A*>(vehiculo)) {
            cout << "Contaminacion: " << carro->getContaminacion() << endl;
        }
        // 处理B类
        else if (B* moto = dynamic_cast<B*>(vehiculo)) {
            cout << "Cubicaje moto: " << moto->getCubicaje() << endl;
        }
    }

    return 0;
}

2. 利用多态（虚函数）统一接口 #

如果派生类的专属方法有统一的业务逻辑（比如都需要输出自身信息），可以在Base类中定义纯虚函数，派生类各自实现：

class Base{
    // ... 原有成员
public:
    virtual ~Base() = default;
    // 纯虚函数，强制派生类实现
    virtual void mostrarInformacion() const = 0;
    // ... 原有方法
};

// A类实现
class A: public Base{
    // ... 原有成员
public:
    void mostrarInformacion() const override {
        cout << "[Carro] Placa: " << placa << ", Ano: " << ano_de_registro 
             << ", Contaminacion: " << contaminacion << endl;
    }
};

// C类实现
class C: public Base{
    // ... 原有成员
public:
    void mostrarInformacion() const override {
        cout << "[Camion] Placa: " << placa << ", Ano: " << ano_de_registro 
             << ", Sobregarga: " << sobregarga << endl;
    }
};

之后直接通过Base*调用mostrarInformacion()，会自动执行对应派生类的实现：

for (auto* vehiculo : Vehiculos) {
    vehiculo->mostrarInformacion();
}

代码中其他错误修复 #

1. C类构造函数递归调用问题：
   原C类构造函数中C(_placa,_ano_de_registro)是递归调用自身，应改为调用基类构造函数：

C(string _placa, int _ano_de_registro,int _cantidad_de_ejes, int _sobregarga)
    : Base(_placa,_ano_de_registro), cantidad_de_ejes(_cantidad_de_ejes), sobregarga(_sobregarga) {};

2. 方法调用的拼写与语法错误：
   原代码中Vehiculos.at(0)->getSobrecarga;存在两个问题：

• 拼写错误：方法名应为getSobregarga（与C类定义一致）
• 方法调用需加括号：getSobregarga()

内容的提问来源于stack exchange，提问作者salinsuwu