Question

我想知道如何在C ++中执行以下操作：

考虑这些课程：

C1 < C2 < C3 < ... < Cn, Ci < Cj表示sizeof(Ci) < sizeof(Cj)

我想要一个使用可变参数模板作为Ci的序列的结构，

OrderBySize<AnySequenceOfCis>，例如：OrderBySize<C1,C2,C3,...,Cn>或 OrderBySize<C2,C1,C3,C4,...,Cn> ...所有可能的组合

并给出以下结构：

class result{
  Cn elem1;
  Cn-1 elem2;
  .
  .
  .
  C1 elemn;
}

我看了this article，它显示了我们如何定义Tuple<typename ...T>，但是，这是不同的，更难以实现并且非常有用。

编辑：

order_by_size<T1, ..., Tn> 包含 T1, ..., Tn的有序组合的元组

但是我不希望用户知道我在命令字段，用户会像元组一样使用它。因此，为了访问字段，用户将使用：

template<typename... Tn> get<size_t>(const MyStructure<Tn ...>& m)获取size_t个元素，该元素在新tuple中有另一个索引。

enter image description here

Answer 1

基本上，这个问题简化为仅根据给定的比较器对类型列表进行排序。一旦你拥有了，其他一切都随之而来。所以这个答案只是排序部分。我们将从一个类型列表开始：

template <typename...>
struct typelist {
    using type = typelist;
};

我将假设一组非常短的元函数（head，tail，concat，size）。为简洁起见，我将省略它们。

所以，让我们跳进编写合并排序：

template <typename TL, typename Cmp = LessSize>
struct sort
{
    using left_right = typename split<TL, size<TL>::value/2>::type;
    using left = typename sort<head_t<left_right>, Cmp>::type;
    using right = typename sort<head_t<tail_t<left_right>>, Cmp>::type;

    using type = typename merge<left, right, Cmp>::type;
};

// base case for exactly 1 element
template <typename T, typename Cmp>
struct sort<typelist<T>, Cmp> {
    using type = typelist<T>;
};

// potentially add a base case for exactly 2 elements here?

这里的一般结构应该看起来很熟悉。我们将类型列表TL分成两个相等的部分，对它们进行排序，然后合并。当然，这是元编程，因此一切都不必要地复杂化。

让我们从split开始吧。 split获取一个类型列表和一个大小，并返回两个类型列表的类型列表：第一个具有给定的大小，第二个是剩余的：

template <typename A, typename B, size_t N>
struct split_impl
    : std::conditional<
        size<A>::value < N,
        split_impl<concat_t<A, typelist<head_t<B>>>, tail_t<B>, N>,
        typelist<A, B>
        >::type
{ };

template <typename TL, size_t N>
struct split
    : split_impl<typelist<>, TL, N>
{ };

因此，我们left和right（至少在我们应用head_t<>和head_t<tail_t<>>后）。剩下的就是merge步骤了。我正在使用Boost MPL关于元函数类的概念，所以LessSize是：

struct LessSize {
    template <typename A, typename B>
    using apply = std::integral_constant<bool, sizeof(A) < sizeof(B)>;
};

merge只需要走两个类型列表并根据两个类型列表之间的比较器选择最小元素。首先，我们将从所有基本情况开始：

template <typename L, typename R, typename Cmp>
struct merge;

// R empty
template <typename... T, typename Cmp>
struct merge<typelist<T...>, typelist<>, Cmp> {
    using type = typelist<T...>;
};

// L empty
template <typename... T, typename Cmp>
struct merge<typelist<>, typelist<T...>, Cmp> {
    using type = typelist<T...>;
};

然后是递归步骤，这有点难看：

template <typename A, typename... As, typename B, typename... Bs, typename Cmp> 
struct merge<typelist<A, As...>, typelist<B, Bs...>, Cmp>
: std::conditional<
        Cmp::template apply<A, B>::value,
        concat_t<typelist<A>, typename merge<typelist<As...>, typelist<B, Bs...>, Cmp>::type>,
        concat_t<typelist<B>, typename merge<typelist<A, As...>, typelist<Bs...>, Cmp>::type>
        >::type
{ };

基本上，给定两个类型列表{A, As...}和{B, Bs...}，我们选择基于Cmp的最小值，这就是我们从中弹出元素的一面。如果Cmp::apply<A,B>，则我们会将A与{As...}与{B, Bs...}合并的结果联系起来。反之亦然。

这就是她所写的全部内容：

template <typename T>
struct TD;

int main()
{
    using T = sort<typelist<int, double, char, float>, LessSize>::type;
    TD<T> r;
}

main.cpp: In function 'int main()':
main.cpp:131:11: error: aggregate 'TD<typelist<char, float, int, double> > r' has incomplete type and cannot be defined
     TD<T> r;
           ^

一旦你有了排序类型，制作元组很简单：

template <template <typename...> class C>
struct meta_quote {
    template <typename... T>
    using apply = C<T...>;
};

template <typename F, typename TL>
struct meta_apply;

template <typename F, typename... T>
struct meta_apply<F, typelist<T...>> {
    using type = typename F::template apply<T...>;
};

template <typename... T>
struct my_tuple
: meta_apply<meta_quote<std::tuple>,
             typename sort<typelist<T...>>::type
             >::type;
{ 
    using base_tuple = meta_apply<...>;
};

现在只需在get<>上添加my_tuple<T...>的重载：

template <size_t I, typename... T>
auto get(my_tuple<T...>& t) {
    using type = std::tuple_element_t<I, std::tuple<T...>>;
    return std::get<type>(static_cast<typename my_tuple<T...>::base_type&>(t));
}

Answer 2

这可能不是最有效的实现（它使用类型的循环置换来确定具有最大大小的类型），并且可能包含错误，但整个想法应该是清楚的。结果是std::tuple，其类型按降序排序。主函数检查它是否真的有效（并且它适用于我的gcc-4.8.2）。

#include <iostream>
#include <tuple>
#include <iomanip>

constexpr std::size_t max (std::size_t x, std::size_t y)
{
   return (x < y) ? y : x;
}

template <typename ... Ts>
struct max_size;

template < >
struct max_size < >
{
       static constexpr std::size_t result = 0;
};

template <typename T, typename ... Ts>
struct max_size <T, Ts...>
{
       static constexpr std::size_t result = max(sizeof(T), max_size<Ts...>::result);
};

template <typename R, typename ... Ts>
struct order_by_size_impl;

template <bool M, typename R, typename ... Ts>
struct order_by_size_helper;

template <typename ... Rs, typename T, typename ... Ts>
struct order_by_size_helper<true, std::tuple<Rs...>, T, Ts...>
    : order_by_size_impl<std::tuple<Rs..., T>, Ts...>
{ };

template <typename ... Rs, typename T, typename ... Ts>
struct order_by_size_helper<false, std::tuple<Rs...>, T, Ts...>
    : order_by_size_impl<std::tuple<Rs...>, Ts..., T>
{ };

template <typename ... Rs, typename T, typename ... Ts>
struct order_by_size_impl<std::tuple<Rs...>, T, Ts...>
    : order_by_size_helper<sizeof(T) >= max_size<Ts...>::result, std::tuple<Rs...>, T, Ts...>
{ };

template <typename ... Rs>
struct order_by_size_impl<std::tuple<Rs...>>
{
       typedef std::tuple<Rs...> result;
};

template <typename ... Ts>
struct order_by_size
    : order_by_size_impl<std::tuple<>, Ts...>
{ };

struct test
{
   std::uint8_t data[128];
};

template <std::size_t I, typename T, typename R>
bool check (R const & r)
{
   return std::is_same<typename std::remove_cv<typename std::remove_reference<decltype(std::get<I>(r))>::type>::type, T>::value;
}

int main ( )
{
   order_by_size<std::uint8_t, std::uint32_t, std::uint16_t, std::uint64_t, test>::result r;
   std::cout << std::boolalpha;
   std::cout << check<0, test>(r) << std::endl;
   std::cout << check<1, std::uint64_t>(r) << std::endl;
   std::cout << check<2, std::uint32_t>(r) << std::endl;
   std::cout << check<3, std::uint16_t>(r) << std::endl;
   std::cout << check<4, std::uint8_t>(r) << std::endl;
}

按大小存储字段的结构

2 个答案: