如何通过父类类型指针访问派生类成员？避免频繁使用dynamic_cast

先明确你的场景结构：

class A { };

class B : public A
{
private:
    int Bvalue{};
};

class C
{
private:
    A* ptr{};
};

当C::ptr指向B对象时，你希望避免每次访问Bvalue都调用dynamic_cast，同时觉得让A返回默认0的虚函数方案不够合理，以下是几种可行的解决思路：

1. 提前转换并缓存派生类指针 #

在C类中额外维护一个B*类型的缓存指针，仅在设置ptr时执行一次类型转换，后续直接使用缓存指针访问Bvalue。这种方法把类型转换的开销从每次访问降到一次初始化：

class C
{
private:
    A* ptr{};
    B* cachedBPtr{}; // 缓存B类型指针

public:
    void setPtr(A* newPtr) {
        ptr = newPtr;
        // 仅在设置指针时执行一次dynamic_cast
        cachedBPtr = dynamic_cast<B*>(ptr);
    }

    // 安全访问Bvalue的方法
    int getBvalue() const {
        if (cachedBPtr) {
            return cachedBPtr->Bvalue;
        }
        // 处理ptr不是B对象的情况，比如抛出异常或返回合理默认值
        throw std::runtime_error("ptr does not point to a B object");
    }
};

注意：要确保ptr的生命周期和cachedBPtr同步，避免悬空指针问题。

2. 使用访问者模式 #

如果你的类层次可能扩展（比如后续会有更多A的派生类），访问者模式可以彻底消除类型转换，让派生类自己处理成员访问逻辑：
首先定义访问者基类和A类的accept接口：

class B; // 前置声明

class Visitor {
public:
    virtual void visit(B* b) = 0;
    // 如果有其他派生类，这里添加对应的visit重载
};

class A {
public:
    virtual void accept(Visitor& visitor) = 0;
    virtual ~A() = default; // 基类必须有虚析构函数
};

然后让B类实现accept方法：

class B : public A
{
private:
    int Bvalue{};
public:
    void accept(Visitor& visitor) override {
        visitor.visit(this);
    }

    // 提供访问Bvalue的接口（因为要给Visitor访问，所以设为public或友元）
    int getBvalue() const { return Bvalue; }
};

最后在C类中通过访问者获取Bvalue：

class BValueVisitor : public Visitor {
private:
    int result{};
public:
    void visit(B* b) override {
        result = b->getBvalue();
    }

    int getResult() const { return result; }
};

class C
{
private:
    A* ptr{};
public:
    int getBvalue() const {
        BValueVisitor visitor;
        ptr->accept(visitor);
        return visitor.getResult();
    }
};

这种方法的优势是类型安全，且后续扩展派生类时只需添加对应的visit重载，无需修改现有逻辑。

3. 重新设计类层次（最优雅的方案） #

你之前尝试的虚函数方案问题在于A返回默认0不合理，正确的做法是把getBvalue设计为纯虚函数，强制所有派生类实现该接口，避免无意义的默认值：

class A {
public:
    // 纯虚函数，要求所有派生类必须实现
    virtual int getBvalue() const = 0;
    virtual ~A() = default; // 基类必须有虚析构函数
};

class B : public A
{
private:
    int Bvalue{};
public:
    int getBvalue() const override {
        return Bvalue;
    }
};

如果某些派生类不需要Bvalue，可以让它们抛出异常或者返回std::optional<int>来明确表示"无此值"，比返回0更符合语义：

#include <optional>

class A {
public:
    virtual std::optional<int> getBvalue() const = 0;
    virtual ~A() = default;
};

class B : public A
{
private:
    int Bvalue{};
public:
    std::optional<int> getBvalue() const override {
        return Bvalue;
    }
};

// 假设有另一个派生类D
class D : public A
{
public:
    std::optional<int> getBvalue() const override {
        return std::nullopt; // 明确表示无此值
    }
};

这种方案从根源上消除了类型转换的需求，是面向对象设计中最合理的做法。

内容的提问来源于stack exchange，提问作者Tripotin D. Muel