Dlaczego nie można tego std :: znaleźć porównaj te obiekty?

Question

Zwykle, kiedy robię std :: find, postawię predykat jako trzeci argument, ale tym razem pomyślałem, że zrobię to inaczej, nie wiem. t zrozumieć, dlaczego to nie działa.

#include <iostream> 
#include <vector> 
#include <algorithm> 

struct RenderJob 
{ 
    RenderJob() {}; 
    int renderJob_ID; 
    bool operator==(RenderJob& rhs) { return rhs.renderJob_ID == this->renderJob_ID; } 
}; 

int main() 
{ 
    RenderJob foo; 
    RenderJob foo2; 
    foo == foo2; // Works 

    std::vector<RenderJob> renderJobs; 

    std::find(renderJobs.begin(), renderJobs.end(), foo); // Doesn't work 
} 

binarny "==" żaden operator znalezione, które zajmuje leworęcznego operand typu RenderJob (lub nie ma akceptowalne konwersji)

Edit :: Dobrze dzięki za odpowiedzi . Oto kilka przykładów, dlaczego nie

RenderJob foo; 
    RenderJob foo2; 
    foo == foo2; // Works 

    std::vector<RenderJob> renderJobs; 

    std::vector<RenderJob>::const_iterator constit = renderJobs.begin(); 

    *constit == foo2; // Doesn't work 

jeszcze prostsze jako ilustracja:

const RenderJob* pToRenderJob; 

*pToRenderJob == foo2; // This fails because the pointed to 
         // object is const, and cannot call the 
         // operator== function because the actual function 
         // definition is not const. 

Gdyby było na odwrót:

foo2 == *pToRenderJob; // This would fail because the 
         // operator==(RenderJob&) the actual argument 
         // is not const. Very subtle rules 

Answer 1

Zostawiłeś swoje const kwalifikatorów off.

bool operator==(const RenderJob& rhs) const { ... } 

Answer 2

Wygląda mi na problem z poprawnością konstelacji. Spróbuj coś takiego zamiast:

bool operator==(RenderJob const &rhs) const { 
    return rhs.renderJob_ID == this->renderJob_ID; 
} 

Doing porównania bardziej pracował bo były tylko przejazdem zwykłe przedmioty, które nie były uzupełnienia tymczasowe, ani nie były const kwalifikacje. Przy std::find funkcja porównania będzie (przynajmniej zwykle) odbierała odwołanie do obiektu w kolekcji (która zwykle będzie miała kwalifikację stałą), więc musi być w stanie odebrać referencję o stałej wartości.

Answer 3

Ale to nadal nie ma sensu, w powyższym przykładzie, prawa strona jest foo2, który nie jest stały, który powinien udać się do nieprzestrzegania constoperator==. Chyba że istnieje ogólna zasada, że ​​nie można porównywać wartości const i non const.

W języku nie ma reguły, że obiekty const i inne niż const nie mogą być porównywane. Musisz się upewnić, że można je porównywać, używając odpowiednich kwalifikatorów const.

Linia

*pToRenderJob == foo2; 

jest równoważna

pToRenderJob->operator==(foo2); 

to nie zadziała, ponieważ pToRenderJob nie może być używany do wywołania funkcji const niebędącą użytkownika. foo2 nie jest tutaj problemem.

Jeśli używasz

foo2 == *pToRenderJob 

jest to równoważne

foo2.operator==(*pToRenderJob) 

Jest to również problem, ponieważ argument funkcji jest const obiektu w czasie, gdy funkcja oczekuje niebędącą const odniesienia. Ponownie, foo2 nie jest problemem.

dokonującej Funkcja A const funkcję Członka i czyni argument const odniesienia daje pewność, że wszystkie kombinacje const i nie- const obiektów po obu stronach operatora może być stosowany bez żadnego problemu.