Элегантное сравнение объектов

Если вы имеете в виду, что Compare () в классе B или C всегда должен передаваться объекту класса B или C, независимо от того, что написано в подписи, вы можете работать с указателями на экземпляры вместо экземпляров и пытаться понижать указатель в код метода, использующий что-то вроде

int B::Compare(A *ptr)
{
   other = dynamic_cast <B*> (ptr);
   if (other)
      ...  // Ok, it was a pointer to B
}

(Такая перегрузка была бы необходима только для тех производных классов, которые добавляют к состоянию своего родителя что-то, что влияет на сравнение.)

Сравнение должно быть отражающим, поэтому:

let a = new A
let b = new B (inherits from A)

if (a.equals(b))
 then b.equals(a) must be true!

Таким образом, a.equals(b) должен возвращать false, поскольку B, вероятно, содержит поля, которых нет у A, что означает, что b.equals(a), вероятно, будет ложным.

Таким образом, я полагаю, что в C++ сравнение должно быть виртуальным, и вы должны использовать проверку типов, чтобы увидеть, что параметр имеет «тот же» тип, что и текущий объект.

В дополнение к dynamic_cast вам также необходимо передать ссылку или указатель, возможно, const. Функция сравнения также, вероятно, может быть константой.

class B: public A
{
    B();
    virtual ~B();
    virtual int Compare(const A &Other) const;
};


int B::Compare(const A &Other) const
{
    const B *other = dynamic_cast <const B*> (&Other);
    if (other) {
        // compare
    }
    else {
        return 0;
    }
}

Обновлено: необходимо скомпилировать перед публикацией ...

У меня почти не возникает этой проблемы в C++. В отличие от Java, от нас не требуется наследовать все наши классы от одного и того же корневого класса Object. При работе с сопоставимыми (семантика / значение) классами очень маловероятно, чтобы они происходили из полиморфной иерархии.

Если потребность в вашей конкретной ситуации реальна, вы снова столкнетесь с проблемой двойной отправки / нескольких методов. Есть разные способы решить эту проблему (dynamic_cast, таблицы функций для возможных взаимодействий, посетители, ...)

Я бы реализовал это так:

class A{
    int a;

public:
    virtual int Compare(A *other);
};


class B : A{
    int b;

public:
    /*override*/ int Compare(A *other);
};

int A::Compare(A *other){
    if (!other)
        return 1; /* let's just say that non-null > null */

    if (a > other->a)
        return 1;

    if (a < other->a)
        return -1;

    return 0;
}

int B::Compare(A *other){
    int cmp = A::Compare(other);
    if (cmp)
        return cmp;

    B *b_other = dynamic_cast<B*>(other);
    if (!b_other)
        throw "Must be a B object";

    if (b > b_other->b)
        return 1;

    if (b < b_other->b)
        return -1;

    return 0;
}

Это очень похоже на шаблон IComparable в .NET, который работает очень хорошо.

Обновлено:

Одно предостережение к вышеизложенному заключается в том, что a.Compare(b) (где a - это A, а b - это B) может возвращать равенство и никогда генерирует исключение, тогда как b.Compare(a) будет. Иногда это то, чего вы хотите, а иногда нет. Если это не так, то вы, вероятно, не хотите, чтобы ваша функция Compare была виртуальной, или вы хотите сравнить type_info в базовой функции Compare, как в:

int A::Compare(A *other){
    if (!other)
        return 1; /* let's just say that non-null > null */

    if (typeid(this) != typeid(other))
        throw "Must be the same type";

    if (a > other->a)
        return 1;

    if (a < other->a)
        return -1;

    return 0;
}

Обратите внимание, что функции производных классов Compare не нужно изменять, так как они должны вызывать Compare базового класса, где будет происходить сравнение type_info. Однако вы можете заменить dynamic_cast в переопределенной функции Compare на static_cast.

Наверное, я бы так сделал:

class A
{
 public:
  virtual int Compare (const A& rhs) const
  {
    // do some comparisons
  }
};

class B
{
 public:
  virtual int Compare (const A& rhs) const
  {
    try
    {
      B& b = dynamic_cast<A&>(rhs)
      if (A::Compare(b) == /* equal */)
      {
        // do some comparisons
      }
      else
        return /* not equal */;
    }
    catch (std::bad_cast&)
    {
      return /* non-equal */
    }
  }
};

Я бы посоветовал не делать его виртуальным. Единственный недостаток заключается в том, что вы должны явно указать, какое сравнение использовать, если классы не совпадают. Но поскольку это необходимо, вы можете обнаружить ошибку (во время компиляции), которая в противном случае могла бы вызвать ошибку времени выполнения ...

class A
{
  public:
    A(){};
    int Compare(A const & Other) {cout << "A::Compare()" << endl; return 0;};
};

class B: public A
{
  public:
    B(){};
    int Compare(B const & Other) {cout << "B::Compare()" << endl; return 0;};
};

class C: public A
{
  public:
    C(){};
    int Compare(C const & Other) {cout << "C::Compare()" << endl; return 0;};
};

int main(int argc, char* argv[])
{
    A a1;
    B b1, b2;
    C c1;

    a1.Compare(b1);     // A::Compare()
    b1.A::Compare(a1);  // A::Compare()
    b1.Compare(b2);     // B::Compare()
    c1.A::Compare(b1);  // A::Compare()

    return 0;
}

Это зависит от предполагаемой семантики A, B и C и семантики compare (). Сравнение - это абстрактное понятие, которое не обязательно имеет единственное правильное значение (или вообще какое-либо значение, если на то пошло). На этот вопрос нет однозначного правильного ответа.

Вот два сценария, в которых сравнение означает две совершенно разные вещи с одной и той же иерархией классов:

class Object 
{
    virtual int compare(const Object& ) = 0;
    float volume;
};

class Animal : Object 
{
    virtual int compare(const Object& );
    float age;
};

class Zebra  : Animal 
{
    int compare(const Object& );
};

Мы можем рассмотреть (как минимум) два способа сравнения двух зебр: какая старше и какая объемнее? Оба сравнения действительны и легко вычислимы; разница в том, что мы можем использовать объем для сравнения зебры с любым другим объектом, но мы можем использовать возраст только для сравнения зебр с другими животными. Если мы хотим, чтобы compare () реализовал семантику сравнения возраста, не имеет смысла определять compare () в классе Object, поскольку семантика не определена на этом уровне иерархии. Стоит отметить, что ни один из этих сценариев не требует какого-либо преобразования, поскольку семантика определяется на уровне базового класса (будь то Object при сравнении объема или Animal при сравнении возраста).

Это поднимает более важную проблему - некоторые классы не подходят для единой универсальной функции compare (). Часто имеет смысл реализовать несколько функций, которые явно указывают, что сравнивается, например compare_age () и compare_volume (). Определение этих функций может происходить в той точке иерархии наследования, где семантика становится актуальной, и адаптация их к дочерним классам должна быть тривиальной (если это вообще необходимо). Простое сравнение с использованием compare () или operator == () часто имеет смысл только с простыми классами, где правильная семантическая реализация очевидна и однозначна.

Короче говоря ... "смотря по обстоятельствам".