Vermeiden von const_cast beim Aufruf von std :: set <Type*> :: finden

Question

Gibt es eine gute Möglichkeit, um die const_cast unten zu vermeiden, während const Richtigkeit zu halten?

Ohne const_cast wird der folgende Code nicht kompiliert. set::find erhält einen konstanten Verweis auf den Schlüsseltyp des Satzes, in unserem Fall garantiert es also, den übergebenen Zeigerwert nicht zu ändern; Es ist jedoch nichts garantiert, nicht zu ändern, worauf der Zeiger zeigt.

class C { 
public: 
    std::set<int*> m_set; 

    bool isPtrInSet(const int* ptr) const 
    { 
     return m_set.find(const_cast<int*>(ptr)) != m_set.end(); 
    } 
}; 

Answer 1

Ja. In C++ 14 können Sie einen eigenen Vergleicher verwenden, der int const* als transparent deklariert. Dies würde die template overload von find() aktivieren, die Schlüssel gegen beliebige Typen vergleichen kann. Siehe dazu SO question. Und hier ist Jonathan Wakely's explanation.

Answer 2

Wenn Sie const int* s speichern möchten, speichern Sie dann const int* s. Wenn Sie stattdessen int* s speichern wollen, dann tun Sie das, aber Sie können nicht so mischen und passen (zumindest nicht ohne den Hack, den Sie bereits benutzt haben).

Wählen Sie einen aus und bleiben Sie dabei.

Answer 3

Gibt es einen guten Weg, um den unten stehenden const_cast zu umgehen, während die const Korrektheit beibehalten wird?

Ich bin mir nicht sicher, ob das, was ich vorschlagen werde, als "guter Weg" gilt. Sie können jedoch die const_cast vermeiden, wenn es Ihnen nichts ausmacht, selbst über den Inhalt des Sets zu iterieren. Denken Sie daran, dass damit eine O (log (N)) - Operation in eine O (N) -Operation umgewandelt wird.

bool isPtrInSet(const int* ptr) const 
{ 
    for (auto p : m_set) 
    { 
     if (p == ptr) 
     { 
     return true; 
     } 
    } 
    return false; 
} 

Answer 4

Ich möchte die zugrunde liegende Logik erklären, warum dies unmöglich ist.

Angenommen, set<int*>::find(const int*) wäre legitim. Dann könntest du folgendes machen:

set<int*> s; 
const int* p_const; 
// fill s and p 
auto it = s.find(p_const); 
int* p = *it; 

Hey presto! Sie haben const int* in int* umgewandelt, ohne const_cast durchzuführen.