Was ist "Argument-Dependent Lookup" (auch bekannt als ADL oder "Koenig Lookup")?

Was sind einige gute Erklärungen für die argumentabhängige Suche? Viele Leute nennen es auch Koenig Lookup.

Am liebsten würde ich wissen:

• Warum ist es eine gute Sache?
• Warum ist es eine schlechte Sache?
• Wie funktioniert es?

Koenig Lookup oder Argument Dependent Lookup beschreibt, wie unqualifizierte Namen vom Compiler in C ++ gesucht werden.

Der C ++ 11-Standard § 3.4.2 / 1 besagt:

Wenn der Postfix-Ausdruck in einem Funktionsaufruf (5.2.2) eine unqualifizierte ID ist, können andere Namespaces durchsucht werden, die bei der üblichen unqualifizierten Suche (3.4.1) nicht berücksichtigt wurden, und in diesen Namespaces Namespace-Scope-Friend-Funktionsdeklarationen ( 11.3) kann sonst nicht sichtbar gefunden werden. Diese Änderungen an der Suche hängen von den Argumenttypen ab (und bei Vorlagenvorlagenargumenten vom Namespace des Vorlagenarguments).

Einfacher ausgedrückt sagt Nicolai Josuttis ¹ :

Sie müssen den Namespace nicht für Funktionen qualifizieren, wenn im Namespace der Funktion ein oder mehrere Argumenttypen definiert sind.

Ein einfaches Codebeispiel:

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

MyNamespace::MyClass obj; // global object


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

Im obigen Beispiel gibt es weder eine using-deklaration noch eine using-directive, aber der Compiler identifiziert den nicht qualifizierten Namen korrekt doSomething()als die im Namespace deklarierte Funktion, MyNamespaceindem er die Koenig-Suche anwendet .

Wie funktioniert es?

Der Algorithmus weist den Compiler an, nicht nur den lokalen Bereich zu betrachten, sondern auch die Namespaces, die den Typ des Arguments enthalten. Somit stellt der Compiler im obigen Code fest, dass das Objekt obj, das das Argument der Funktion ist doSomething(), zum Namespace gehört MyNamespace. Es sieht sich also diesen Namespace an, um die Deklaration von zu finden doSomething().

Was ist der Vorteil der Koenig-Suche?

Wie das obige einfache Codebeispiel zeigt, bietet die Koenig-Suche dem Programmierer Komfort und Benutzerfreundlichkeit. Ohne Koenig-Suche würde der Programmierer einen Overhead haben, um die vollständig qualifizierten Namen wiederholt anzugeben oder stattdessen zahlreiche usingDeklarationen zu verwenden.

Warum die Kritik an Koenig Lookup?

Übermäßiges Vertrauen in die Koenig-Suche kann zu semantischen Problemen führen und den Programmierer manchmal überraschen.

Betrachten Sie das Beispiel std::swapeines Standardbibliotheksalgorithmus zum Austauschen von zwei Werten. Bei der Koenig-Suche müsste man bei der Verwendung dieses Algorithmus vorsichtig sein, weil:

std::swap(obj1,obj2);

zeigt möglicherweise nicht das gleiche Verhalten wie:

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

Bei ADL swaphängt die Version der aufgerufenen Funktion vom Namespace der an ADL übergebenen Argumente ab.

Wenn es einen Namespace gibt Aund wenn A::obj1, A::obj2& A::swap()existiert, führt das zweite Beispiel zu einem Aufruf von A::swap(), was möglicherweise nicht das ist, was der Benutzer wollte.

Wenn aus irgendeinem Grund beide A::swap(A::MyClass&, A::MyClass&)und std::swap(A::MyClass&, A::MyClass&)definiert sind, wird das erste Beispiel aufgerufen std::swap(A::MyClass&, A::MyClass&), das zweite jedoch nicht kompiliert, da swap(obj1, obj2)dies mehrdeutig wäre.

Wissenswertes:

Warum heißt es "Koenig Lookup"?

Weil es vom ehemaligen Forscher und Programmierer Andrew Koenig von AT & T und Bell Labs entwickelt wurde .

Weiterführende Literatur:

• Herb Sutters Namenssuche auf GotW

• Standard C ++ 03/11 [basic.lookup.argdep]: 3.4.2 Argumentabhängige Namenssuche.

_{¹ Die Definition von Koenig Lookup ist wie in Josuttis 'Buch The C ++ Standard Library: A Tutorial and Reference definiert .}

Wenn in Koenig Lookup eine Funktion aufgerufen wird, ohne ihren Namespace anzugeben, wird der Name einer Funktion auch in Namespace (s) gesucht, in denen der Typ der Argumente definiert ist. Aus diesem Grund wird es auch als argumentabhängige Namenssuche bezeichnet , kurz ADL .

Es ist wegen Koenig Lookup, wir können dies schreiben:

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

Sonst müssten wir schreiben:

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

Das ist wirklich zu viel Tippen und der Code sieht wirklich hässlich aus!

Mit anderen Worten, ohne Koenig Lookup sieht sogar ein Hello World- Programm kompliziert aus.

Vielleicht ist es am besten, mit dem Warum zu beginnen und erst dann zum Wie zu gehen.

Bei der Einführung von Namespaces bestand die Idee darin, alles in Namespaces zu definieren, damit sich separate Bibliotheken nicht gegenseitig stören. Dies führte jedoch zu einem Problem mit den Bedienern. Schauen Sie sich zum Beispiel den folgenden Code an:

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
  ???
}

Natürlich hätten Sie schreiben können N::operator++(x), aber das hätte den ganzen Punkt der Überlastung des Bedieners zunichte gemacht. Daher musste eine Lösung gefunden werden, die es dem Compiler ermöglichte, operator++(X&)trotz der Tatsache, dass es nicht im Umfang war, zu finden. Auf der anderen Seite sollte es immer noch keinen anderen finden operator++, der in einem anderen, nicht verwandten Namespace definiert ist, was den Aufruf möglicherweise mehrdeutig macht (in diesem einfachen Beispiel würden Sie keine Mehrdeutigkeit erhalten, in komplexeren Beispielen jedoch möglicherweise). Die Lösung war Argument Dependent Lookup (ADL), so genannt, da die Suche vom Argument abhängt (genauer gesagt vom Typ des Arguments). Da das Schema von Andrew R. Koenig erfunden wurde, wird es auch oft als Koenig-Suche bezeichnet.

Der Trick besteht darin, dass für Funktionsaufrufe zusätzlich zur normalen Namenssuche (bei der Namen im Gültigkeitsbereich am Verwendungsort gefunden werden) eine zweite Suche in den Bereichen der Typen von Argumenten durchgeführt wird, die der Funktion gegeben wurden. Wenn Sie also im obigen Beispiel x++in main schreiben , wird operator++nicht nur im globalen Bereich gesucht, sondern auch in dem Bereich, in dem der Typ von x, N::Xdefiniert wurde, dh in namespace N. Und dort findet es eine Übereinstimmung operator++und x++funktioniert daher einfach. Ein anderer operator++, der beispielsweise in einem anderen Namespace definiert ist N2, wird jedoch nicht gefunden. Da ADL nicht auf Namespaces beschränkt ist, können Sie auch f(x)anstelle von N::f(x)in verwenden main().

Meiner Meinung nach ist nicht alles gut. Leute, einschließlich Compiler-Anbieter, haben es wegen seines manchmal unglücklichen Verhaltens beleidigt.

ADL ist für eine umfassende Überarbeitung der for-range-Schleife in C ++ 11 verantwortlich. Um zu verstehen, warum ADL manchmal unbeabsichtigte Auswirkungen haben kann, sollten Sie berücksichtigen, dass nicht nur die Namespaces berücksichtigt werden, in denen die Argumente definiert sind, sondern auch die Argumente der Vorlagenargumente der Argumente, der Parametertypen der Funktionstypen / der Zeigertypen der Zeigertypen dieser Argumente und so weiter und so fort.

Ein Beispiel mit Boost

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

Dies führte zu einer Mehrdeutigkeit, wenn der Benutzer die Bibliothek boost.range verwendet, da beide std::begingefunden werden (durch ADL-Verwendung std::vector) und boost::begingefunden werden (durch ADL-Verwendung boost::shared_ptr).