【发布时间】：2013-09-29 06:52:51
【问题描述】：
我想知道一种使类的内存布局在模板化代码中更有效的可能方法。据我所知，标准要求类的数据成员按照声明的顺序排列在内存中。编译器可能会进行填充以对齐数据成员，从而不必要地增加类的大小。这个想法是在编译时重新排列数据成员声明以最小化这种填充。我做了一些搜索，但找不到任何信息（大多数时候人们讨论打包编译器指令，这与我看到的不太一样）。
首先，请考虑以下（琐碎，但重复且丑陋）代码（same code on ideone.com）（问题在代码下方，请随意直接跳到它们）：
#include <iostream>
#include <cstdint>
namespace so
{
template <typename Ta, typename Tb, typename Tc, std::size_t =
((sizeof(Ta) >= sizeof(Tb)) && (sizeof(Tb) >= sizeof(Tc))) ? 10 :
((sizeof(Ta) >= sizeof(Tc)) && (sizeof(Tc) >= sizeof(Tb))) ? 11 :
((sizeof(Tb) >= sizeof(Ta)) && (sizeof(Ta) >= sizeof(Tc))) ? 20 :
((sizeof(Tb) >= sizeof(Tc)) && (sizeof(Tc) >= sizeof(Ta))) ? 21 :
((sizeof(Tc) >= sizeof(Ta)) && (sizeof(Ta) >= sizeof(Tb))) ? 30 :
((sizeof(Tc) >= sizeof(Tb)) && (sizeof(Tb) >= sizeof(Ta))) ? 31 : 0>
struct foo {};
template <typename Ta, typename Tb, typename Tc>
struct foo<Ta, Tb, Tc, 10>
{
Ta a;
Tb b;
Tc c;
foo(Ta _a, Tb _b, Tc _c) : a{_a}, b{_b}, c{_c} {}
};
template <typename Ta, typename Tb, typename Tc>
struct foo<Ta, Tb, Tc, 11>
{
Ta a;
Tc c;
Tb b;
foo(Ta _a, Tb _b, Tc _c) : a{_a}, c{_c}, b{_b} {}
};
template <typename Ta, typename Tb, typename Tc>
struct foo<Ta, Tb, Tc, 20>
{
Tb b;
Ta a;
Tc c;
foo(Ta _a, Tb _b, Tc _c) : b{_b}, a{_a}, c{_c} {}
};
template <typename Ta, typename Tb, typename Tc>
struct foo<Ta, Tb, Tc, 21>
{
Tb b;
Tc c;
Ta a;
foo(Ta _a, Tb _b, Tc _c) : b{_b}, c{_c}, a{_a} {}
};
template <typename Ta, typename Tb, typename Tc>
struct foo<Ta, Tb, Tc, 30>
{
Tc c;
Ta a;
Tb b;
foo(Ta _a, Tb _b, Tc _c) : c{_c}, a{_a}, b{_b} {}
};
template <typename Ta, typename Tb, typename Tc>
struct foo<Ta, Tb, Tc, 31>
{
Tc c;
Tb b;
Ta a;
foo(Ta _a, Tb _b, Tc _c) : c{_c}, b{_b}, a{_a} {}
};
template <typename Ta, typename Tb, typename Tc>
struct bar: public foo<Ta, Tb, Tc>
{
private:
using base = foo<Ta, Tb, Tc>;
public:
bar() = default;
using base::base;
};
template <typename Ta, typename Tb, typename Tc>
struct foobar
{
Ta a;
Tb b;
Tc c;
foobar() = default;
foobar(Ta _a, Tb _b, Tc _c) : a{_a}, b{_b}, c{_c} {}
};
} //namespace so
int main()
{
so::bar<std::uint16_t, std::uint32_t, std::uint16_t> bar{1, 2, 3};
so::foobar<std::uint16_t, std::uint32_t, std::uint16_t> foobar{1, 2, 3};
std::cout << sizeof(bar) << "\t" << sizeof(foobar) << std::endl;
std::cout << bar.a << " : " << bar.b << " : " << bar.c << std::endl;
std::cout << foobar.a << " : " << foobar.b << " : " << foobar.c << std::endl;
return (0);
}
程序输出：
8 12
1 : 2 : 3
1 : 2 : 3
问题：
- 是否有一些众所周知的、独立于编译器的方法来解决此类问题（也许是 Boost）？
- 如果没有，是否有一些特定于编译器的指令会自动执行此类操作（不会像 GCC 的
__atribute__((packed))那样发生数据错位）？ - 能否以更通用的方式完成（可能使用可变参数模板）？
提前致谢！
【问题讨论】：
-
提示：我相信你可以通过使用继承来解决重复问题，这为可变参数模板打开了大门，但是这将严重依赖编译器并且代码可能没有那么优雅（又名，你将不得不使用函数来访问元素，例如
get<0>(foo))。我还要注意，在某些架构double上，您只查看大小而不是对齐方式，长度为 8 个字节，但在 4 个字节边界上对齐，因此您的计算可能不是最佳的。 -
@MatthieuM。当我们展开参数包并使用某种
get<>来浏览它时，您的意思是某种递归继承吗？对齐可以处理alignof()/std::alignment_of<>，我想 - 感谢您指出这一点。 -
实际上，我的主要问题是不幸的是你不能在属性中使用包扩展（烦人），并且有多种方法可以处理它......然后我意识到我在检查时已经审查了这些方法
std::tuple是如何实现的，而不是尝试使用继承技巧重新实现它们，我可以简单地重用std::tuple：D
标签： c++ class templates datamember memory-layout