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.