Trợ giúp với loại đặc điểm mà

Question

Giả sử chúng ta có lớp mẫu sau

template<typename T> class Wrap { /* ... */ }; 

Chúng tôi không thể thay đổiWrap. Nó quan trọng.

Cho phép có các lớp học bắt nguồn từ Wrap<T>. Ví dụ,

class NewInt : public Wrap<int>  { /* ... */ }; 
class MyClass : public Wrap<myclass> { /* ... */ }; 
class Foo  : public Wrap<Bar>  { /* ... */ }; 

Chúng tôi không thể thay đổi các lớp này quá. Tất cả các lớp trên là bên thứ 3. Chung không thuộc vê tôi.

Tôi cần thời gian biên dịch sau type_traits:

template<class T> 
struct is_derived_from_Wrap { 
    static const bool value = /* */; 
}; 

Tôi cần những gì?

assert(is_derived_from_Wrap<Int>::value == true); // Indeed I need static assert 
assert(is_derived_from_Wrap<MyClass>::value == true); 
assert(is_derived_from_Wrap<char>::value == false); 
struct X {}; 
assert(is_derived_from_Wrap<X>::value == false); 

Answer 1

Bạn có thể làm điều này bằng SFINAE nhưng loại hình này của huyền diệu nếu bạn không biết whats going on ...

template<typename T> class Wrap { }; 

struct myclass {}; 
struct X {}; 

class Int  : public Wrap<int>  { /* ... */ }; 
class MyClass : public Wrap<myclass> { /* ... */ }; 

template< typename X > 
struct is_derived_from_Wrap 
{ 
    struct true_type { char _[1]; }; 
    struct false_type { char _[2]; }; 

    template< typename U > 
    static true_type test_sfinae(Wrap<U> * w); 
    static false_type test_sfinae(...); 

    enum { value = sizeof(test_sfinae((X*)(0)))==sizeof(true_type) }; 
}; 


#include <iostream> 
#define test(X,Y) std::cout<<(#X " == " #Y)<<" : "<<((X)?"true":"false") <<std::endl; 

int main() 
{ 
    test(is_derived_from_Wrap <Int>::value, true); 
    test(is_derived_from_Wrap <MyClass>::value, true); 
    test(is_derived_from_Wrap <char>::value, false); 
    test(is_derived_from_Wrap <X>::value, false); 
} 

này mang lại cho sản lượng dự kiến ​​

is_derived_from_Wrap <Int>::value == true : true 
is_derived_from_Wrap <MyClass>::value == true : true 
is_derived_from_Wrap <char>::value == false : false 
is_derived_from_Wrap <X>::value == false : false 

Có một vài gotchas với mã của tôi. Nó cũng sẽ trả về true nếu kiểu là một Wrap.

assert( is_derived_from_Wrap< Wrap<char> >::value == 1); 

Điều này có thể được khắc phục bằng ma thuật SFINAE hơn một chút nếu cần.

Nó sẽ trả về false nếu nguồn gốc không phải là một nguồn gốc nào (nghĩa là private hay protected)

struct Evil : private Wrap<T> { }; 
assert(is_derived_from_Wrap<Evil>::value == 0); 

Tôi nghi ngờ điều này không thể được cố định. (Nhưng tôi có thể sai). Nhưng tôi nghi ngờ thừa kế công khai là đủ.

Answer 2

Sau đây sẽ xác định xem một cái gì đó là một bọc:

template<class T> 
struct is_Wrap { static const bool value = false; }; 

template<typename T> 
struct is_Wrap< Wrap<T> > { static const bool value = true; }; 

Kể từ nguồn gốc là một Is-Một mối quan hệ, mọi thứ đều bắt nguồn từ Wrap<T> cũng là một Wrap<T> và cần được tìm thấy bằng cách này.

Answer 3

Bạn cần thực hiện một số mẫu siêu lập trình liên quan đến mẫu để xác định xem một lớp X có xuất phát từ một Y khác hay không, trong trường hợp chung. Về cơ bản X có nguồn gốc từ Y nếu:

1. Y có thể được ngầm chuyển đổi sang X
2. X và Y là không cùng loại

Andrei Alexandrescu giải thích làm thế nào để làm điều này (cùng với nhiều mẫu thủ thuật khác) trong cuốn sách "Thiết kế C++ hiện đại".

Bạn có thể tìm mã giải quyết vấn đề của mình trong thư viện Loki hoặc triển khai uSTL, cả hai được viết bởi Alexandrescu.