Cách chính xác để thực hiện so sánh cho một lớp cơ sở là gì?

Question

Tôi có một lớp cơ sở

class Animal 

với các chức năng ảo tinh khiết, và một bộ các lớp thừa kế

class Monkey : public Animal 
class Snake : public Animal 

Tôi muốn thực hiện một thao tác so sánh do đó, nếu tôi gặp phải hai con trỏ đến Loài vật trong mã của tôi

Animal* animal1 
Animal* animal2 

Tôi có thể so sánh chúng với nhau. So sánh sẽ mang lại giá trị sai, nếu animal1 và animal2 có các lớp dẫn xuất khác nhau. Nếu chúng thuộc cùng một lớp dẫn xuất, thì đầu ra của toán tử so sánh sẽ được trả về.

Ai đó có thể chỉ cho tôi cách thực hiện tốt điều này không?

Answer 1

Chà, rất nhiều câu trả lời khác hoàn toàn không cần thiết. dynamic_cast- nó tồn tại, sử dụng nó.

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; 
    } 
}; 

Chỉnh sửa: Cúi trước khi triển khai tự động theo khuôn mẫu của tôi!

Chỉnh sửa chỉnh sửa: Một điều tôi đã làm là quên gắn thẻ chúng là const, điều đó sai với tôi. Tôi sẽ không xin lỗi vì không làm! = Như, hãy đối mặt với nó, thực hiện nó là một doddle tổng số.

Chỉnh sửa khác: Các chàng trai của Chúa Giêsu Kitô, đây không phải là ví dụ về cách viết! = Hoặc ==, đây là ví dụ về cách sử dụng CRTP.Nếu bạn không thích cách tôi chọn để triển khai! = Hoặc ==, bạn có thể kiện.

Answer 2

Vì không có thông tin kiểu tĩnh liên kết với hai con trỏ, bạn sẽ cần sử dụng RTTI. Bạn có thể so sánh kết quả của loại typeid operator để xác định xem các đối tượng có cùng loại hay không.

Cách khác là thêm ID loại của riêng bạn vào lớp Animal. Thêm một hàm ảo khác và có các lớp dẫn xuất trả về một cái gì đó nhận dạng duy nhất kiểu đó. Bạn có thể sử dụng một kiểu liệt kê, hoặc có thể là tên của kiểu như một chuỗi. Nếu bạn có thể sử dụng nó, tuy nhiên, RTTI sẽ là IMHO tốt hơn nhiều.

Answer 3

Sử dụng lớp type_info. Nó định nghĩa toán tử == trả về cho dù hai kiểu mô tả cùng loại. Ở đây bạn có thể tìm thấy tài liệu tham khảo: http://www.cplusplus.com/reference/std/typeinfo/type_info/

Answer 4

Một cách để thực hiện điều này, là sử dụng hai công văn để phân biệt giữa 'cùng lớp' và 'lớp khác nhau':

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

Dưới đây là một mẹo nhỏ Tôi sử dụng (Tôi hy vọng nó có thể làm việc cho bạn quá). tôi thêm các phương pháp tin sau đây để động vật và ghi đè lên nó trong mỗi lớp được thừa kế (Tôi biết, đó là một chút rắc rối, nhưng nó là nhanh hơn so với 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; 
} 
... 
} 

bây giờ để xem nếu 2 con trỏ (a, b) là của cùng lớp chỉ cần kiểm tra cho

a-> chữ ký() == b> chữ ký()

nó không thực sự là một giải pháp, đó là một thủ thuật, nhưng nó hoạt động chỉ với 2 các cuộc gọi phương thức ảo (1 cho mỗi con trỏ) vì vậy nó khá nhanh.