面向对象语言中如何实现按子类型分支处理的功能？

你需要实现的是典型的双分派需求：执行逻辑同时取决于参数的运行时类型和当前业务的具体实现，函数式语言的模式匹配原生支持这类场景，C++等面向对象语言可以通过两种成熟方案实现：

方案1：经典设计模式——访问者模式（Visitor Pattern） #

这是传统面向对象语言中解决这类问题的标准方案，核心是把「类型匹配+逻辑分派」的过程抽成抽象接口，解除业务逻辑和数据类的耦合。
你之前写的虚函数方案是访问者模式的雏形，只要把依赖抽象化就能解决耦合问题：
首先定义抽象访问者接口，所有对Animal的操作都通过这个接口声明，Animal只需要依赖这个抽象类，不需要知道具体业务实现：

class Cat;
class Dog;

class AnimalVisitor {
public:
    virtual ~AnimalVisitor() = default;
    virtual void visit(Cat* cat) = 0;
    virtual void visit(Dog* dog) = 0;
};

然后Animal类只需要声明accept接口，子类实现对应分派逻辑：

class Animal {
public:
    virtual ~Animal() = default;
    virtual void accept(AnimalVisitor* visitor) = 0;
};

class Cat : public Animal {
public:
    void accept(AnimalVisitor* visitor) override {
        visitor->visit(this);
    }
};

class Dog : public Animal {
public:
    void accept(AnimalVisitor* visitor) override {
        visitor->visit(this);
    }
};

最后AnimalManager内部实现具体的访问者处理add逻辑，完全不需要修改Animal体系的代码：

class AnimalManager {
private:
    // 内部实现的Add访问者，专门处理add的分支逻辑
    class AddVisitor : public AnimalVisitor {
    private:
        AnimalManager* m_manager;
    public:
        AddVisitor(AnimalManager* manager) : m_manager(manager) {}
        void visit(Cat* cat) override {
            m_manager->doThingsWithCats(cat);
        }
        void visit(Dog* dog) override {
            m_manager->doThingsWithDogs(dog);
        }
    };

    void doThingsWithCats(Cat* cat) { /* Cat专属add逻辑 */ }
    void doThingsWithDogs(Dog* dog) { /* Dog专属add逻辑 */ }
public:
    void add(Animal* animal) {
        AddVisitor visitor(this);
        animal->accept(&visitor);
    }
};

该方案完全符合开闭原则，新增对Animal的操作只需要新增对应的Visitor实现，不需要修改Animal体系的代码；Animal只依赖抽象的Visitor接口，不需要感知具体业务类的存在，解决了之前的耦合问题。

方案2：现代C++原生模式匹配（std::variant + std::visit） #

如果你使用C++17及以上版本，可以直接用标准库提供的variant和visit，完全还原函数式的模式匹配写法，不需要继承、虚函数，全程编译期安全：
首先把Animal定义为所有子类的变体类型：

#include <variant>
class Cat { /* Cat的自有实现 */ };
class Dog { /* Dog的自有实现 */ };
using Animal = std::variant<Cat, Dog>;

然后AnimalManager的add方法直接用std::visit做模式匹配，写法和你最开始的伪代码几乎一致：

#include <iostream>
// 重载lambda辅助模板，简化visit写法
template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

class AnimalManager {
private:
    void doThingsWithCats(Cat& cat) { /* Cat专属add逻辑 */ }
    void doThingsWithDogs(Dog& dog) { /* Dog专属add逻辑 */ }
public:
    void add(Animal& animal) {
        std::visit(overloaded{
            [this](Cat& cat) { doThingsWithCats(cat); },
            [this](Dog& dog) { doThingsWithDogs(dog); }
        }, animal);
    }
};

所有类型检查都是编译期完成的，不会有运行时错误，新增子类只要在variant的类型列表里加对应类型，visit如果漏了分支编译期会直接报错。

方案选择建议 #

• 如果Animal子类数量不固定，未来会频繁新增子类，且对Animal的操作相对固定，选择普通多态方案，把操作定义为Animal的虚函数
• 如果Animal子类数量固定，未来会频繁新增对Animal的操作（比如add、remove、统计、打印等），选择访问者模式
• C++17及以上版本，且子类数量有限的场景，优先选择std::variant + std::visit方案，开发效率和安全性都更高
• dynamic_cast方案只建议在临时调试、极少量特殊场景下使用，业务代码中尽量避免：它是运行时检查，漏分支、类型不匹配都会引发运行时错误，且代码扩展性差，每次加子类都要修改所有分支判断的位置

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