Почему ADL не находит шаблоны функций?

Какая часть спецификации C ++ ограничивает поиск, зависящий от аргументов, от поиска шаблонов функций в наборе связанных пространств имен? Другими словами, почему последний вызов mainниже не компилируется?

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

Эта часть объясняет это:

Стандарт C ++ 03 14.8.1.6 :

[Примечание: для простых имен функций поиск, зависящий от аргументов (3.4.2), применяется, даже если имя функции не отображается в рамках вызова. Это связано с тем, что вызов по-прежнему имеет синтаксическую форму вызова функции (3.4.1). Но когда используется шаблон функции с явными аргументами шаблона, вызов не имеет правильной синтаксической формы, если не существует шаблона функции с таким именем, видимого в точке вызова. Если такое имя не отображается, вызов не имеет синтаксической правильной формы и поиск, зависящий от аргументов, не применяется. Если такое имя видно, применяется поиск, зависящий от аргументов, и дополнительные шаблоны функций могут быть найдены в других пространствах имен.

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
}

Начиная с C ++ 20, adl также отлично работает с явным шаблоном функции. Вот предложение: P0846R0: ADL и шаблоны функций, которые не видны :

Вместо того, чтобы требовать от пользователя использования ключевого слова шаблона, была предложена новая редакция правил поиска, чтобы имя, для которого обычный поиск либо не дает результата, либо находит одну или несколько функций, и за которым следует знак «<», будет рассматриваться как если было найдено имя шаблона функции, которое приведет к выполнению ADL.

В настоящее время только GCC 9 реализует эту функцию, поэтому ваш пример можно компилировать.

live demo.

Я хотел бы уточнить слегка принятый ответ. Это неясно в вопросе OP, но важная часть стандарта (цитируется Корнелем) заключается в следующем (выделено мной):

Но когда используется шаблон функции с явными аргументами шаблона , вызов не имеет правильной синтаксической формы.

поэтому запрещено полагаться на ADL и использовать явные аргументы шаблона. К сожалению, использование аргументов шаблона без типа требует использования явных аргументов (если у них нет значений по умолчанию).

Ниже приведен пример кода, показывающий это:

[прямой эфир]

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

Изменить: нет, это неправильно. См . Ответ @Kornel .

Я не совсем уверен, но, посоветовавшись с Страуструпом «Язык программирования C ++», я думаю, что причиной может быть раздел 13.8.4 Приложения C.

Поскольку frobэто шаблон, его можно было бы специализировать i=0в момент после того, как вы его вызовете. Это означает, что у реализации останется два возможных способа выбора того, какой из них frobвызывать, поскольку он, по-видимому, может выбрать его в точке создания экземпляра или в конце обработки единицы трансляции.

Итак, я думаю, проблема в том, что вы могли бы сделать

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