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

Was sind einige gute Erklärungen dafür, was argumentabhängige Suche ist? Viele Leute nennen es auch Koenig Lookup.

Am liebsten würde ich wissen:

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

König Lookupoder Argumentabhängige Suchebeschreibt, wie unqualifizierte Namen vom Compiler in C++ nachgeschlagen 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 Namensräume, die während der üblichen unqualifizierten Suche (3.4.1) nicht berücksichtigt werden, durchsucht werden, und in diesen Namensräumen werden Namensraumbereichsfreund-Funktionsdeklarationen ( 11.3) nicht anderweitig sichtbar gefunden werden. Diese Änderungen an der Suche hängen von den Typen der Argumente ab (und für Template-Template-Argumente vom Namespace des Template-Arguments).

Einfacher ausgedrückt sagt Nicolai Josuttis¹:

Sie müssen den Namensraum für Funktionen nicht qualifizieren, wenn ein oder mehrere Argumenttypen im Namensraum der Funktion 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 a using-Erklärung noch a using-Direktive, aber der Compiler identifiziert den nicht qualifizierten Namen trotzdem korrekt doSomething() als die im Namespace deklarierte Funktion MyNamespace durch Auftragen Koenig-Suche.

Wie funktioniert es?

Der Algorithmus weist den Compiler an, nicht nur den lokalen Gültigkeitsbereich zu betrachten, sondern auch die Namespaces, die den Typ des Arguments enthalten. Somit findet der Compiler im obigen Code, dass das Objekt objwas das Argument der Funktion ist doSomething()gehört zum Namensraum MyNamespace. Es sucht also in diesem Namensraum nach der Deklaration von doSomething().

Was ist der Vorteil der Koenig-Suche?

Wie das obige einfache Codebeispiel zeigt, bietet die Koenig-Suche dem Programmierer Komfort und Benutzerfreundlichkeit. Ohne die Koenig-Suche würde es für den Programmierer einen Mehraufwand geben, die vollständig qualifizierten Namen wiederholt anzugeben oder stattdessen zahlreiche zu verwenden using-Erklärungen.

Warum die Kritik an Koenig Lookup?

Sich zu sehr auf die Koenig-Suche zu verlassen, kann zu semantischen Problemen führen und den Programmierer manchmal unvorbereitet treffen.

Betrachten Sie das Beispiel von std::swap, bei dem es sich um einen Standardbibliotheksalgorithmus zum Austauschen zweier Werte handelt. 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);

Mit ADL, welche Version von swap Funktion aufgerufen wird, würde vom Namensraum der übergebenen Argumente abhängen.

Wenn es einen Namensraum gibt Aund wenn A::obj1, A::obj2und A::swap() existieren, dann führt das zweite Beispiel zu einem Aufruf an A::swap()was möglicherweise nicht das ist, was der Benutzer wollte.

Ferner, wenn aus irgendeinem Grund beides A::swap(A::MyClass&, A::MyClass&) und std::swap(A::MyClass&, A::MyClass&) definiert sind, dann wird das erste Beispiel aufgerufen std::swap(A::MyClass&, A::MyClass&) aber die zweite wird nicht kompiliert, weil swap(obj1, obj2) wäre zweideutig.

Wissenswertes:

Warum heißt es „Koenig-Lookup“?

Da es von einem ehemaligen Forscher und Programmierer von AT&T und Bell Labs entwickelt wurde, Andreas König.

Weiterlesen:

• Herb Sutters Namenssuche auf GotW

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

**¹** Die Definition der Koenig-Suche ist wie in Josuttis’ Buch *The C++ Standard Library: A Tutorial and Reference* definiert.

Wenn in der Koenig-Suche eine Funktion aufgerufen wird, ohne ihren Namensraum anzugeben, dann ist der Name einer Funktion Auch gesucht in Namespace(s), in denen der Typ des Arguments/der Argumente definiert ist. Deshalb wird es auch als bezeichnet Argumentabhängige Namenssuchekurz einfach ADL.

Aufgrund von Koenig Lookup können wir Folgendes 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, in Ermangelung von Koenig Lookup sogar a Hallo Welt Programm sieht kompliziert aus.

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

Als Namespaces eingeführt wurden, war die Idee, alles in Namespaces zu definieren, damit separate Bibliotheken sich nicht gegenseitig stören. Dies führte jedoch zu einem Problem mit den Operatoren. Sehen 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ättest du schreiben können N::operator++(x), aber das hätte den eigentlichen Punkt der Operatorüberladung zunichte gemacht. Daher musste eine Lösung gefunden werden, die es dem Compiler ermöglichte, zu finden operator++(X&) trotz der Tatsache, dass es nicht im Geltungsbereich war. Auf der anderen Seite sollte es immer noch keinen anderen finden operator++ in einem anderen, nicht verwandten Namensraum definiert, wodurch der Aufruf mehrdeutig werden könnte (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 Koenig-Lookup genannt.

Der Trick besteht darin, dass für Funktionsaufrufe zusätzlich zur normalen Namenssuche (die Namen im Geltungsbereich zum Zeitpunkt der Verwendung findet) eine zweite Suche in den Geltungsbereichen der Typen aller an die Funktion übergebenen Argumente durchgeführt wird. Also im obigen Beispiel, wenn Sie schreiben x++ in der Hauptsache sucht es operator++ nicht nur im globalen Geltungsbereich, sondern auch in dem Geltungsbereich, in dem der Typ von x, N::Xwurde definiert, dh in namespace N. Und dort findet es ein passendes operator++und deshalb x++ funktioniert einfach. Andere operator++ in einem anderen Namensraum definiert, sagen wir N2, wird jedoch nicht gefunden. Da ADL nicht auf Namensräume beschränkt ist, können Sie auch verwenden f(x) anstatt N::f(x) in main().

Nicht alles daran ist meiner Meinung nach 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, bedenken Sie, dass nicht nur die Namespaces, in denen die Argumente definiert sind, berücksichtigt werden, sondern auch die Argumente von Template-Argumenten der Argumente, von Parametertypen von Funktionstypen / Pointee-Typen von Zeigertypen dieser Argumente , und so weiter und fort.

Ein Beispiel mit Boost

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

Dies führte zu einer Unklarheit, wenn der Benutzer die boost.range-Bibliothek verwendet, da beide std::begin gefunden wird (von ADL mit std::vector) und boost::begin gefunden wird (von ADL mit boost::shared_ptr).