Thứ tự tìm kiếm phạm vi biểu tượng C++ khác nhau đối với mẫu và lớp không phải mẫu?

Question

#include <iostream> 

void foo() 
{ 
    std::cout << "global foo()" << std::endl; 
} 

struct A { 
    void foo() 
    { 
     std::cout << "A::foo()" << std::endl; 
    } 
}; 

struct B : public A { 
    void call() 
    { 
     foo(); 
    } 
}; 

int main(int argc, char **argv) 
{ 
    B b; 
    b.call(); 
    return 0; 
} 

Điều này cho phép expected result:

A::foo() 

Tuy nhiên sau khi thay đổi hai dòng (lớp B để mẫu):

#include <iostream> 

void foo() 
{ 
    std::cout << "global foo()" << std::endl; 
} 

struct A { 
    void foo() 
    { 
     std::cout << "A::foo()" << std::endl; 
    } 
}; 

template <typename T> // change here 
struct B : public T { 
    void call() 
    { 
     foo(); 
    } 
}; 

int main(int argc, char **argv) 
{ 
    B<A> b; // and here 
    b.call(); 
    return 0; 
} 

tôi nhận được unexpected result:

global foo() 

Và sử dụng this-> là không phải là một lựa chọn như tôi đang cố gắng để cre ăn một cơ chế "dự phòng".

Answer 1

Những gì bạn nhận được là kết quả mong đợi. Điều này được gọi là "tra cứu tên hai pha" trong tiêu chuẩn C++.

Tên bên trong các mẫu được chia thành hai loại:

phụ thuộc - tên mà phụ thuộc vào các thông số mẫu nhưng không được khai báo bên trong mẫu.

Không phụ thuộc - tên không phụ thuộc vào thông số mẫu, cộng với tên của bản thân mẫu và tên được khai báo trong đó.

Khi trình biên dịch cố gắng giải quyết một số tên trong mã, trước tiên nó quyết định xem tên có phụ thuộc hay không và quá trình giải quyết bắt nguồn từ sự khác biệt này. Trong khi các tên không phụ thuộc được giải quyết "bình thường" - khi mẫu được xác định, độ phân giải cho các tên phụ thuộc sẽ xảy ra tại thời điểm tạo bản mẫu.

foo(); trong B::call trong ví dụ của bạn là tên không phụ thuộc, do đó, nó được giải quyết toàn cầu foo() tại điểm định nghĩa mẫu.

Answer 2

Bạn cần phải thông báo cụ thể để sử dụng phương pháp lớp T.

template <typename T> 
struct B : public T { 
    void call() 
    { 
     T::foo(); 
    } 
}; 

---

Nhưng như đối với một cơ chế dự phòng, bạn có thể kiểm tra câu hỏi này: Is it possible to write a template to check for a function's existence?

Sử dụng một thất bại Thay không phải là một lỗi (SFINAE), bạn có thể kiểm tra cho phương thức foo trong T, rồi chạy phương thức thích hợp.

Answer 3

Câu trả lời được chấp nhận giải thích lý do bạn thấy hành vi đó, nhưng không phải là cách đạt được hành vi "dự phòng" mà bạn muốn. Điều đó có thể được thực hiện bằng cách sử dụng SFINAE, bằng cách giới thiệu một cặp quá tải mẫu thành viên, một trong số đó sẽ chỉ tồn tại nếu lớp cơ sở có hàm thành viên được gọi là foo.

template <typename T> 
struct B : T { 
    template <void (T::*)()> struct has_mem_fn {}; 

    template <typename U> void call(has_mem_fn<&U::foo>*) {this->foo();} 
    template <typename U> void call(...) {foo();} 

    void call() {call<T>(0);} 
}; 

struct X {}; 

int main() 
{ 
    B<A> ba; 
    ba.call(); // A::foo() 

    B<X> bx; 
    bx.call(); // global foo() 
} 

UPDATE: nơi bạn nói bạn biết phương pháp này, nhưng không thể sử dụng nó do phải hỗ trợ trình biên dịch rối loạn chức năng. Trong trường hợp đó, tôi sợ rằng những gì bạn muốn có lẽ là không thể.