C++运行时选择子类后通过基类指针调用独有方法的方案咨询

这类场景的核心矛盾是需要统一存储多态实例，同时需要调用子类独有的非公共接口，避免冗长的手动动态类型判断，常用的通用实现方案有以下4种，各有适用场景： #

核心是通过双分派把类型判断的逻辑交给编译器处理，不需要手动写转型分支，尤其适合硬件访问、固定数据类型集合这类子类数量不会频繁变动的场景。
改造后代码示例：

#include <iostream>
#include <memory>

using namespace std;

class A;
class B;

// 访问者基类，定义所有子类的访问接口
class BaseVisitor {
public:
    virtual void visit(A* a) = 0;
    virtual void visit(B* b) = 0;
    virtual ~BaseVisitor() = default;
};

// 原基类新增accept接口
class Base
{
public:
    virtual void shared()=0;
    virtual void accept(BaseVisitor* visitor) = 0;
    virtual ~Base() = default;
};

class A : public Base
{
public:
    void shared() override
    {
        cout << "do A stuff\n";
    }
    
    void methodUniqueToA()
    {
        cout << "stuff unique to A\n";
    }

    void accept(BaseVisitor* visitor) override {
        visitor->visit(this);
    }
};

class B : public Base
{
public:
    void shared() override
    {
        cout << "do B stuff\n";
    }
    
    void methodUniqueToB()
    {
        cout << "stuff unique to B\n";
    }

    void accept(BaseVisitor* visitor) override {
        visitor->visit(this);
    }
};

// 自定义操作的访问者，实现对应类型的独有逻辑
class OpVisitor : public BaseVisitor {
public:
    void visit(A* a) override {
        a->methodUniqueToA();
    }
    void visit(B* b) override {
        b->methodUniqueToB();
    }
};

int main()
{
    shared_ptr<Base> basePtr = make_shared<A>();
    basePtr->shared();
    
    OpVisitor op;
    basePtr->accept(&op);
    return 0;
}

• 优点：完全符合多态设计，类型安全，无手动转型，新增操作只需要新增访问者子类即可
• 缺点：新增子类时需要修改所有访问者基类的接口，仅适合子类数量固定的场景

如果不需要强继承约束，也可以用标准库的类型安全联合体存储不同子类实例，通过visit自动匹配对应类型的处理逻辑：

#include <iostream>
#include <variant>
#include <memory>
#include <type_traits>

using namespace std;

class A
{
public:
    void shared()
    {
        cout << "do A stuff\n";
    }
    
    void methodUniqueToA()
    {
        cout << "stuff unique to A\n";
    }
};

class B
{
public:
    void shared()
    {
        cout << "do B stuff\n";
    }
    
    void methodUniqueToB()
    {
        cout << "stuff unique to B\n";
    }
};

using InstanceType = variant<unique_ptr<A>, unique_ptr<B>>;

int main()
{
    InstanceType instance = make_unique<A>();
    // 调用公共方法
    visit([](auto& ptr){ ptr->shared(); }, instance);
    // 调用独有方法
    visit([](auto& ptr){
        using T = typename decay_t<decltype(ptr)>::element_type;
        if constexpr (is_same_v<T, A>) {
            ptr->methodUniqueToA();
        } else if constexpr (is_same_v<T, B>) {
            ptr->methodUniqueToB();
        }
    }, instance);
    return 0;
}

• 优点：不需要继承体系，无虚函数开销，代码简洁易维护，类型判断在编译期完成
• 缺点：需要C++17及以上版本支持，子类数量过多时variant定义会比较冗长

如果场景非常简单，只有2-3个子类且后续不会新增，可以优化你原本的写法，避免重复转型：

int main()
{
    shared_ptr<Base> basePtr = make_shared<A>();
    basePtr->shared();
    
    if (auto a = dynamic_pointer_cast<A>(basePtr)) {
        a->methodUniqueToA();
    } else if (auto b = dynamic_pointer_cast<B>(basePtr)) {
        b->methodUniqueToB();
    } else {
        throw runtime_error("unsupported type");
    }
    return 0;
}

• 优点：改造成本最低，逻辑直观
• 缺点：不符合开闭原则，新增子类必须修改分支逻辑，子类多时代码冗余严重

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