通过基类指针检查模板类相等性

class Base {
public:
    virtual ~Base() = default;
};

template <typename T>
class Derived : public Base {
public:
    Derived(T value) : value_(value) {}
    T getValue() const { return value_; }
private:
    T value_;
};

class Base {
public:
    virtual ~Base() = default;
    virtual bool isEqual(const Base& other) const = 0;
};

template <typename T>
class Derived : public Base {
public:
    Derived(T value) : value_(value) {}
    bool isEqual(const Base& other) const override {
        const Derived<T>* derivedOther = dynamic_cast<const Derived<T>*>(&other);
        if (derivedOther) {
            return value_ == derivedOther->getValue();
        }
        return false;
    }
    T getValue() const { return value_; }
private:
    T value_;
};

#include <typeinfo>

bool areEqual(const Base& a, const Base& b) {
    if (typeid(a) != typeid(b)) {
        return false;
    }
    // 这里假设每个派生类都实现了自己的isEqual逻辑
    return a.isEqual(b);
}

#include <iostream>
#include <typeinfo>

class Base {
public:
    virtual ~Base() = default;
    virtual bool isEqual(const Base& other) const = 0;
};

template <typename T>
class Derived : public Base {
public:
    Derived(T value) : value_(value) {}
    bool isEqual(const Base& other) const override {
        const Derived<T>* derivedOther = dynamic_cast<const Derived<T>*>(&other);
        if (derivedOther) {
            return value_ == derivedOther->getValue();
        }
        return false;
    }
    T getValue() const { return value_; }
private:
    T value_;
};

bool areEqual(const Base& a, const Base& b) {
    if (typeid(a) != typeid(b)) {
        return false;
    }
    return a.isEqual(b);
}

int main() {
    Derived<int> d1(10);
    Derived<int> d2(10);
    Derived<int> d3(20);

    std::cout << "d1 == d2: " << areEqual(d1, d2) << std::endl; // 输出: 1 (true)
    std::cout << "d1 == d3: " << areEqual(d1, d3) << std::endl; // 输出: 0 (false)

    return 0;
}