decisión de tipo basado en la existencia de typedef anidada

Question

necesito para definir una estructura de plantilla tal que:

element<T>::type 

es de tipo:

T::element_type 

si T contiene un (público) ELEMENT_TYPE typedef llamado, de otro modo (si no contiene tales typedef)

element<T>::type 

es de tipo

T::value_type 

si T es mutable y de tipo

const T::value_type 

si T es constante.

Realmente estoy luchando con esto, cualquier sugerencia es muy apreciada! :)

¡Muchas gracias por su ayuda con anticipación!

Answer 1

Tal vez algo como:

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

Esto debe por supuesto ser dividido y organizado.

Answer 2

Como alternativa a la declaración de una clase de rasgos utilizando SFINAE, puede usarla de forma más sutil con especialización parcial.

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

... es posible que desee agregar otro caso para hacer element_type const para const T? Desafortunadamente, esto no funciona en GCC, aunque Comeau lo acepta.

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

Código que utiliza para probar esto:

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;