如何在派生类中实现同类型对象细节拷贝（规避dynamic_cast）

针对你提出的「仅当派生类与目标对象类型相同时才拷贝内部细节，否则不操作」的需求，以下是几种避免dynamic_cast代码异味的实现思路：

方案1：CRTP（奇异递归模板模式）封装类型检查 #

利用CRTP将类型判断逻辑抽象到模板基类中，让派生类只需专注于自身的拷贝细节，避免重复编写类型检查代码：

#include <type_traits>

class Animal {
public:
    virtual ~Animal() = default;
    virtual void CopyFrom(const Animal* animal) = 0;
};

template<typename Derived>
class AnimalCRTP : public Animal {
public:
    void CopyFrom(const Animal* animal) override final {
        // 类型检查逻辑统一封装在此
        if (const Derived* derived_src = dynamic_cast<const Derived*>(animal)) {
            static_cast<Derived*>(this)->CopyDerivedDetails(derived_src);
        }
        // 不同类型则无操作
    }

protected:
    // 派生类必须实现该方法，完成自身成员的拷贝
    virtual void CopyDerivedDetails(const Derived* src) = 0;
};

class Dog : public AnimalCRTP<Dog> {
public:
    Dog() = default;

protected:
    void CopyDerivedDetails(const Dog* other) override {
        this->likes_to_bark = other->likes_to_bark;
    }

private:
    bool likes_to_bark = false;
};

class Cat : public AnimalCRTP<Cat> {
protected:
    void CopyDerivedDetails(const Cat* other) override {
        this->likes_to_purr = other->likes_to_purr;
    }

private:
    bool likes_to_purr = true;
};

说明：虽然仍用到dynamic_cast，但它被封装在模板基类中，派生类代码无需重复编写类型判断，逻辑更集中，也符合DRY原则。

方案2：双分派（访问者模式变种）实现类型安全拷贝 #

如果之前尝试双分派失败，可能是未正确设计访问者与被访问者的交互逻辑。以下是正确的双分派实现，将拷贝逻辑与派生类解耦：

#include <typeinfo>

// 前向声明
class Animal;
class Dog;
class Cat;

// 拷贝访问者基类，定义每种动物的拷贝接口
class CopyVisitor {
public:
    virtual ~CopyVisitor() = default;
    virtual void VisitDog(Dog* dest, const Dog* src) = 0;
    virtual void VisitCat(Cat* dest, const Cat* src) = 0;
};

// 具体拷贝访问者，实现同类型拷贝逻辑
class SameTypeCopyVisitor : public CopyVisitor {
public:
    void VisitDog(Dog* dest, const Dog* src) override {
        dest->SetLikesToBark(src->GetLikesToBark());
    }

    void VisitCat(Cat* dest, const Cat* src) override {
        dest->SetLikesToPurr(src->GetLikesToPurr());
    }
};

class Animal {
public:
    virtual ~Animal() = default;
    virtual void AcceptCopy(CopyVisitor* visitor, const Animal* src) = 0;
};

class Dog : public Animal {
public:
    void AcceptCopy(CopyVisitor* visitor, const Animal* src) override {
        // 先验证源对象类型，匹配则调用访问者的对应方法
        if (const Dog* dog_src = dynamic_cast<const Dog*>(src)) {
            visitor->VisitDog(this, dog_src);
        }
    }

    // 提供访问私有成员的接口（或直接声明访问者为友元）
    bool GetLikesToBark() const { return likes_to_bark; }
    void SetLikesToBark(bool val) { likes_to_bark = val; }

private:
    bool likes_to_bark = false;
};

class Cat : public Animal {
public:
    void AcceptCopy(CopyVisitor* visitor, const Animal* src) override {
        if (const Cat* cat_src = dynamic_cast<const Cat*>(src)) {
            visitor->VisitCat(this, cat_src);
        }
    }

    bool GetLikesToPurr() const { return likes_to_purr; }
    void SetLikesToPurr(bool val) { likes_to_purr = val; }

private:
    bool likes_to_purr = true;
};

// 对外暴露的拷贝接口
void CopyAnimal(Animal* dest, const Animal* src) {
    SameTypeCopyVisitor visitor;
    dest->AcceptCopy(&visitor, src);
}

说明：双分派通过两次虚拟调用实现类型匹配：第一次是dest->AcceptCopy根据自身类型进入对应派生类，第二次是访问者根据源对象类型调用具体拷贝方法。新增动物类型时，只需扩展访问者类和派生类的AcceptCopy方法即可。

方案3：类型标识+静态转换（轻量RTTI方案） #

如果想避免dynamic_cast的开销，可以通过typeid获取类型标识，匹配后用static_cast安全转换：

#include <typeinfo>

class Animal {
public:
    virtual ~Animal() = default;
    virtual void CopyFrom(const Animal* animal) = 0;
    virtual const std::type_info& GetType() const = 0;
};

class Dog : public Animal {
public:
    void CopyFrom(const Animal* animal) override {
        if (animal->GetType() == this->GetType()) {
            // 类型匹配后，static_cast是安全的
            const Dog* dog_src = static_cast<const Dog*>(animal);
            this->likes_to_bark = dog_src->likes_to_bark;
        }
    }

    const std::type_info& GetType() const override {
        return typeid(Dog);
    }

private:
    bool likes_to_bark = false;
};

说明：该方案依赖RTTI（运行时类型信息），但比dynamic_cast更轻量，代码也更直观，适合类型较少的场景。

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