正确对齐内存模板，参数顺序不变
Properly align in-memory template, invariant of order of parameters
看看这个模板。
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 个参数的解决方案(3！ 可能的排序)，但通用解决方案(包括可变长度模板)会很有趣。
我提出了一个通用解决方案：一个可变参数类型的分拣机和一个使用它的可变参数Alignement。
按照 Peter 的建议，这个想法是对类型进行排序，将较大的类型放在首位。
我使用 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_sequenceindexSequence和makeIndexSequence(C++11兼容的std::index_sequence和std::make_index_sequence简化仿真)的帮助下，我为Alignement添加了一些辅助struct
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 参数模板类，我需要定义 N 个包装类，每个包装类包含第 n 个参数的单个字段名称。不同的对齐<>应该有不同的字段名称 == 每个包装器的 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__)
您可以定义具有专用化的模板索引structwrapper_wrp1，并在wrapper_wrp1<0U, T>专用化中定义first成员，在wrapper_wrp1<1U, T>中定义second成员等，调用
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>
{ };
#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;
}
编辑：添加了一个 Order<> 模板来递归检查任意数量参数的大小顺序，并扩展了 Aligenment 以容纳 3 个变量。
EDIT2：使用相同大小的类型时，模板推断失败，因此我更改了SizeOrder template以采用DeclarationOrder模板，以消除具有 2 个可能订单的歧义，例如Alignement<int, int, double>
通过对 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 = void之前添加template D.然后我们#define DO DeclarationOrder<D,4>并#define Dname fourth.
然后，我们向MAKE_SPECIALIZATION宏添加一个D和FOURTH，并定义所有(16？)可能的布局。
远非吱吱作响的干净，但可行。
对于三成员的情况(或任何其他固定数量)，您可以使用排序网络来有效地减少专业化的数量(充其量，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>是自 C++14 以来的标准布局(以及自 C++17 以来的聚合)，无论何时Tj。这意味着您需要放置断言来检查 C++14 之前的正确字段顺序和总大小。
编辑：我忘记了，即使在>=C++14中，基类最多可以有非静态数据成员;所以，我的Alignment<>几乎从来都不是标准布局;无论如何，任何像样的编译器都应该以预期的方式放置字段，或者如果适合的话更好。考虑到您的目标是帮助编译器生成更优化的布局，这可能是可以接受的。
一般情况通过实现排序算法或概括上述内容以处理某些排序网络抽象来解决类似问题;无论如何，您仍然需要专门化MemberDecl之类的东西来获得数据成员的正确命名(第一，第二，第三，第四,...等等)。
相关文章：
- 函数调用中参数的顺序重要吗
- C++部分概念 id:显式模板规范顺序/第一个参数的特殊状态的原因是什么?
- lambda 作为接受其他参数的参数的初始化顺序
- 如何实现对参数顺序不可知的std::same_as的广义形式(即对于两个以上的类型参数）
- 约束模板参数顺序的更简单方法
- 正确对齐内存模板，参数顺序不变
- 具有不同参数顺序的聚合初始化
- glDrawArrays的意外行为-参数顺序错误会产生所需的图像
- 函数的参数顺序
- 推导的模板参数顺序
- 对"pthread_key_create"的未定义引用;参数顺序不能解决问题
- 参数顺序评估
- Printf参数顺序被忽略
- 通过交换参数顺序来重载函数
- 可变模板参数顺序，必须总是最右边的参数
- 如何反转可变参数模板函数的参数顺序
- Lua元事件参数顺序
- 'stringstream'参数顺序问题
- 宏参数顺序很重要
- sequence before:不同函数的参数顺序
