有沒有一種智能的方法來禁止隱藏基類的運算符功能派生類

Question

我正在學習C++一段時間。 我想做一個好奇的遞歸模板模式的指針類，如下所示。不幸的是，它不起作用，因爲派生類的默認運算符==（）函數隱藏了基類的operator ==（）函數。我們是否有一種聰明的方法來禁止派生類之一隱藏基類的操作符函數？或者你知道一種避免這個問題的方法嗎？ 如果我追加來自編譯器的消息。 非常感謝。

#include <vector> 

template <typename Derived, typename T> 
class Function0 { 
public: 
    friend bool operator== (Derived& org, Derived& cmp) { // ***** This line gives a warning 
     Derived& org_value = static_cast<Derived&>(org); 
     Derived& cmp_value = static_cast<Derived&>(cmp); 
     return *(org_value.value_) == *(cmp_value.value_); // *** old code: return org_value == cmp_value; 
    } 
}; 

template <typename T, template <typename Derived, typename T_T> class Functions> 
class Pointer : public Functions<Pointer<T,Functions>, T> { 
public: 
    Pointer() {}; 
    Pointer(T* new_value) : value_(new_value) {}; 
    bool operator== (Pointer& cmp) = delete; // ***** This line gives a warning 
    virtual ~Pointer() { 
}; 
private: 
    friend Functions<Pointer<T,Functions>, T>; 
    T* value_ = nullptr; 
}; 

class TestA { 
public: 
    TestA(unsigned int id) : id_(id) {}; 
    virtual ~TestA() {}; 
    unsigned int id(void) { return id_; } 

    bool operator== (TestA& cmp) { 
     return (id_ == cmp.id()) ? true : false; 
    } 

private: 
    unsigned int id_ = 0; 
}; 

template <typename Element> 
Element findCorrespondingFirst(Element& obj, std::vector<Element>& vec) { 
    for (unsigned int i = 0; i < vec.size(); ++i) { 
     auto o = vec[i]; 
     if (obj == o) { // this dispatches an error massage 
      return o; 
     } 
    } 
    return Element(); 
} 

void test_pointer_class(void) { 

    std::vector<Pointer<TestA, Function0>> ptr_vector; 

    TestA* raw_ptr0 = new TestA(1); 
    TestA* raw_ptr1 = nullptr; 
    TestA* raw_ptr2 = new TestA(2); 

    Pointer<TestA, Function0> ptr0 = Pointer<TestA, Function0>(raw_ptr0); 
    Pointer<TestA, Function0> ptr1 = Pointer<TestA, Function0>(raw_ptr1); 
    Pointer<TestA, Function0> ptr2 = Pointer<TestA, Function0>(raw_ptr2); 

    TestA* raw_ptr3 = new TestA(1); 
    Pointer<TestA, Function0> ptr3 = Pointer<TestA, Function0>(raw_ptr3); 

    ptr_vector.push_back(ptr0); 
    ptr_vector.push_back(ptr1); 
    ptr_vector.push_back(ptr2); 
    ptr_vector.push_back(ptr3); 

    auto result1 = findCorrespondingFirst(ptr3, ptr_vector); 

    delete raw_ptr0; 
    delete raw_ptr1; 
    delete raw_ptr2; 
    delete raw_ptr3; 

} 

從gcc編譯器消息的一部分之後，

/home/.../pointer.hpp: In instantiation of ‘Element findCorrespondingFirst(Element&, std::vector<_RealType>&) [with Element = Pointer<TestA, Function0>]’: 
/home/.../pointer.hpp:120:56: required from here 
/home/.../pointer.hpp:68:11: error: ambiguous overload for ‘operator==’ (operand types are ‘Pointer<TestA, Function0>’ and ‘Pointer<TestA, Function0>’) 
    if (obj == o) { // this dispatches an error massage 
     ^
/home/.../pointer.hpp:68:11: note: candidates are: 
/home/.../pointer.hpp:39:7: note: bool Pointer<T, Functions>::operator==(Pointer<T, Functions>&) [with T = TestA; Functions = Function0] <deleted> 
    bool operator== (Pointer& cmp) = delete; // ***** This line gives a warning 
^
/home/.../pointer.hpp:23:14: note: bool operator==(Pointer<TestA, Function0>&, Pointer<TestA, Function0>&) 
friend bool operator== (Derived& org, Derived& cmp) { // ***** This line gives a warning 
     ^

再次感謝您。

Answer 1

線

bool operator== (Pointer& cmp) = delete; // ***** This line gives a warning 

是錯誤的多種方式。事實上，刪除它可以消除這個問題（你應該考慮這麼做，因爲它不清楚它的用途是什麼，我必須說）。

順便說一句，正確的方法來定義它。將其聲明爲

bool operator== (const Pointer<T, Functions>& cmp) const = delete; // ***** This line gives a warning 

需要注意的是你的類類型不是Pointer，而是Pointer<T, Functions>，並且正確const內斯此操作的性能。

您的第一個operator==也有const問題。

---

我建議你做如下修改：

friend bool operator== (const Derived& org, const Derived& cmp) { // ***** This line gives a warning 
    const Derived& org_value = static_cast<const Derived&>(org); 
    const Derived& cmp_value = static_cast<const Derived&>(cmp);                                   
    return org_value == cmp_value; 
} 

只是抹去後者：

// bool operator== (const Pointer<T, Functions>& cmp) const = delete; // ***** This line gives a warning