正确对齐内存模板，参数顺序不变

时间：2018-01-01 20:43:53

标签： c++ c++11 templates template-meta-programming memory-alignment

看看这个模板。

template < typename T1, typename T2, typename T3 >
struct Alignement {
    T1 first;
    T2 second;
    T3 third;
};

int main() {
    Alignement<char, int, double> a1;
    Alignement<char, double, int> a2;
    assert( sizeof(a1) < sizeof(a2) );
    return 0;
}

显然断言是成立的。在这种情况下，次优排序会使内存使用量增加50％。

我的问题是，除了亲切地要求用户自己处理它之外，有什么方法可以对抗它并正确地对模板结构中的类型进行排序（如果他不知道大小的话会给他带来同样的问题。他的类型事先）？

我的想法是在编译时使用宏或TMP动态生成最佳排序，但我对这些技术没有适当的了解。或者，部分专业模板的军队可能会完成工作吗？

关键方面是保留客户端的AlignedObject.first语法。

对于我的具体情况，我正在寻找3个参数（3个！可能的排序）的解决方案，但一般的解决方案（包括变量长度模板）会很有趣。

3 个答案:

答案 0 :(得分：1)

#include <iostream>
#include <type_traits>

template <typename... O>
struct SizeOrder;

template <typename T1, typename T2, typename... Rest>
struct SizeOrder<T1, T2, Rest...> {
    using type = typename std::conditional<(T1::size::value > T2::size::value || (T1::size::value == T2::size::value && T1::order::value < T2::order::value)), typename SizeOrder<T2, Rest...>::type, int>::type;
};

template <typename T1, typename T2>
struct SizeOrder<T1, T2> {
    using type = typename std::conditional<(T1::size::value > T2::size::value || (T1::size::value == T2::size::value && T1::order::value < T2::order::value)), void, int>::type;
};

template <typename... T>
using Order = typename SizeOrder<T...>::type;

template <typename T1, int T2>
struct DeclarationOrder {
    using size = typename std::alignment_of<T1>;
    using order = typename std::integral_constant<int, T2>;
};

template <typename A, typename B, typename C, typename = void>
struct Alignement;

#define AO DeclarationOrder<A,1>
#define BO DeclarationOrder<B,2>
#define CO DeclarationOrder<C,3>

template <typename A, typename B, typename C>
struct Alignement<A, B, C, Order<AO, BO, CO>> {
    A first;
    B second;
    C third;
};

template <typename A, typename B, typename C>
struct Alignement<A, B, C, Order<AO, CO, BO>> {
    A first;
    C third;
    B second;
};

template <typename A, typename B, typename C>
struct Alignement<A, B, C, Order<BO, AO, CO>> {
    B second;
    A first;
    C third;
};

template <typename A, typename B, typename C>
struct Alignement<A, B, C, Order<BO, CO, AO>> {
    B second;
    C third;
    A first;
};

template <typename A, typename B, typename C>
struct Alignement<A, B, C, Order<CO, AO, BO>> {
    C third;
    A first;
    B second;
};

template <typename A, typename B, typename C>
struct Alignement<A, B, C, Order<CO, BO, AO>> {
    C third;
    B second;
    A first;
};


int main() {
    Alignement<char, int, double> t1;
    std::cout << sizeof(t1) << std::endl << sizeof(t1.first) << std::endl << sizeof(t1.second) << std::endl << std::endl;

    Alignement<char, double, int> t2;
    std::cout << sizeof(t2) << std::endl << sizeof(t2.first) << std::endl << sizeof(t2.second) << std::endl << std::endl;

    return 0;
}

编辑：添加订单＆lt;＆gt;模板以递归方式检查任意数量参数的大小顺序，并使用扩展的Aligenment来保存3个变量。

EDIT2：使用相同尺寸的类型时，模板扣除失败，因此我更改了SizeOrder template以采用DeclarationOrder模板，以消除类似Alignement<int, int, double>之类的2个可能订单的歧义

通过对godbolt的一些测试来找出宏部分，我们可以将整个事情压缩到这一点。

#include <iostream>
#include <type_traits>

template <typename... O>
struct SizeOrder;

template <typename T1, typename T2, typename... Rest>
struct SizeOrder<T1, T2, Rest...> {
    using type = typename std::conditional<(T1::size::value > T2::size::value || (T1::size::value == T2::size::value && T1::order::value < T2::order::value)), typename SizeOrder<T2, Rest...>::type, int>::type;
};

template <typename T1, typename T2>
struct SizeOrder<T1, T2> {
    using type = typename std::conditional<(T1::size::value > T2::size::value || (T1::size::value == T2::size::value && T1::order::value < T2::order::value)), void, int>::type;
};

template <typename... T>
using Order = typename SizeOrder<T...>::type;

template <typename T1, int T2>
struct DeclarationOrder {
    using size = typename std::alignment_of<T1>;
    using order = typename std::integral_constant<int, T2>;
};

template <typename A, typename B, typename C, typename = void>
struct Alignement;

#define AO DeclarationOrder<A,1>
#define BO DeclarationOrder<B,2>
#define CO DeclarationOrder<C,3>

#define Aname first
#define Bname second
#define Cname third

#define MAKE_SPECIALIZATION(FIRST, SECOND, THIRD) \
template <typename A, typename B, typename C> \
struct Alignement<A, B, C, Order<FIRST ## O, SECOND ## O,  THIRD ## O>> { \
    FIRST FIRST ## name; \
    SECOND SECOND ## name; \
    THIRD THIRD ## name; \
};

MAKE_SPECIALIZATION(A,B,C)
MAKE_SPECIALIZATION(A,C,B)
MAKE_SPECIALIZATION(B,A,C)
MAKE_SPECIALIZATION(B,C,A)
MAKE_SPECIALIZATION(C,A,B)
MAKE_SPECIALIZATION(C,B,A)


int main() {
    Alignement<char, int, double> t1;
    std::cout << sizeof(t1) << std::endl << sizeof(t1.first) << std::endl << sizeof(t1.second) << std::endl << std::endl;

    Alignement<char, double, int> t2;
    std::cout << sizeof(t2) << std::endl << sizeof(t2.first) << std::endl << sizeof(t2.second) << std::endl << std::endl;

    return 0;
}

要将其扩展为4个，5个或6个变量，我们需要更新struct Alignement以在template D之前添加template = void。然后我们#define DO DeclarationOrder<D,4>和#define Dname fourth。

然后我们将D和FOURTH添加到MAKE_SPECIALIZATION宏并定义所有（16？）可能的布局。

远非吱吱作响，但可行。

答案 1 :(得分：1)

  

对于我的具体情况，我正在寻找3个参数（3个！可能的排序）的解决方案，但一般的解决方案（包括变量长度模板）会很有趣。

我提出了一个通用的解决方案：一个可变类型的排序器和一个使用它的可变参数Alignement。

根据彼得的建议，我们的想法是先对biggers类型进行排序。

我使用C ++ 17，因为新模板折叠许可我使用C ++ 11，因为OP必须使用仅符合C ++ 11的编译器才能使非常简单一种类型特征，表示列表的第一种类型是否更大（根据sizeof()）。我维护，评论说，原始的C ++ 17版本

// iftb = is first type bigger ?

// original C++17 version
//
// template <typename T0, typename ... Ts>
// struct iftb
//    : public std::integral_constant<bool,((sizeof(Ts) <= sizeof(T0)) && ...)>
//  { };

template <typename ...>
struct iftb;

template <typename T0>
struct iftb<T0> : public std::true_type
 { };

template <typename T0, typename T1, typename ... Ts>
struct iftb<T0, T1, Ts...>
   : public std::integral_constant<bool,
        (sizeof(T1) <= sizeof(T0)) && iftb<T0, Ts...>::value>
 { };

现在是一个类型特征，用于了解类型容器是否包含有序类型列表

// ifctb = is first contained type bigger ?
template <typename>
struct ifctb;

template <template <typename ...> class C, typename ... Tc>
struct ifctb<C<Tc...>> : public iftb<Tc...>
 { };

现在类型订购者很容易写（但不是特别有效;对不起）

// to = type orderer
template <typename, typename Cd, bool = ifctb<Cd>::value>
struct to;

template <template <typename...> class C, typename ... To,
          typename T0, typename ... Tu>
struct to<C<To...>, C<T0, Tu...>, true> : public to<C<To..., T0>, C<Tu...>>
 { };

template <template <typename...> class C, typename ... To,
          typename T0, typename ... Tu>
struct to<C<To...>, C<T0, Tu...>, false> : public to<C<To...>, C<Tu..., T0>>
 { };

template <template <typename...> class C, typename ... To, typename T>
struct to<C<To...>, C<T>, true>
 { using type = C<To..., T>; };

现在我提出一个索引包装器，必须通过部分特化来定义，以定义first，second和third（等等，如果你想扩展解决方案）

template <std::size_t, typename>
struct wrapper;

template <typename T>
struct wrapper<0U, T>
 { T first; };

template <typename T>
struct wrapper<1U, T>
 { T second; };

template <typename T>
struct wrapper<2U, T>
 { T third; };

我们需要仅从C ++ 14开始提供的std::index_sequence和std::make_index_sequence;但OP必须在兼容C ++ 11的编译器中编译此代码，因此我提出了一个简单的仿真C ++ 11兼容

// std::index_sequence and std::make_index_sequence simplified emulators
template <std::size_t...>
struct indexSequence
 { using type = indexSequence; };

template <typename, typename>
struct concatSequences;

template <std::size_t... S1, std::size_t... S2>
struct concatSequences<indexSequence<S1...>, indexSequence<S2...>>
   : public indexSequence<S1..., ( sizeof...(S1) + S2 )...>
 { };

template <std::size_t N>
struct makeIndexSequenceH
   : public concatSequences<
               typename makeIndexSequenceH<(N>>1)>::type,
               typename makeIndexSequenceH<N-(N>>1)>::type>::type
 { };

template<>
struct makeIndexSequenceH<0> : public indexSequence<>
 { };

template<>
struct makeIndexSequenceH<1> : public indexSequence<0>
 { };

template <std::size_t N>
using makeIndexSequence = typename makeIndexSequenceH<N>::type;

借助std::tuple， std::index_sequence和std::make_index_sequence indexSequence和makeIndexSequence（符合C ++ 11标准的简化仿真） std::index_sequence和std::make_index_sequence），我为struct

添加了一对助手Alignement 
template <typename>
struct AlH2;

template <typename ... Ts>
struct AlH2<std::tuple<Ts...>> : public Ts...
 { };

template <typename...>
struct AlH1;

template <std::size_t ... Is, typename ... Ts>
struct AlH1<indexSequence<Is...>, Ts...>
   : public AlH2<typename to<std::tuple<>,
                             std::tuple<wrapper<Is, Ts>...>>::type>
 { };

现在Alignement可以写成

template <typename ... Ts>
struct Alignement
  : public AlH1<makeIndexSequence<sizeof...(Ts)>, Ts...>
 { };

以下是一个完整的（我记得：C ++ 17） C ++ 11编译示例，其中包含一些assert()来验证正确的排序。

#include <tuple>
#include <cassert>
#include <iostream>
#include <type_traits>

// std::index_sequence and std::make_index_sequence simplified emulators
template <std::size_t...>
struct indexSequence
 { using type = indexSequence; };

template <typename, typename>
struct concatSequences;

template <std::size_t... S1, std::size_t... S2>
struct concatSequences<indexSequence<S1...>, indexSequence<S2...>>
   : public indexSequence<S1..., ( sizeof...(S1) + S2 )...>
 { };

template <std::size_t N>
struct makeIndexSequenceH
   : public concatSequences<
               typename makeIndexSequenceH<(N>>1)>::type,
               typename makeIndexSequenceH<N-(N>>1)>::type>::type
 { };

template<>
struct makeIndexSequenceH<0> : public indexSequence<>
 { };

template<>
struct makeIndexSequenceH<1> : public indexSequence<0>
 { };

template <std::size_t N>
using makeIndexSequence = typename makeIndexSequenceH<N>::type;

// iftb = is first type bigger ?

// original C++17 version
//
// template <typename T0, typename ... Ts>
// struct iftb
//    : public std::integral_constant<bool,((sizeof(Ts) <= sizeof(T0)) && ...)>
//  { };

template <typename ...>
struct iftb;

template <typename T0>
struct iftb<T0> : public std::true_type
 { };

template <typename T0, typename T1, typename ... Ts>
struct iftb<T0, T1, Ts...>
   : public std::integral_constant<bool,
        (sizeof(T1) <= sizeof(T0)) && iftb<T0, Ts...>::value>
 { };

// ifctb = is first contained type bigger ?
template <typename>
struct ifctb;

template <template <typename ...> class C, typename ... Tc>
struct ifctb<C<Tc...>>
   : public iftb<Tc...>
 { };

// to = type orderer
template <typename, typename Cd, bool = ifctb<Cd>::value>
struct to;

template <template <typename...> class C, typename ... To,
          typename T0, typename ... Tu>
struct to<C<To...>, C<T0, Tu...>, true> : public to<C<To..., T0>, C<Tu...>>
 { };

template <template <typename...> class C, typename ... To,
          typename T0, typename ... Tu>
struct to<C<To...>, C<T0, Tu...>, false> : public to<C<To...>, C<Tu..., T0>>
 { };

template <template <typename...> class C, typename ... To, typename T>
struct to<C<To...>, C<T>, true>
 { using type = C<To..., T>; };

template <std::size_t, typename>
struct wrapper;

template <typename T>
struct wrapper<0U, T>
 { T first; };

template <typename T>
struct wrapper<1U, T>
 { T second; };

template <typename T>
struct wrapper<2U, T>
 { T third; };

template <typename>
struct AlH2;

template <typename ... Ts>
struct AlH2<std::tuple<Ts...>> : public Ts...
 { };

template <typename...>
struct AlH1;

template <std::size_t ... Is, typename ... Ts>
struct AlH1<indexSequence<Is...>, Ts...>
   : public AlH2<typename to<std::tuple<>,
                             std::tuple<wrapper<Is, Ts>...>>::type>
 { };

template <typename ... Ts>
struct Alignement
  : public AlH1<makeIndexSequence<sizeof...(Ts)>, Ts...>
 { };


int main ()
 {
   Alignement<char, int, long long>  a0;

   a0.first  = '0';
   a0.second = 1;
   a0.third  = 2LL;

   assert( (std::size_t)&a0.third < (std::size_t)&a0.first );
   assert( (std::size_t)&a0.third < (std::size_t)&a0.second );
   assert( (std::size_t)&a0.second < (std::size_t)&a0.first );
 }

- 编辑 -

OP问

  

使用你的解决方案，如果我想实现N-argument模板类，我需要定义N个包装类，每个类包含第n个参数的单个字段名。不同的Alignement＆lt;＆gt;应该具有不同的字段名称==每个包装的N个包装器。宏（或模板......）有什么好主意可以实现吗？

对我来说，C风格的宏是邪恶的（我不太了解它们），但是......

我建议不是一个完整的解决方案;只有草稿。

如果您定义以下一组宏

#define WrpNum(wName, num, fName) \
   template <typename T>\
   struct wrapper_ ## wName <num, T> \
    { T fName; };

#define Foo_1(wName, tot, fName) \
   WrpNum(wName, tot-1U, fName)

#define Foo_2(wName, tot, fName, ...) \
   WrpNum(wName, tot-2U, fName) \
   Foo_1(wName, tot, __VA_ARGS__)

#define Foo_3(wName, tot, fName, ...) \
   WrpNum(wName, tot-3U, fName) \
   Foo_2(wName, tot, __VA_ARGS__)

// Foo_4(), Foo_5(), ...

#define Foo(wName, num, ...) \
   template <std::size_t, typename> \
   struct wrapper_ ## wName; \
   Foo_ ## num(wName, num, __VA_ARGS__)

您可以定义带有专业化的struct wrapper_wrp1索引模板以及first专精中的wrapper_wrp1<0U, T>成员，second成员wrapper_wrp1<1U, T>成员等等，打电话

Foo(wrp1, 3, first, second, third)

注意您需要专业总数作为第二个参数。

也许有可能做得更好（使用递归可变参数宏？）但是，坦率地说，我对宏没有太多兴趣。

给出这个电话

Foo(wrp1, 3, first, second, third)

你可以（警告：未经测试）修改AlH1特定的包装结构（wrapper_wrp1）

template <std::size_t ... Is, typename ... Ts>
struct AlH1<std::index_sequence<Is...>, Ts...>
   : public AlH2<typename to<std::tuple<>,
                             std::tuple<wrapper_wrp1<Is, Ts>...>>::type>
 { };

答案 2 :(得分：1)

对于三人案例（或任何其他固定号码），您可以使用排序网络来有效减少专业化数量（充其量，log ^ 2n交换AFAIR）;在C ++ 11中，类似（未经测试）：

template <typename T,std::size_t> struct MemberSpec: std::alignment_of<T> {};

struct NoMember{};
template<typename, typename = NoMember> struct MemberDecl{};
template<typename T, typename B> struct MemberDecl<MemberSpec<T,0>,B>: B { T first; };
template<typename T, typename B> struct MemberDecl<MemberSpec<T,1>,B>: B { T second; };
template<typename T, typename B> struct MemberDecl<MemberSpec<T,2>,B>: B { T third; };

template<typename M0,typename M1,typename M2>
struct Alignement_01: std::conditional_t<( M0::value < M1::value ),
  MemberDecl<M0,MemberDecl<M1,MemberDecl<M2>>>, MemberDecl<M1,MemberDecl<M0,MemberDecl<M2>>> >{};

template<typename M0,typename M1,typename M2>
struct Alignement_02: std::conditional_t<( M0::value < M2::value ),
  Alignement_01<M0,M1,M2>, Alignement_01<M2,M1,M0> >{};

template<typename M0,typename M1,typename M2>
struct Alignement_12: std::conditional_t<( M1::value < M2::value ),
  Alignement_02<M0,M1,M2>, Alignement_02<M0,M2,M1> >{};

template<typename T0,typename T1,typename T2>
struct Alignement: Alignement_12<MemberSpec<T0,0>,MemberSpec<T1,1>,MemberSpec<T2,2>> {};
上面的

，每当Alignment<T0,T1,T2>时，结果Tj是自C ++ 14以来的标准布局（以及C ++ 17以来的聚合）。这意味着您需要放置断言以检查前C ++ 14中的正确字段排序和总大小。

编辑：我忘记了，即使在＆gt; = C ++ 14中，基类最多也可以有非静态数据成员;所以，我的Alignment<>几乎从不标准布局;无论如何，任何体面的编译器都应该按照预期的方式放置字段，如果适合的话，应该更好。考虑到您的目标是帮助编译器生成更优化的布局，这可能是可以接受的。

通过实现排序算法，或者将上述内容概括为一些排序网络抽象，可以类似地解决一般情况;无论如何，你仍然需要专门化MemberDecl这样的东西来让你的数据成员命名正确（第一，第二，第三，第四，...... 无论如何）。

相关问题
最新问题