Warum findet ADL keine Funktionsvorlagen?

Welcher Teil der C ++ - Spezifikation verhindert, dass die argumentabhängige Suche nach Funktionsvorlagen in den zugehörigen Namespaces sucht? Mit anderen Worten, warum kann der letzte Aufruf mainunten nicht kompiliert werden?

namespace ns {
    struct foo {};
    template<int i> void frob(foo const&) {}
    void non_template(foo const&) {}
}

int main() {
    ns::foo f;
    non_template(f); // This is fine.
    frob<0>(f); // This is not.
}

Dieser Teil erklärt es:

C ++ Standard 03 14.8.1.6 :

[Hinweis: Für einfache Funktionsnamen gilt die argumentabhängige Suche (3.4.2) auch dann, wenn der Funktionsname im Rahmen des Aufrufs nicht sichtbar ist. Dies liegt daran, dass der Aufruf immer noch die syntaktische Form eines Funktionsaufrufs hat (3.4.1). Wenn jedoch eine Funktionsvorlage mit expliziten Vorlagenargumenten verwendet wird, hat der Aufruf nicht die richtige syntaktische Form, es sei denn, am Aufrufpunkt ist eine Funktionsvorlage mit diesem Namen sichtbar. Wenn kein solcher Name sichtbar ist, ist der Aufruf syntaktisch nicht wohlgeformt und die argumentabhängige Suche gilt nicht. Wenn ein solcher Name sichtbar ist, gilt die argumentabhängige Suche, und zusätzliche Funktionsvorlagen können in anderen Namespaces gefunden werden.

namespace A {
  struct B { };
  template<int X> void f(B);
}
namespace C {
  template<class T> void f(T t);
}
void g(A::B b) {
  f<3>(b);    //ill-formed: not a function call
  A::f<3>(b); //well-formed
  C::f<3>(b); //ill-formed; argument dependent lookup
              // applies only to unqualified names
  using C::f;
  f<3>(b);    //well-formed because C::f is visible; then
              // A::f is found by argument dependent lookup
}

Seit c ++ 20 funktioniert adl auch mit expliziten Funktionsvorlagen. Hier ist der Vorschlag: P0846R0 : ADL- und Funktionsvorlagen, die nicht sichtbar sind :

Anstatt den Benutzer zur Verwendung des Schlüsselworts template zu verpflichten, wurde eine Überarbeitung der Suchregeln vorgeschlagen, sodass ein Name, für den eine normale Suche entweder kein Ergebnis liefert oder eine oder mehrere Funktionen findet und dem ein aa "<" folgt, als behandelt wird Wenn ein Funktionsvorlagenname gefunden wurde und die Ausführung von ADL bewirken würde.

Derzeit hat nur GCC 9 diese Funktion implementiert, sodass Ihr Beispiel kompiliert werden kann.

live demo.

Ich möchte die leicht akzeptierte Antwort verfeinern. Es ist in der OP-Frage nicht klar, aber der wichtige Teil des Standards (zitiert von Kornel) ist folgender (Schwerpunkt Mine):

Wenn jedoch eine Funktionsvorlage mit expliziten Vorlagenargumenten verwendet wird, hat der Aufruf nicht die richtige syntaktische Form

Was also verboten ist, ist sich auf ADL zu verlassen und explizite Vorlagenargumente zu verwenden. Leider erfordert die Verwendung von Vorlagenargumenten, die nicht vom Typ sind, die Verwendung expliziter Argumente (es sei denn, sie haben Standardwerte).

Unten finden Sie einen Beispielcode, der dies zeigt:

[Leben]

#include <string>
#include <utility>

namespace C {
  struct B { };
  template<class T> void f(T t){}
}

void g(C::B b) {
  f(b);           // OK
  //f<C::B>(b);   // ill-formed: not a function call, but only 
                  //  because explicit template argument were used

  std::string s;
  move(s);                      // OK
  //move<std::string&>(s);      // Error, again because 
                                //  explicit template argument were used
  std::move<std::string&>(s);   // Ok
}

int main()
{
 C::B b;
 g(b);
}

Edit: Nein, das ist nicht richtig. Siehe @ Kornels Antwort .

Ich bin nicht ganz sicher , aber Stroustrup „The C ++ Programmiersprache“ Ich denke , dass 13.8.4 Anhang C Abschnitt Konsultation könnte die Ursache sein.

Da frobes sich um eine Vorlage handelt, kann man sie möglicherweise i=0zu einem Zeitpunkt spezialisieren, nachdem Sie sie aufgerufen haben. Dies bedeutet, dass der Implementierung zwei Möglichkeiten zur Auswahl übrig bleiben, welche frobaufgerufen werden soll, wie es scheint. Sie kann sie zum Zeitpunkt der Instanziierung oder am Ende der Verarbeitung der Übersetzungseinheit auswählen .

Ich denke, das Problem ist, dass Sie es tun könnten

namespace ns {
    struct foo {};
    template<int i> void frob(foo const&) {}
}

int main() {
    ns::foo f;
    frob<0>(f);
    return 0;
}

namespace ns {
    template<> void frob< 0 >(foo const&) { /* Do something different*/ }
}