實現基類比較的正確方法是什麼？

Question

我有一個基類

class Animal 

與純虛函數，和一組派生類

class Monkey : public Animal 
class Snake : public Animal 

我想實現一個比較操作的，這樣，如果我遇到兩個指針動物在我的代碼

Animal* animal1 
Animal* animal2 

我可以將它們相互比較。如果animal1和animal2具有不同的派生類，則比較應該產生錯誤。如果它們具有相同的派生類，則應返回比較運算符的輸出。

有人可以指出我實現這個好方法嗎？

Answer 1

哇，很多其他的答案是完全沒有必要的。 dynamic_cast-它存在，使用它。

class Animal { 
public: 
    virtual bool operator==(const Animal& other) = 0; 
    virtual ~Animal() = 0; 
}; 
template<class T> class AnimalComp : public Animal { 
public: 
    virtual bool operator==(const Animal& ref) const { 
     if (const T* self = dynamic_cast<const T*>(&ref)) { 
      return ((T*)this)->operator==(*self); 
     } 
     return false; 
    } 
    virtual bool operator!=(const Animal& ref) const { 
     if (const T* self = dynamic_cast<const T*>(&ref)) { 
      return ((T*)this)->operator!=(*self); 
     } 
     return true; 
    } 
}; 
class Monkey : public AnimalComp<Monkey> { 
public: 
    virtual bool operator==(const Monkey& other) const { 
     return false; 
    } 
    virtual bool operator!=(const Monkey& other) const { 
     return false; 
    } 
}; 
class Snake : public AnimalComp<Snake> { 
public: 
    virtual bool operator==(const Snake& other) const { 
     return false; 
    } 
    virtual bool operator!=(const Snake& other) const { 
     return false; 
    } 
}; 

編輯：在我的自動模板實現前鞠躬！

編輯編輯：我做的一件事是忘記標記爲const，這是我的錯誤。我不會爲沒有做而道歉！=因爲，讓我們面對它，實施它是一個總的輕而易舉的事情。

更多編輯：耶穌基督傢伙，這不是如何寫！=或==的例子，這是一個如何使用CRTP的例子。如果你不喜歡我選擇實施我的！=或==，你可以起訴。

Answer 2

由於沒有與兩個指針相關的靜態類型信息，因此您需要使用RTTI。您可以比較類型typeid operator的結果以確定對象是否屬於同一類型。

另一種方法是將您自己的類型ID添加到Animal類。添加另一個虛函數並派生類返回唯一標識類型的內容。您可以使用枚舉，或者可以使用字符串的名稱。如果你可以使用它，但是，RTTI會好得多恕我直言。

Answer 3

使用type_info類。它定義了operator ==，它返回兩種類型是否描述相同的類型。 在這裏你可以找到參考：實現這個 http://www.cplusplus.com/reference/std/typeinfo/type_info/

Answer 4

的一種方法，是使用雙調度「同一類」和「不同類」之間的區別：

class Monkey; 
class Snake; 

class Animal { 
public: 
    virtual bool compare_impl(const Animal*) const { return false; } 
    virtual bool compare_impl(const Monkey*) const { return false; } 
    virtual bool compare_impl(const Snake*) const { return false; } 
    virtual bool compare(const Animal* rhs) const =0; 
}; 

class Monkey : public Animal { 
private: 
    /* Override the default behaviour for two Monkeys */ 
    virtual bool compare_impl(const Monkey*) const { /* compare two Monkey's */ } 
public: 
    /* Let overload-resolution pick the compare_impl for Monkey and let virtual dispatch select the override in the dynamic type of rhs */ 
    virtual bool compare(const Animal* rhs) const { return rhs->compare_impl(this); } 
}; 

class Snake : public Animal { 
private: 
    /* Override the default behaviour for two Snakes */ 
    bool compare_impl(const Snake*) const { /* compare two Snakes */ } 
public: 
    /* Let overload-resolution pick the compare_impl for Monkey and let virtual dispatch select the override in the dynamic type of rhs */ 
    virtual bool compare(const Animal* rhs) const { return rhs->compare_impl(this); } 
}; 

Answer 5

這裏有一個小竅門我使用（我希望它也能爲你工作）。 我下面的私有方法添加到動物並在每一個派生類中重寫它（我知道，它是有點麻煩，但它比RTTI更快）

class Animal { 
protected: 

virtual const void* signature() const 
{ 
    static bool dummy; 
    return &dummy; 
} 
... 
} 


class Monkey : public Animal { 
private: 
virtual const void* signature() const 
{ 
    static bool dummy; 
    return &dummy; 
} 
... 
} 

現在爲了看兩個指針（ a和b）是同一類的只是檢查

A->簽名（）== B->簽名（）

它不是一個真正的解決方案，這是一個把戲，但它只有2個工作虛擬方法調用（每個指針爲1），因此速度很快。