Tại sao không B :: f giải quyết sự mơ hồ nhưng A :: f không?

Question

Tại sao không B :: f giải quyết sự mơ hồ nhưng A :: f không?

namespace A 
{ 
    class X { }; 
    void f(X); 
} 

namespace B 
{ 
    void f(A::X); 
    void g(A::X x) 
    { 
     using B::f; // which expression shall I use here to select B::f? 
     f(x);   // ambiguous A::f or B::f 
    } 
} 

Answer 1

Một sử dụng-khai hoạt động như một tuyên bố bình thường: nó che giấu tờ khai phạm vi bên ngoài, nhưng nó không ngăn chặn tra cứu luận phụ thuộc (ADL).

Khi bạn thực hiện using B::f, về cơ bản bạn không thay đổi gì cả. Bạn chỉ cần redeclare B::f trong phạm vi địa phương, nơi nó đã được nhìn thấy anyway. Điều đó cũng không ngăn ADL tìm được số A::f, điều này tạo ra sự mơ hồ giữa A::f và B::f.

Nếu bạn làm using A::f, khai báo địa phương là A::f sẽ ẩn khai báo ngoài của B::f. Vì vậy, B::f không còn hiển thị và không còn tìm thấy bằng tra cứu tên không đủ tiêu chuẩn. Chỉ có A::f được tìm thấy ngay bây giờ, có nghĩa là không còn mơ hồ nữa.

Không thể chặn ADL. Vì đối số trong trường hợp của bạn là loại A::X, chức năng A::f sẽ luôn được ADL tìm thấy cho tên không đủ tiêu chuẩn f. Bạn không thể "loại trừ" nó khỏi xem xét. Điều đó có nghĩa là bạn không thể mang lại B::f vào xem xét mà không tạo ra sự mơ hồ. Cách duy nhất xung quanh là sử dụng tên đủ điều kiện.

Khi @Richard Smith ghi chú chính xác trong các nhận xét, ADL có thể bị chặn. ADL chỉ được sử dụng khi tên hàm chính nó được sử dụng như biểu thức postfix trong lời gọi hàm. Chỉ định hàm mục tiêu theo bất kỳ cách nào khác sẽ kích hoạt ADL.

Ví dụ, khởi tạo của con trỏ hàm là không phụ thuộc vào ADL

void g(A::X x) 
{ 
    void (*pf)(A::X) = &f; 
    pf(x); 
} 

Trong ví dụ trên B::f sẽ được gọi. Và thậm chí là một cặp chỉ của () xung quanh tên hàm là đủ để ngăn chặn ADL, ví dụ:

void g(A::X x) 
{ 
    (f)(x); 
} 

là đã đủ để làm cho nó gọi B::f.

Answer 2

Bạn nên viết không gian tên mỗi lần một cách rõ ràng. Chỉ cần làm

#include <iostream> 

namespace A 
{ 
    class X { }; 
    void f(X) { 
     std::cout << "A"; 
    } 
} 

namespace B 
{ 
    void f(A::X) { 
     std::cout << "B"; 
    } 
    void g(A::X x) 
    { 
     // using B::f; 
     B::f(x);   
    } 
} 

int main() { 
    B::g(A::X()); // outputs B 
} 

Answer 3

Khi trình biên dịch cố gắng giải quyết f trong f(x) nó tìm thấy B::f kể từ khi chúng tôi đang trong namespace B. Nó cũng tìm thấy A::f sử dụng argument dependent lookup kể từ x là một phiên bản của X được xác định trong không gian tên A. Do đó sự mơ hồ.

Tuyên bố sử dụng B::f không có tác dụng vì chúng tôi đã có trong không gian tên B.

Để giải quyết sự mơ hồ, hãy sử dụng A::f(x) hoặc B::f(x).