Dlaczego ADL nie znajduje szablonów funkcji?

Która część specyfikacji C ++ ogranicza wyszukiwanie zależne od argumentów od znajdowania szablonów funkcji w zestawie powiązanych przestrzeni nazw? Innymi słowy, dlaczego ostatnie wywołanie mainponiżej nie daje się skompilować?

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

Ta część wyjaśnia to:

Standard C ++ 03 14.8.1.6 :

[Uwaga: W przypadku prostych nazw funkcji wyszukiwanie zależne od argumentów (3.4.2) ma zastosowanie nawet wtedy, gdy nazwa funkcji nie jest widoczna w zakresie wywołania. Dzieje się tak, ponieważ wywołanie nadal ma postać składniową wywołania funkcji (3.4.1). Ale gdy używany jest szablon funkcji z jawnymi argumentami szablonu, wywołanie nie ma poprawnej formy składniowej, chyba że istnieje szablon funkcji o tej nazwie widoczny w miejscu wywołania. Jeśli żadna taka nazwa nie jest widoczna, wywołanie nie jest poprawnie sformułowane składniowo, a wyszukiwanie zależne od argumentów nie ma zastosowania. Jeśli jakaś taka nazwa jest widoczna, ma zastosowanie wyszukiwanie zależne od argumentów, a dodatkowe szablony funkcji można znaleźć w innych przestrzeniach nazw.

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
}

Od C ++ 20 adl działa również dobrze z jawnym szablonem funkcji. Oto propozycja: P0846R0: Szablony ADL i funkcji, które nie są widoczne :

Zamiast wymagać od użytkownika użycia słowa kluczowego szablonu, zaproponowano zmianę reguł wyszukiwania, tak aby nazwa, dla której normalne wyszukiwanie nie dawała żadnego wyniku lub znajdowała jedną lub więcej funkcji, po której następuje aa „<”, byłaby traktowana jako jeśli nazwa szablonu funkcji została znaleziona i spowodowałaby wykonanie ADL.

Obecnie tylko GCC 9 ma zaimplementowaną tę funkcję, więc Twój przykład może się kompilować.

live demo.

Chciałbym zawęzić lekko zaakceptowaną odpowiedź. Nie jest to jasne w pytaniu PO, ale istotna część standardu (cytowana przez Kornela) jest taka (wyróżnienie moje):

Ale gdy używany jest szablon funkcji z jawnymi argumentami szablonu , wywołanie nie ma poprawnej formy składniowej

więc to, co jest zabronione, to poleganie na ADL i używanie jawnych argumentów szablonów. Niestety użycie argumentów szablonu innego niż typ wymaga użycia jawnych argumentów (chyba że mają wartości domyślne).

Poniżej znajduje się przykładowy kod pokazujący to:

[relacja na żywo]

#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);
}

Edycja: Nie, to nie jest w porządku. Zobacz odpowiedź @ Kornel .

Nie jestem do końca pewien, ale po konsultacji z „Językiem programowania C ++” Stroustrupa myślę, że przyczyną może być sekcja 13.8.4 dodatku C.

Ponieważ frobjest to szablon, można by go wyspecjalizować i=0w momencie, gdy go wywołasz. Oznacza to, że implementacji pozostałyby dwa możliwe sposoby wyboru frobwywołania, ponieważ wydaje się, że może to wybrać w momencie tworzenia instancji lub na końcu przetwarzania jednostki tłumaczącej.

Więc myślę, że problem polega na tym, że możesz to zrobić

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*/ }
}