基于嵌套 typedef 存在的类型决策

Question

我需要定义一个模板结构：

element<T>::type

属于：

T::element_type 

如果 T 包含一个名为 element_type 的（公共）typedef，否则（如果它不包含这样的 typedef）

element<T>::type

属于类型

T::value_type 

如果 T 是可变的并且属于类型

const T::value_type

如果 T 是常数。

我真的很挣扎，任何建议都非常感谢！ :)

非常感谢您提前提供的帮助！

Answer 1

可能是这样的：

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

这当然应该被拆分和组织。

Answer 2

作为使用 SFINAE 声明特征类的替代方法，您可以通过部分特化更巧妙地使用它。

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

...您可能想添加另一个案例以使element_type const 为const T？不幸的是，这在 GCC 中不起作用，尽管 Comeau 接受了它。

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

我用来测试的代码：

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;