c++ - ejemplo - auto en c

Siempre prefiera establecer<T, menos<>> para establecer<T> desde 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
}

Entonces, ¿debería ser una regla?

Siempre prefiera set<T, less<>> para set<T> desde C ++ 14 ?

Answer 1

Es trivial encontrar un contraejemplo:

#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

Puede haber un inconveniente en el rendimiento cuando se usa el associative_container<T, less<>> : Considere un tipo como

#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");
}

Aquí, la aplicación del operator< en el algoritmo realizado por s.find convertirá el carácter literal en una stupid_string implícitamente. ¡Esto sucede para cada comparación realizada! Demo en vivo

Sé de un caso en el que ocurrió algo similar en el código de producción, con una implementación StdLib C ++ 03 no conforme.

Esta es la forma en que la principal razón por la cual la búsqueda heterogénea a través de less<> se realizó opt-in; ver N3657 :

Stephan T. Lavavej sugirió que los dos problemas de preservar el comportamiento existente y permitir las búsquedas heterogéneas se podrían resolver haciendo que los contenedores detecten cuando el objeto de comparación acepta argumentos heterogéneos y solo sobrecargando condicionalmente las funciones de búsqueda actuales con versiones de plantilla.