Is there any portable way to ensure a struct is defined without padding bytes using c++11?

Question

Lets consider the following task: My C++ module as part of an embedded system receives 8 bytes of data, like: uint8_t data[8]. The value of the first byte determines the layout of the rest (20-30 different). In order to get the data effectively, I would create different structs for each layout and put each to a union and read the data directly from the address of my input through a pointer like this:

struct Interpretation_1 {
    uint8_t multiplexer;
    uint8_t timestamp;
    uint32_t position;
    uint16_t speed;
};
// and a lot of other struct like this (with bitfields, etc..., layout is not defined by me :( )

union DataInterpreter {
    Interpretation_1 movement;
    //Interpretation_2 temperatures;
    //etc...
};

...
uint8_t exampleData[8] {1u, 10u, 20u,0u,0u,0u, 5u,0u};
DataInterpreter* interpreter = reinterpret_cast<DataInterpreter*>(&exampleData);
std::cout << "position: " << +interpreter->movement.position << "\n";

The problem I have is, the compiler can insert padding bytes to the interpretation structs and this kills my idea. I know I can use

• with gcc: struct MyStruct{} __attribute__((__packed__));
• with MSVC: I can use #pragma pack(push, 1) MyStruct{}; #pragma pack(pop)
• with clang: ? (I could check it)

But is there any portable way to achieve this? I know c++11 has e.g. alignas for alignment control, but can I use it for this? I have to use c++11 but I would be just interested if there is a better solution with later version of c++.

Answer 1

But is there any portable way to achieve this?

No, there is no (standard) way to "make" a type that would have padding to not have padding in C++. All objects are aligned at least as much as their type requires and if that alignment doesn't match with the previous sub objects, then there will be padding and that is unavoidable.

Furthermore, there is another problem: You're accessing through a reinterpreted pointed that doesn't point to an object of compatible type. The behaviour of the program is undefined.

We can conclude that classes are not generally useful for representing arbitrary binary data. The packed structures are non-standard, and they also aren't compatible across different systems with different representations for integers (byte endianness).

---

There is a way to check whether a type contains padding: Compare the size of the sub objects to the size of the complete object, and do this recursively to each member. If the sizes don't match, then there is padding. This is quite tricky however because C++ has minimal reflection capabilities, so you need to resort either hard coding or meta programming.

Given such check, you can make the compilation fail on systems where the assumption doesn't hold.

Another handy tool is std::has_unique_object_representations (since C++17) which will always be false for all types that have padding. But note that it will also be false for types that contain floats for example. Only types that return true can be meaningfully compared for equality with std::memcmp.

Answer 2

Reading from unaligned memory is undefined behavior in C++. In other words, the compiler is allowed to assume that every uint32_t is located at a alignof(uint32_t)-byte boundary and every uint16_t is located at a alignof(uint16_t)-byte boundary. This means that if you somehow manage to pack your bytes portably, doing interpreter->movement.position will still trigger undefined behaviour.

(In practice, on most architectures, unaligned memory access will still work, but albeit incur a performance penalty.)

You could, however, write a wrapper, like how std::vector<bool>::operator[] works:

#include <cstdint>
#include <cstring>
#include <iostream>
#include <type_traits>

template <typename T>
struct unaligned_wrapper {
    static_assert(std::is_trivial<T>::value);
    std::aligned_storage_t<sizeof(T), 1> buf;
    operator T() const noexcept {
        T ret;
        memcpy(&ret, &buf, sizeof(T));
        return ret;
    }
    unaligned_wrapper& operator=(T t) noexcept {
        memcpy(&buf, &t, sizeof(T));
        return *this;
    }
};

struct Interpretation_1 {
    unaligned_wrapper<uint8_t> multiplexer;
    unaligned_wrapper<uint8_t> timestamp;
    unaligned_wrapper<uint32_t> position;
    unaligned_wrapper<uint16_t> speed;
};
// and a lot of other struct like this (with bitfields, etc..., layout is not defined by me :( )

union DataInterpreter {
    Interpretation_1 movement;
    //Interpretation_2 temperatures;
    //etc...
};

int main(){
    uint8_t exampleData[8] {1u, 10u, 20u,0u,0u,0u, 5u,0u};
    DataInterpreter* interpreter = reinterpret_cast<DataInterpreter*>(&exampleData);
    std::cout << "position: " << interpreter->movement.position << "\n";
}

This would ensure that every read or write to the unaligned integer is transformed to a bytewise memcpy, which does not have any alignment requirement. There might be a performance penalty for this on architectures with the ability to access unaligned memory quickly, but it would work on any conforming compiler.