Question

我正面临以下问题：

我有一些通用容器，可以对类型进行一些操作。为简单起见，操作在请求时是线程安全的。并且，请求表示容器中的类型具有typedef std::true_type needs_thread_safety;。

struct thread_safe_item {
    typedef std::true_type needs_thread_safety;
    /* */ 
};

struct thread_unsafe_item {
    typedef std::false_type needs_thread_safety;
    /* */
};
template<typename TItem> container {
    /* some algorithms, that are std::enable_if selected, according to needs_thread_safety */
};

但是，我希望needs_thread_safety能够选择加入，而不需要定义（=默认false_type）。我试过以下：

    struct thread_unsafe_item {
        /* */ 
    };

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

        template <typename C> static yes& test(typename C::needs_thread_safety*);
        template <typename> static no& test(...);

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

    typedef 
        typename std::conditional<
            has_defined_thread_safety<TItem>::value,
            typename TItem::needs_thread_safety,
            std::false_type
        >::type needs_thread_safety;
};
....
struct <typename TItem> container {
    /* changed all TItem::needs_thread_safety selectors to thread_safety_selector<TItem>::needs_thread_safety */
};

但显然没有延迟评估，因为错误是error C2039: 'needs_thread_safety' : is not a member of 'thread_unsafe_item'。

如何为未指定的参数实现默认值？

这是出于教育目的，所以我不需要不同的方法来解决这个问题。

谢谢！

Answer 1

你不能使用std::conditional，因为它总是会解析它的所有参数。您可以创建自己的谓词：

template <bool, class>
struct get_thread_safety;

template <class T>
struct get_thread_safety<true, T>
{
  typedef typename T::needs_thread_safety type;
};

template <class T>
struct get_thread_safety<false, T>
{
  typedef std::false_type type;
};

// Used like this:

typedef 
    typename get_thread_safety<
        has_defined_thread_safety<TItem>::value,
        TItem
    >::type needs_thread_safety;

Answer 2

实际上使用std::enable_if加std::conditional可以更容易实现这一点：

#include <iostream>
#include <type_traits>

// Classes to be checked against needs_thread_safety
struct A {};
struct B { typedef std::true_type needs_thread_safety; };
struct C { typedef std::false_type needs_thread_safety; };

// Checker helper
template<class T> class get_thread_safety
{
    typedef char(&zero_size_t)[0];

    template <class X> static typename std::enable_if<X::needs_thread_safety::value, char>::type check(int);
    template <class X> static typename std::enable_if<!X::needs_thread_safety::value, zero_size_t>::type check(int);
    template <class X> static zero_size_t check(...);

public:
    typedef typename std::conditional<sizeof(check<T>(0)), std::true_type, std::false_type>::type type;
};

int main()
{
   // Usage. Will print 0 1 0
   std::cout << get_thread_safety<A>::type::value << std::endl;     
   std::cout << get_thread_safety<B>::type::value << std::endl;
   std::cout << get_thread_safety<C>::type::value << std::endl; 

   return 0;
}

Answer 3

您实际上可以以惰性方式使用std::conditional，您只需要避免在其模板参数列表中使用嵌套的typedef。您还需要false案例的另一种后备类型（“默认值”，如您所说）：

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

        template <typename C> static yes& test(typename C::needs_thread_safety*);
        template <typename> static no& test(...);

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

    // this would be your "default value"
    struct not_thread_safe {
        typedef std::false_type needs_thread_safety;
    };

    typedef
        typename std::conditional<
            has_defined_thread_safety<TItem>::value,
            TItem,   // <---- note, not using the typedef here
            not_thread_safe
        >::type::needs_thread_safety  needs_thread_safety;
     //  ^^^^^^^^^^^^^^^^^^^^^^^^^^^
     //  lazily, after the selection is done
};

如何在模板元编程中使用“默认”值

3 个答案: