Question

我试图将模板化方法限制为允许类型的给定列表及其重复的＆＃34;风味。

typedef boost::mpl::set<bool, int, double> allowedTypes;

class Foo
{
    typedef boost::mpl::set<bool, int, double> allowedTypes;
    template<class T>
    void some_templated_method()
    {
       BOOST_MPL_ASSERT((boost::mpl::has_key<allowedTypes, T>));
    }
}


// main.cpp
Foo foo;
struct restricted_type{};
foo.some_templated_method<restricted_type>(); // Compiles, why ?!

除此之外，我想知道如何自动过滤允许类型的重复版本。对于重复版本，我的意思是他们的std::vector<T>表示，而没有在mpl::set

中进行说明

e.g。

typedef boost::mpl::set<bool, 
                        int, 
                        double, 
                        std::vector<bool>,
                        std::vector<int>,
                        std::vector<double> > allowedTypes;

Answer 1

您始终可以自动创建包含原始集合及其容器包装对应项的序列。

为此，我们需要一个一元的lambda：

template <template <typename...> class Container>
struct MakeContainerOfT {
    template <typename T>
    struct impl {
        using type = Container<T>;
    };
 };

这可以处理除map之外的每个容器（它们需要值类型）和数组（有一个非类型模板参数）。作为奖励，这里是制作大小为N的数组的工厂：

template <std::size_t N>
struct ArrayOfT {
    template <typename T>
    struct impl {
        using type = std::array<T, N>;
    };
};

现在，我们需要一个设施，在我们的集合上为我们给出的任何容器应用这个lambda（或任何其他一元lambda）。

template <typename Sequence, template <typename> class Transform>
struct TransformedSequenceBuilder {
    using type = typename boost::mpl::reverse_fold<Sequence,
                                      boost::mpl::set0<>,
                                      boost::mpl::insert<boost::mpl::_1, 
                                                         Transform<boost::mpl::_2>>>::type;
};

我们终于可以继续使用＆＃34;累加器＆＃34;这将为变量lambda的变量序列执行此操作：

template <typename Sequence, template <typename> class... Transforms>
struct MakeFullSequence;

template <typename Sequence, template <typename> class Transform, template <typename> class... Tail>
struct MakeFullSequence<Sequence, Transform, Tail...> {

    using type = typename boost::mpl::reverse_fold<typename MakeFullSequence<Sequence, Tail...>::type,
                                      typename TransformedSequenceBuilder<Sequence, Transform>::type,
                                      boost::mpl::insert<boost::mpl::_1, boost::mpl::_2>>::type;
};

template <typename Sequence>
struct MakeFullSequence<Sequence> {
    typedef Sequence type;
};

最后一步是为您感兴趣的容器定义别名：

template <typename Sequence>
using wrapped_set = typename MakeFullSequence<Sequence,
                                              ContainerOfT<std::vector>::template impl,
                                              ContainerOfT<std::set>::template impl//,
                                              /* any transformation you fancy here */>::type;

为了测试这个，我们可以进行相等测试：

using le_set = boost::mpl::set<int, double, char>;
using le_vector_set = boost::mpl::set<std::vector<int>, std::vector<double>, std::vector<char>>;
using le_set_set = boost::mpl::set<std::set<int>, std::set<double>, std::set<char>>;

using le_transformed_set = wrapped_set<le_set>;
using le_manually_transformed_set = boost::mpl::joint_view<boost::mpl::joint_view<le_set, le_set_set>::type, le_vector_set>::type;

std::cout << boost::mpl::equal<le_transformed_set,
                               le_manually_transformed_set>::value;

用法非常简单：用户只提供＆＃34; raw＆＃34;类型集Set，每次需要时将逻辑分支到wrapped_set<Set>：

class Foo
{
    typedef boost::mpl::set<bool, int, double> allowedTypes;
    template<class T>
    void some_templated_method()
    {
       BOOST_MPL_ASSERT((boost::mpl::has_key<wrapped_set<allowedTypes>, T>));
    }
};

你可以找到演示，说明我们最终会得到原始集合，矢量包装集合和集合包裹集合的结合：Live Demo

通过这种设计，您还可以添加任何其他＆＃34;重复的味道＆＃34;你喜欢。引用（resp。const）对应的输入类型？只需传递std::add_lvalue_reference（分别为std::add_const）！

Answer 2

我认为正确的方法是添加自定义类型特征，专门为some_templated_method支持的类型赋予真正的价值。

#include <string>
#include <type_traits>
#include <vector>

template< typename T, typename TDummy = void > class
t_GoodForSomeTemplateMethod final
:   public ::std::integral_constant< bool, false >
{
    //  Nothing.
};

template<> class
t_GoodForSomeTemplateMethod< bool > final
:   public ::std::integral_constant< bool, true >
{
    //  Nothing.
};

template< typename TInt > class
t_GoodForSomeTemplateMethod< TInt, ::std::enable_if_t< ::std::is_integral< TInt >::value > > final
:   public ::std::integral_constant< bool, true >
{
    //  Nothing.
};

template< typename TFlt > class
t_GoodForSomeTemplateMethod< T, ::std::enable_if_t< ::std::is_floating_point< TFlt >::value > > final
:   public ::std::integral_constant< bool, true >
{
    //  Nothing.
};

template< typename TItem, typename TAllocator > class
t_GoodForSomeTemplateMethod< ::std::vector< TItem, TAllocator > > final
:   public ::std::integral_constant< bool, true >
{
    //  Nothing.
};

template< class T > void
SomeTemplateMethod(void)
{
    static_assert(t_GoodForSomeTemplateMethod< T >::value, "type is not suitable for SomeTemplateMethod");
}

int
main(void)
{
    SomeTemplateMethod< int >(); // ok
    SomeTemplateMethod< ::std::vector< char > >(); // ok
    SomeTemplateMethod< ::std::string >(); // error
}

断言是否允许模板参数

2 个答案: