垫一个 C++ 2 的幂结构

Question

我正在为嵌入式系统编写一些 C++ 代码。 代码使用的 I/O 接口要求每个消息的大小（以字节为单位）是 2 的幂。 现在，代码做了这样的事情（在几个地方）：

#pragma pack(1)
struct Message
{
   struct internal_
   {
      unsigned long member1;
      unsigned long member2;
      unsigned long member3;
      /* more members */
   } internal;
   char pad[64-sizeof(internal_)];
};
#pragma pack()

我第一次尝试在 64 位 Fedora 上编译代码，其中 long 是 64 位。 在本例中，sizeof(internal_) 大于 64，数组大小表达式下溢，编译器会抱怨数组太大。

理想情况下，我希望能够编写一个宏，该宏将获取结构的大小并在编译时评估填充数组所需的大小，以便将结构的大小舍入为 2 的幂。

我查看了 Bit Twiddling Hacks 页面，但我不知道是否其中的任何技术实际上都可以在宏中实现，以便在编译时进行评估。

这个问题还有其他解决方案吗？ 或者我应该让这个问题永久存在，只是将神奇的 64 更改为神奇的 128？

Answer 1

还有另一个模板解决方案（从 fizzer 中大量窃取)：

#include <iostream>
#include <ostream>
using namespace std;

template <int TSize, int PSize = 1, bool = false>
struct PadSize
{
  static const int val =
    ( PadSize <    TSize, (PSize*2), (TSize <= (PSize*2)  )    > :: val );
};

template < int TSize, int PSize>
struct PadSize <TSize, PSize, true>  // As soon as TSize is <= to PSize
{
  static const int val = PSize;
};

int main()
{
    typedef char Arr[8];
    char pad[ PadSize <sizeof(Arr)>::val  ];

    cout << sizeof pad << endl;
}

我的方法就是继续将填充大小加倍，直到它至少与字体大小一样大。

Answer 2

我喜欢 Niki 的回答，尤其是这一部分具有匿名结构。

答案没有解决的一件事是大于 64 字节的问题，但是可以通过有条件地声明 char[128] 结构成员来解决，如果 sizeof(long)= =8 并声明 char[64] 否则。

Answer 3

基础知识

基于 Fizzer 的答案，但具有更现代的 (C++17) 风格，以及我认为的一个更好的界面，允许您通过以下方式填充任何结构/类：

#include "padded.h"

struct UnpaddedStruct
{
    unsigned char unaligned_data[5];
};

using PaddedStruct = Padded<UnpaddedStruct>;

sizeof(UnpaddedStruct) 是 5，如预期的那样。
sizeof(PlatedStruct) 是 8，正如所希望的那样。

这里最大的区别是没有特殊的数据成员（除了可能的填充），也不需要以任何特定的方式编写类来添加填充。 您只需使用 Plated 结构进行对齐，然后以与不使用填充时完全相同的方式访问您的结构。

这是一个现成的文件，您应该能够将其作为标头包含在内，以允许
对于该功能：

#ifndef PADDED_H
#define PADDED_H
/**
 * padded.h - Padding to align types with powers of two.
 */
#include <cstddef>
#include <cstdint>
#include <limits>

/**
 * pad_size_of<T>() - Get the size required to align T to a power of two.
 * @tparam T: The type to get alignment values for.
 *
 * Return: The amount of padding required to align T to a power of two.
 */
template <typename T>
constexpr size_t pad_size_of()
{
    // Edge case. The highest number which is representable for any size type
    // is going to be one less than the number we want to align it to.
    const size_t max_of = std::numeric_limits<size_t>::max();
    if constexpr(sizeof(T) > max_of / 2) {
            return max_of - sizeof(T) + 1;
    }
    // We want to find the power of two that can fit AT LEAST sizeof(T).
    size_t power_of_two = 1;
    // There's definitely some better way to do this, but this is the most
    // straight forward way to do what it's supposed to do. It's a constexpr
    // function, so there should be no runtime overhead anyway.
    while (power_of_two < sizeof(T)) {
        power_of_two *= 2;
    }
    // Finally, our padding size is simply the difference between the two.
    return power_of_two - sizeof(T);
}

/**
 * struct Padded<T, Size> - A struct including padding for alignment.
 * @tparam T: The class to add padding to.
 * @tparam Size: The amount of padding to add to the class.
 *
 * Simple struct which can be inherited to add padding to any class. Will
 * default to figuring out the amount of padding required to align a class to
 * a power of two, then use that.
 */
template <typename T, size_t Size = pad_size_of<T>()>
struct Padded : public T
{
    /// Simple array of bytes large enough to align the class to powers of two.
    uint8_t padding[Size]{};
};


// Specialization of the above template for the base case, where no padding is
// required for alignment, so none is included.
template <typename T>
struct Padded<T, 0> : public T {};
#endif // PADDED_H

详细信息

对于特别感兴趣的人，让我们解释一下这里发生了什么。

首先，我知道有些人不喜欢注释/文档字符串，认为它们很吵，所以让我们从没有注释的纯代码开始：

#include <limits>

template <typename T>
constexpr size_t pad_size_of()
{
    const size_t max_of = std::numeric_limits<size_t>::max();
    if constexpr(sizeof(T) > max_of / 2) {
            return max_of - sizeof(T) + 1;
    }
    size_t power_of_two = 1;
    while (power_of_two < sizeof(T)) {
        power_of_two *= 2;
    }
    return power_of_two - sizeof(T);
}

template <typename T, size_t Size = pad_size_of<T>()>
struct Padded : public T
{
    uint8_t padding[Size]{};
};

template <typename T>
struct Padded<T, 0> : public T {};

这里的第一个“魔法”是 constexpr 函数：

template <typename T>
constexpr size_t pad_size_of()

constexpr 函数可以在编译时求值，这意味着我们可以使用它们来计算，例如类属性。 我们不必滥用结构和枚举来做任何事情，我们只需写下我们的意思即可。

编译器可能会省略 constexpr 函数调用，而是直接使用函数调用的结果，而不是在运行时调用它。 这意味着不应该有二进制膨胀或任何东西，它只是编译器可以用来计算我们需要多少填充的简单函数。

然后，我们将 Plated 结构定义为模板类：

template <typename T, size_t Size = pad_size_of<T>()>
struct Padded : public T

它需要两个模板参数，一个是要添加填充的类，另一个是要添加到其中的填充量。 默认情况下，它会在我们的 pad_size_of 函数的帮助下，根据类的大小自动计算出这一点，因此您通常不需要考虑这一点。 您可以考虑一下，例如，如果您想要对齐到sizeof(int)的倍数而不是2的幂，但在大多数情况下，2的幂应该是合理的案例。

最后，我们对 Plated 结构进行了特殊化，即：

template <typename T>
struct Padded<T, 0> : public T {};

这是另一个“神奇”位。 如果结构不需要填充，则它不会有填充。 简单如。 这允许您向底层结构添加数据成员，而不必担心更新任何填充值或其他内容。 如果不需要开销，就不会有开销。

完整示例

#include <cstdint>
#include <iostream>
#include "padded.h"

/**
 * struct UnpaddedStruct - Some arbitrary struct with no padding.
 */
struct UnpaddedStruct
{
    /// Whatever unaligned data you want.
    uint8_t data[5];
};

/**
 * struct Struct - An UnpaddedStruct with extra padding.
 */
using Struct = Padded<UnpaddedStruct>;


int main(int argc, char *argv[])
{
    Struct s{'a', 'b', 'c', '\0'};
    std::cout
            << "UNPADDED: " << sizeof(UnpaddedStruct)
            << ", PADDED: " << sizeof(Struct)
            << ", CONTENT: " << s.data
            << std::endl;
    return 0;
}

输出

UNPADDED: 5, PADDED: 8, CONTENT: abc

Answer 4

您可以使用模板获得结构大小四舍五入为 2 的幂的编译时常量：

template<int N, int C = 1>
struct Recurse
{
    enum {result = Recurse<N/2, C*2>::result};
};

template<int C>
struct Recurse<0, C>
{
    enum {result = C};
};

template<typename T>
struct Calc
{
    enum {size = Recurse<sizeof(Test)-1>::result};
};

struct Test
{
    int a;
    double b;
    double c;
};

int main()
{
    std::cout << sizeof(Test) << " -> " << Calc<Test>::size << std::endl;
    return 0;
}

这样填充值应该很容易。

Answer 5

如何在发送和接收消息函数周围编写一个小包装器来处理任何大小的消息，它们只分配一个更大的缓冲区（下一个 2 的幂）并 memclear 它，将结构复制到开头并一起发送。

Answer 6

使用模板元程序。 （根据评论进行编辑）。

#include <iostream>
#include <ostream>
using namespace std;

template <int N>
struct P
{
    enum { val = P<N/2>::val * 2 };
};

template <>
struct P<0>
{
    enum { val = 1 };
};

template <class T>
struct PadSize
{
    enum { val = P<sizeof (T) - 1>::val - sizeof (T) }; 
};

template <class T, int N>
struct PossiblyPadded
{
    T       payload;
    char    pad[N]; 
};

template <class T>
struct PossiblyPadded<T, 0>
{
    T       payload;
};

template <class T>
struct Holder : public PossiblyPadded<T, PadSize<T>::val>
{
};


int main()
{
    typedef char Arr[6];

    Holder<Arr> holder;
    cout << sizeof holder.payload << endl;

    // Next line fails to compile if sizeof (Arr) is a power of 2
    // but holder.payload always exists
    cout << sizeof holder.pad << endl;
}

Answer 7

为什么不使用工会？

union Message
{
    struct internal_
    {
        unsigned long member1;
        /* more members */
    };
    char[64];
};

或者更好的是使用匿名结构，

union Message
{
    struct
    {
        unsigned long member1;
        /* more members */
    };
    char[64];
};

这样你就可以像这样访问成员：Message.member1;

编辑：显然这并不能解决大于 64 的问题，但提供了一种更干净的填充方式。

Answer 8

也许最明显的方法是只使用三元运算符：

#define LOG2_CONST(n) ((n) <= 1 ? 0 :
                      ((n) <= 2 ? 1 :
                      ((n) <= 4 ? 2 :
                      /* ... */
                      ))))))))))))))))))))))))))))))
#define PADDED_STRUCT(ResultName, BaseName) \
  typedef union { BaseName data; char pad[1 << LOG2_CONST(sizeof(BaseName))]; } ResultName

Answer 9

您已经在使用 #pragma pack，我不知道您具体使用什么编译器，但您应该查看它们是否支持控制对齐/填充的 pack 参数，然后您可以只需完全删除填充字段即可。 我知道 MSVC 的 版本 pragma pack 支持这一点，GCC 也是如此。

Answer 10

解决该问题的一种方法是用大小（长）的倍数替换硬编码的 64，将填充变成如下所示：

char pad[4*sizeof(unsigned long) - sizeof(internal_)];

它很丑，但应该可以移植到 64 位。

也就是说，要求消息大小为 2 的幂的 API 听起来有点奇怪，就像一个设计问题。 要求大小为偶数是有道理的，因为在某些处理器上访问奇数地址上的数据要付出相当大的代价，但你的 #pragma 包几乎使这种情况不可避免。

Answer 11

union Message
{
    struct
    {
        unsigned long member1;
        unsigned long member2; //...
    };
    char pad[1 << 5]; //change 5 to whatever size you need...
};

会干净一点。

Answer 12

宏化 此（对于 32 位架构）：

#define align_step(N, shift) ((N) | ((N) >> shift))
#define align_up(N) (align_step(align_step(align_step(align_step(align_step((N)-1, 1), 2), 4), 8), 16) + 1)
#define alignment_padding(N) (align_up((N)) - (N))

您可以如下 您可以使用 union 技巧或其他方法来应用它。 在你的例子中：

#pragma pack(1)
struct Message
{
   struct internal_
   {
      unsigned long member1;
      unsigned long member2;
      unsigned long member3;
      /* more members */
   } internal;
   char pad[alignment_padding(sizeof(internal_))];
};
#pragma pack()