Préférez toujours l'ensemble <T, less<> > régler <T> depuis C ++ 14?

Question

 #include <set>
#include <string>
#include <string_view>

using namespace std;

int main()
{
    string_view key = "hello";

    set<string> coll1;
    coll1.find(key); // error

    set<string, less<>> coll2;
    coll2.find(key); // ok since C++14
}
 

Alors, si c'est une règle:

Vous préférez toujours set<T, less<>> à set<T> depuis C ++ 14 ?

Answer 1

Il est trivial de trouver un contre-exemple:

 #include <set>
#include <string>

using namespace std;

struct converts_to_string {
    operator string() const { return ""; }
};

int main()
{
    converts_to_string key;

    set<string> coll1;
    coll1.find(key); // OK

    set<string, less<>> coll2;
    coll2.find(key); // error
}
 

Answer 2

Il y a peut être une performance à la baisse lors de l'utilisation d' associative_container<T, less<>>: Considérons un type comme

#include <iostream>
#include <set>
#include <string>

struct stupid_string
{
    stupid_string(char const* s)
      : s(s)
    { std::cout << "copy\n"; }

    stupid_string(char const* s, int) // silent
      : s(s)
    {}

    friend bool operator<(stupid_string const& lhs, stupid_string const& rhs);

private:
    std::string s;
};

bool operator<(stupid_string const& lhs, stupid_string const& rhs) {
    return lhs.s < rhs.s;
}

int main() {
    std::set<stupid_string, std::less<>> s;
    s.emplace("hello", 0);
    s.emplace("world", 0);
    s.emplace("foobar", 0);
    std::cout << "find\n";
    (void)s.find("test");
}

Ici, l'application de l' operator< dans l'algorithme exécuté par s.find vous permet de convertir le caractère littéral à un stupid_string implicitement. Ce qui se passe pour chaque comparaison effectuée! Démonstration en direct

Je connais un cas où quelque chose de semblable s'est passé dans le code de production, avec une non-conforme en C++03 StdLib mise en œuvre.

---

C'est d'ailleurs la principale raison pour laquelle hétérogène recherche via less<> a été faite opt-in; voir N3657:

Stephan T. Lavavej a suggéré que les deux problèmes de la préservation de les comportements et permettant hétérogène recherches pourraient à la fois être résolu en faisant le conteneurs détecter lors de la comparaison d'objet accepte hétérogène arguments et seulement sous certaines conditions la surcharge de l' actuelles fonctions de recherche avec le modèle versions.