¿Qué es la "Búsqueda dependiente de argumentos" (también conocida como ADL o "Búsqueda de Koenig")?

¿Cuáles son algunas buenas explicaciones sobre qué argumento depende de la búsqueda? Muchas personas también lo llaman Koenig Lookup también.

Preferiblemente me gustaría saber:

• ¿Por qué es algo bueno?
• ¿Por qué es algo malo?
• ¿Como funciona?

La búsqueda de Koenig , o búsqueda dependiente de argumentos , describe cómo el compilador busca en C ++ nombres no calificados.

El estándar C ++ 11 § 3.4.2 / 1 establece:

Cuando la expresión postfix en una llamada de función (5.2.2) es un id no calificado, se pueden buscar otros espacios de nombres no considerados durante la búsqueda no calificada habitual (3.4.1), y en esos espacios de nombres, declaraciones de función amiga del ámbito de nombres ( 11.3) no se puede ver de otra manera visible. Estas modificaciones a la búsqueda dependen de los tipos de argumentos (y para los argumentos de plantilla, el espacio de nombres del argumento de plantilla).

En términos más simples, Nicolai Josuttis afirma ¹ :

No tiene que calificar el espacio de nombres para las funciones si uno o más tipos de argumentos están definidos en el espacio de nombres de la función.

Un ejemplo de código simple:

namespace MyNamespace
{
    class MyClass {};
    void doSomething(MyClass);
}

MyNamespace::MyClass obj; // global object


int main()
{
    doSomething(obj); // Works Fine - MyNamespace::doSomething() is called.
}

En el ejemplo anterior, no hay una usingdeclaración ni una usingdirectiva, pero el compilador identifica correctamente el nombre no calificado doSomething()como la función declarada en el espacio MyNamespacede nombres mediante la aplicación de búsqueda de Koenig .

¿Como funciona?

El algoritmo le dice al compilador que no solo mire el alcance local, sino también los espacios de nombres que contienen el tipo de argumento. Por lo tanto, en el código anterior, el compilador encuentra que el objeto obj, que es el argumento de la función doSomething(), pertenece al espacio de nombres MyNamespace. Entonces, mira ese espacio de nombres para ubicar la declaración de doSomething().

¿Cuál es la ventaja de la búsqueda de Koenig?

Como lo demuestra el sencillo ejemplo de código anterior, la búsqueda de Koenig proporciona comodidad y facilidad de uso al programador. Sin la búsqueda de Koenig, habría una sobrecarga en el programador, para especificar repetidamente los nombres completos o, en su lugar, utilizar numerosas usingdeclaraciones.

¿Por qué la crítica de la búsqueda de Koenig?

La excesiva dependencia de la búsqueda de Koenig puede conducir a problemas semánticos y, a veces, pillar desprevenido al programador.

Considere el ejemplo de std::swap, que es un algoritmo de biblioteca estándar para intercambiar dos valores. Con la búsqueda de Koenig, uno debería ser cauteloso al usar este algoritmo porque:

std::swap(obj1,obj2);

puede no mostrar el mismo comportamiento que:

using std::swap;
swap(obj1, obj2);

Con ADL, qué versión de la swapfunción se llama dependería del espacio de nombres de los argumentos que se le pasan.

Si existe un espacio de nombres Ay A::obj1, A::obj2y A::swap()existe, el segundo ejemplo dará como resultado una llamada a A::swap(), que podría no ser lo que el usuario quería.

Además, si por alguna razón tanto A::swap(A::MyClass&, A::MyClass&)y std::swap(A::MyClass&, A::MyClass&)se definen, a continuación, el primer ejemplo llamará std::swap(A::MyClass&, A::MyClass&)pero el segundo no se compilará porque swap(obj1, obj2)sería ambiguo.

Trivialidades:

¿Por qué se llama "búsqueda de Koenig"?

Porque fue ideado por el ex investigador y programador de AT&T y Bell Labs, Andrew Koenig .

Otras lecturas:

• Búsqueda del nombre de Herb Sutter en GotW

• Estándar C ++ 03/11 [basic.lookup.argdep]: 3.4.2 Búsqueda de nombres dependiente de argumentos.

_{¹ La definición de búsqueda de Koenig es como se define en el libro de Josuttis, The C ++ Standard Library: A Tutorial and Reference .}

En Koenig Lookup, si se llama a una función sin especificar su espacio de nombres, entonces el nombre de una función también se busca en los espacios de nombres en los que se define el tipo de argumento (s). Es por eso que también se conoce como Búsqueda de nombre dependiente del argumento , en resumen simplemente ADL .

Es por Koenig Lookup, podemos escribir esto:

std::cout << "Hello World!" << "\n";

De lo contrario, tendríamos que escribir:

std::operator<<(std::operator<<(std::cout, "Hello World!"), "\n");

lo que realmente es escribir demasiado y el código se ve muy feo!

En otras palabras, en ausencia de Koenig Lookup, incluso un programa Hello World parece complicado.

Tal vez sea mejor comenzar con el por qué, y solo luego ir al cómo.

Cuando se introdujeron los espacios de nombres, la idea era tener todo definido en los espacios de nombres, para que las bibliotecas separadas no interfieran entre sí. Sin embargo, eso introdujo un problema con los operadores. Mire, por ejemplo, el siguiente código:

namespace N
{
  class X {};
  void f(X);
  X& operator++(X&);
}

int main()
{
  // define an object of type X
  N::X x;

  // apply f to it
  N::f(x);

  // apply operator++ to it
  ???
}

Por supuesto, podría haber escrito N::operator++(x), pero eso habría derrotado todo el punto de sobrecarga del operador. Por lo tanto, se tuvo que encontrar una solución que permitiera encontrar el compilador a operator++(X&)pesar del hecho de que no estaba dentro del alcance. Por otro lado, todavía no debería encontrar otro operator++definido en otro espacio de nombres no relacionado que pueda hacer que la llamada sea ambigua (en este ejemplo simple, no obtendría ambigüedad, pero en ejemplos más complejos, podría). La solución fue la búsqueda dependiente de argumentos (ADL), llamada así ya que la búsqueda depende del argumento (más exactamente, del tipo de argumento). Dado que el esquema fue inventado por Andrew R. Koenig, a menudo también se lo llama búsqueda de Koenig.

El truco es que para las llamadas a funciones, además de la búsqueda de nombre normal (que encuentra los nombres en el alcance en el punto de uso), se realiza una segunda búsqueda en los ámbitos de los tipos de cualquier argumento dado a la función. Así, en el ejemplo anterior, si se escribe x++en el principal, busca operator++no sólo en el ámbito global, pero, además, en el ámbito en el que el tipo de x, N::X, se definió, es decir, en namespace N. Y allí encuentra una coincidencia operator++y, por x++lo tanto, simplemente funciona. Sin embargo, no se encontrará otro operator++definido en otro espacio de nombres N2. Dado que ADL no está restringido a espacios de nombres, también puede usar en f(x)lugar de N::f(x)in main().

No todo es bueno, en mi opinión. Las personas, incluidos los vendedores de compiladores, lo han insultado debido a su comportamiento a veces desafortunado.

ADL es responsable de una revisión importante del ciclo for-range en C ++ 11. Para entender por qué ADL a veces puede tener efectos no deseados, considere que no solo se consideran los espacios de nombres donde se definen los argumentos, sino también los argumentos de los argumentos de plantilla de los argumentos, de los tipos de parámetros de los tipos de función / tipos de puntas de los tipos de punteros de esos argumentos , y así sucesivamente.

Un ejemplo usando boost

std::vector<boost::shared_ptr<int>> v;
auto x = begin(v);

Esto resultó en una ambigüedad si el usuario usa la biblioteca boost.range, porque ambos std::beginse encuentran (mediante ADL usando std::vector) y boost::beginse encuentran (mediante ADL usando boost::shared_ptr).