Tại sao ADL không tìm thấy các mẫu hàm?

Phần nào của đặc tả C ++ hạn chế tra cứu đối số phụ thuộc vào việc tìm các mẫu hàm trong tập hợp các không gian tên được liên kết? Nói cách khác, tại sao lệnh gọi cuối cùng mainbên dưới không biên dịch được?

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

Phần này giải thích nó:

Tiêu chuẩn C ++ 03 14.8.1.6 :

[Lưu ý: Đối với tên hàm đơn giản, tra cứu phụ thuộc đối số (3.4.2) được áp dụng ngay cả khi tên hàm không hiển thị trong phạm vi của lệnh gọi. Điều này là do lệnh gọi vẫn có dạng cú pháp của một lệnh gọi hàm (3.4.1). Nhưng khi một mẫu hàm có các đối số mẫu rõ ràng được sử dụng, thì lệnh gọi không có dạng cú pháp chính xác trừ khi có mẫu hàm có tên đó hiển thị tại điểm gọi. Nếu không có tên nào như vậy được hiển thị, lệnh gọi không được định dạng tốt về mặt cú pháp và tra cứu phụ thuộc vào đối số không áp dụng. Nếu một số tên như vậy hiển thị, thì sẽ áp dụng tra cứu phụ thuộc đối số và có thể tìm thấy các mẫu hàm bổ sung trong các không gian tên khác.

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
}

Kể từ c ++ 20, adl cũng hoạt động tốt với mẫu hàm rõ ràng. Đây là đề xuất: P0846R0: Mẫu ADL và Hàm không Hiển thị :

Thay vì yêu cầu người dùng sử dụng từ khóa mẫu, một bản sửa đổi đối với các quy tắc tra cứu đã được đề xuất để một tên mà một tra cứu thông thường không tạo ra kết quả hoặc không tìm thấy một hoặc nhiều hàm và theo sau là aa "<" sẽ được coi là nếu một tên mẫu chức năng đã được tìm thấy và sẽ khiến ADL được thực hiện.

Hiện tại, chỉ có GCC 9 triển khai tính năng này, vì vậy ví dụ của bạn có thể biên dịch.

live demo.

Tôi muốn lọc lại câu trả lời được chấp nhận một chút. Nó không rõ ràng trong câu hỏi OP, nhưng phần quan trọng của tiêu chuẩn (trích dẫn bởi Kornel) là điều này (tôi nhấn mạnh):

Nhưng khi một mẫu hàm có các đối số mẫu rõ ràng được sử dụng, thì lệnh gọi không có dạng cú pháp chính xác

vì vậy điều bị cấm là dựa vào ADL và sử dụng các đối số mẫu rõ ràng. Thật không may khi sử dụng các đối số mẫu không phải kiểu yêu cầu sử dụng các đối số rõ ràng (trừ khi chúng có giá trị mặc định).

Dưới đây là mã mẫu hiển thị điều này:

[trực tiếp]

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

Chỉnh sửa: Không, điều này không đúng. Xem câu trả lời của @ Kornel .

Tôi không hoàn toàn chắc chắn nhưng đã tham khảo "Ngôn ngữ lập trình C ++" của Stroustrup, tôi nghĩ rằng Phụ lục C phần 13.8.4 có thể là nguyên nhân.

Vì froblà một khuôn mẫu, người ta có thể hình dung nó chuyên biệt hóa nó i=0tại một thời điểm sau khi bạn gọi nó. Điều này có nghĩa là việc triển khai sẽ được để lại với hai cách có thể để chọn cách frobgọi khi nó xuất hiện, nó có thể chọn nó tại điểm khởi tạo hoặc khi kết thúc xử lý đơn vị dịch.

Vì vậy, tôi nghĩ vấn đề là bạn có thể làm

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