运算符重载抽象类

Question

有一个Student抽象类，以及两个派生类Grad和Undergrad；我想以多种方式重载运算符。

student.h

class Student {
    protected:
    string Name;
    int Stu_num;
 
    public:
    virtual void print() = 0;
    bool operator==(const Student& x) const;

    // constructor...
}

class Grad_Student : public Student {
    private:
    string Lab;

    public:
    void print();
    bool operator==(const Grad_Student& x) const;
 
    // constructor...
}

class Undergrad_Student : public Student {
    private:
    string Major;

    public:
    void print();
    bool operator==(const Undergrad_Student& x) const;
  
    // constructor...
}

student.cpp

bool Student::operator==(const Student& x) const {
    if (this->Name == x.Name && this->Stu_num == x.Stu_num) {
        if (typeid(*this).name() != typeid(x).name()) {
            return false;
        }
        else if (!(strcmp(typeid(*this).name(), "12Grad_Student"))) {
            return *dynamic_cast<const Grad_Student *>(this) == *dynamic_cast<const Grad_Student *>(&x);
        } 
        else {
            return *dynamic_cast<const Undergrad_Student *>(this) == *dynamic_cast<const Undergrad_Student *>(&x);
        }
    } 
    else {
        return false;
    }
}

bool Grad_Student::operator==(const Grad_Student& x) const {
    return this->Lab == x.Lab;
}

bool Undergrad_Student::operator==(const Undergrad_Student& x) const {
    return this->Major== x.Major;
}

在Student *students[300]中查找学生对象 这个操作==重载工作并且没有问题， 但我想使用下面的不同方式实现重载。 这个功能怎么实现？？

bool operator==(const Student& x, const Student& y)
{
    // do comparison...
}

Answer 1

虽然这似乎可行，但type_info::name() 是

• 依赖于实现，
• 不保证在不同类型之间是唯一的，
• 不保证在同一程序的不同执行之间是相同的。

虽然直接比较type_infos 是可靠的，但您可以执行if (typeid(*this) == typeid(Grad_Student)) 之类的操作，它会按预期工作。

但是，多态性已经存在，因此您不需要自己实现它，并且可以通过调度到虚函数而不是枚举子类来避免很多麻烦（和开销）。
像这样的：

class Student {
public:
    bool equals(const Student& s) const
    {
        return Name == s.Name
            && Stu_num == s.Stu_num
            && typeid(*this) == typeid(s)
            && equals_internal(s);
    }

private:
    virtual bool equals_internal(const Student& s) const = 0;

    string Name;
    int Stu_num;
};

bool operator==(const Student& lhs, const Student& rhs)
{
    return lhs.equals(rhs);
}

class Grad_Student : public Student {
private:
    string Lab;

    bool equals_internal(const Student& s) const override
    {
        return Lab == static_cast<const Grad_Student&>(s).Lab;
    }
};

class Undergrad_Student : public Student {
private:
    string Major;

    bool equals_internal(const Student& s) const override
    {
        return Major == static_cast<const Undergrad_Student&>(s).Major;        
    }
};

注意static_casts 是安全的，因为Student 已经建立了类型相等性。