Why would elements in a union be unaligned - c++

Question

I've spent a couple hours trying to make sense of the results of a quick mockup I made for an application I am working on. Here is what I am trying to do. I have an incoming message, which among other things has a 512 bit field which can have multiple forms depending on its type and needs to be translated to usable data. The first type results in the 4 x 32-bit words originating from the little endian LSB
|31 0|
|-------------word1--------------|
|-------------word2--------------|
|-------------word3--------------|
|-------------word4--------------|
|-------------unused-------------|
...
|-------------unused-------------|
512
The second is significantly larger and has 4 x 128 bit words but still occupies the same overall space
|31 0|
|-------------word1--------------|
|----------word1 cont.-----------|
|----------word1 cont.-----------|
|----------word1 cont.-----------|
|-------------word2--------------|
|----------word2 cont.-----------|
|----------word2 cont.-----------|
|----------word2 cont.-----------|
|-------------word3--------------|
|----------word3 cont.-----------|
|----------word3 cont.-----------|
|----------word1 cont.-----------|
|-------------word4--------------|
|----------word4 cont.-----------|
|----------word4 cont.-----------|
|----------word4 cont.-----------|
I am attempting to make a class that processes this into 4 accessible void* fields, regardless of if they are type 1 and convertible to a unsigned integer or 128 bit of void data. Here is the code.
The first header is just common structures. I attempted to minimize bit shifting by using unions.
// Common.hpp
#ifndef COMMON_HPP
#define COMMON_HPP
#include <cstdint>
#include <cstddef>
enum WaveFormType
{
TYPE1,
TYPE2
};
enum CommandWordEnum
{
COMMAND1,
COMMAND2,
COMMAND3,
COMMAND4
};
// 384 + 32 + 32 + 32 + 32 = 512 bits
struct Type1CommandWord
{
uint32_t unused[12];
uint32_t word[4];
};
// 128 + 128 + 128 + 128 = 512 bits
struct Type2CommandWord
{
uint32_t word1[4];
uint32_t word2[4];
uint32_t word3[4];
uint32_t word4[4];
};
union CommandWordData
{
uint8_t buffer[64];
Type1CommandWord type1CommandWord;
Type2CommandWord type2CommandWord;
};
#endif /* COMMON_HPP */
The second class is a mockup of the incoming message. In reality it is a very large message, but at the moment, these fields are the ones I am concerned about.
// Message.hpp
#ifndef MESSAGE_HPP
#define MESSAGE_HPP
#include <cstdint>
#include "Common.hpp"
//Test Message
struct Message
{
uint8_t data[64];
WaveFormType waveFormType;
};
#endif /* MESSAGE_HPP */
The next class is the actual receiver class
// CommandReceiver.hpp
#ifndef COMMAND_RECEIVER_HPP
#define COMMAND_RECEIVER_HPP
#include "Common.hpp"
#include "Message.hpp"
#include <cstdlib>
class CommandReceiver
{
public:
CommandReceiver(Message &_message);
virtual ~CommandReceiver() = default;
WaveFormType getWaveFormType() const;
size_t getCommandWordSize() const;
void *getCommandWord(CommandWordEnum cmdWordEnum) const;
private:
CommandWordData commandWordData;
WaveFormType waveFormType;
};
#endif /* COMMAND_RECEIVER_HPP */
and the definition
// CommandReceiver.cpp
#include "CommandReceiver.hpp"
#include <string.h>
CommandReceiver::CommandReceiver(Message &_message)
: waveFormType(_message.waveFormType)
{
memset(
this->commandWordData.buffer,
0,
sizeof(commandWordData.buffer));
memcpy(
this->commandWordData.buffer,
&_message.data,
sizeof(this->commandWordData.buffer));
}
WaveFormType CommandReceiver::getWaveFormType() const
{
return waveFormType;
}
size_t CommandReceiver::getCommandWordSize() const
{
return((waveFormType == TYPE2)
? sizeof(this->commandWordData.type2CommandWord.word1)
: sizeof(this->commandWordData.type1CommandWord.word[1]));
}
void *CommandReceiver::getCommandWord(CommandWordEnum cmdWordEnum) const
{
void * cmdPtr = (void*)malloc(this->getCommandWordSize());
switch(cmdWordEnum)
{
case COMMAND1:
if(this->waveFormType == TYPE2)
{
memcpy(
cmdPtr,
this->commandWordData.type2CommandWord.word2,
this->getCommandWordSize());
}
else
{
memcpy(
cmdPtr,
&this->commandWordData.type1CommandWord.word[1],
this->getCommandWordSize());
}
break;
case COMMAND2:
if(this->waveFormType == TYPE2)
{
memcpy(
cmdPtr,
&this->commandWordData.type2CommandWord.word2,
this->getCommandWordSize());
}
else
{
memcpy(
cmdPtr,
&this->commandWordData.type1CommandWord.word[2],
this->getCommandWordSize());
}
break;
case COMMAND3:
if(this->waveFormType == TYPE2)
{
memcpy(
cmdPtr,
&this->commandWordData.type2CommandWord.word3,
this->getCommandWordSize());
}
else
{
memcpy(
cmdPtr,
&this->commandWordData.type1CommandWord.word[3],
this->getCommandWordSize());
}
break;
case COMMAND4:
if(this->waveFormType == TYPE2)
{
memcpy(
cmdPtr,
&this->commandWordData.type2CommandWord.word4,
this->getCommandWordSize());
}
else
{
memcpy(
cmdPtr,
&this->commandWordData.type1CommandWord.word[4],
this->getCommandWordSize());
}
break;
default:
// memcpy(
// cmdPtr,
// nullptr,
// this->getCommandWordSize());
break;
}
return cmdPtr;
}
finally the main file which I made a few simple tests.
What I am confused about is why a cannot get addresses to
align. See below.
#include "CommandReceiver.hpp"
#include <iostream>
#include <cstring>
#include <cassert>
//test
int main()
{
// Confirm substructures are the correct size
assert(sizeof(Type1CommandWord) == 512 / 8);
assert(sizeof(Type2CommandWord) == 512 / 8);
// Set up tests
Message msg;
memset(&msg.data, 0, sizeof(msg.data));
msg.data[60] = 0xDE;
msg.data[61] = 0xAD;
msg.data[62] = 0xC0;
msg.data[63] = 0xDE;
msg.waveFormType = TYPE1;
// Call the constructor
CommandReceiver cmdRec(msg);
// Confirm values copied in constructor match
assert(cmdRec.commandWordData.buffer[60] == 0xDE);
assert(cmdRec.commandWordData.buffer[61] == 0xAD);
assert(cmdRec.commandWordData.buffer[62] == 0xC0);
assert(cmdRec.commandWordData.buffer[63] == 0xDE);
std::cout << "0x"<< &cmdRec.commandWordData.buffer + 60 << "\n";
std::cout << "0x"<< &cmdRec.commandWordData.buffer + 61 << "\n";
std::cout << "0x"<< &cmdRec.commandWordData.type1CommandWord + (32 * 4) << "\n";
The bottom line is it is not working and the problem is fairly early on. I just cannot figure out why. Here is the output:
0x0x7ffc3139f2e8
0x0x7ffc3139f328
0x0x7ffc313a03e8
The first two fields should be adjacent characters of an unsigned char array. so I would expect them to be 1 byte off, not 744 bytes.
The third field should be equal to the first but instead it is 1100 bytes off. I'm obviously missing something big.
What am I missing? I'd also be interested in suggestions about better ways of doing this. However, the endpoints have to remain the same.

Answer 1

With pointer arithmetic, type of pointer does count:
int* p = /*..*/;
char* c = reinterpret_cast<char*>(p);
int n = /*..*/;
assert(reinterpret_cast<char*>(p + n) == c + n * sizeof(int));
// ^^^^^^^^^^^^^
So in your case
&cmdRec.commandWordData.type1CommandWord + (32 * 4)
"is"
reinterpret_cast<Type1CommandWord*>(
reinterpret_cast<const char*>(
&cmdRec.commandWordData.type1CommandWord
) + (32 * 4) * sizeof(Type1CommandWord)
)
and
&cmdRec.commandWordData.buffer + 60 is not &cmdRec.commandWordData.buffer[60] but
reinterpret_cast<uint8_t(*)[64]>(reinterpret_cast<char*>(&cmdRec.commandWordData.buffer) + 60 * sizeof(uint8_t[64]))