Loại quyết định dựa trên sự tồn tại của lồng nhau typedef

Question

tôi cần phải xác định một mẫu cấu trúc như vậy:

element<T>::type 

là loại:

T::element_type 

nếu T chứa một (công cộng) typedef tên ELEMENT_TYPE, khác (nếu nó không chứa typedef như vậy)

element<T>::type 

là loại

T::value_type 

nếu T là có thể thay đổi và các loại

const T::value_type 

nếu T là hằng số.

Tôi thực sự đấu tranh với điều này, mọi đề xuất đều được đánh giá cao! :)

Cảm ơn bạn rất nhiều vì sự giúp đỡ của bạn trước!

Answer 1

Có lẽ cái gì đó như:

template <typename T> 
struct has_element_type 
{ 
    typedef char yes[1]; 
    typedef char no[2]; 

    template <typename C> 
    static yes& test(typename C::element_type*); 

    template <typename> 
    static no& test(...); 

    static const bool value = sizeof(test<T>(0)) == sizeof(yes); 
}; 

template <typename T> 
struct is_const 
{ 
    static const bool value = false; 
}; 


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

template <typename, bool> // true -> const 
struct value_type_switch; 

template <typename T> 
struct value_type_switch<T, true> 
{ 
    typedef const typename T::value_type type; 
}; 

template <typename T> 
struct value_type_switch<T, false> 
{ 
    typedef typename T::value_type type; 
}; 

template <typename, bool> // true -> has element_type 
struct element_type_switch; 

template <typename T> 
struct element_type_switch<T, true> 
{ 
    typedef typename T::element_type type; 
}; 


template <typename T> 
struct element_type_switch<T, false> 
{ 
    typedef typename value_type_switch<T, is_const<T>::value>::type type; 
}; 

template <typename T> 
struct element 
{ 
    typedef typename element_type_switch<T, 
            has_element_type<T>::value>::type type; 
}; 

này nên dĩ nhiên được tách ra và tổ chức.

Answer 2

Để thay thế cho việc khai báo một lớp đặc điểm sử dụng SFINAE, bạn có thể sử dụng nó một cách tinh tế hơn với chuyên môn từng phần.

template< typename T > 
struct empty { // support class is like stripped-down enable_if 
    typedef void type; 
}; 

template< class T, typename v = void > // v is always void! 
struct element { 
    typedef typename T::value_type type; 
}; 

template< class T, typename v > 
struct element< T const, v > { 
    typedef typename T::value_type const type; 
}; 

template< class T > // T in deduced context, T::element_type is SFINAE: 
struct element< T, typename empty< typename T::element_type >::type > { 
    typedef typename T::element_type type; 
}; 

... bạn có thể muốn thêm một trường hợp khác để làm cho element_type const cho const T? Thật không may điều này không làm việc trong GCC, mặc dù Comeau chấp nhận nó.

template< class T > 
struct element< T const, typename empty< typename T::element_type >::type > { 
    typedef typename T::element_type const type; 
}; 

Mã tôi sử dụng để kiểm tra điều này:

struct has_et { 
    typedef int element_type; 
}; 

struct has_vt { 
    typedef char value_type; 
}; 

char c; 
int i; 

element<has_vt>::type *cp = &c; 
element<has_et>::type *ip = &i;