How are nested structures nested with different alignments in memory?

Question

I am a C # developer, I am writing a client for a server written in C ++. The server transmits some data over TCP / IP to the client, and we must collect it at the other end. The server sends us first a description of the data, then the data itself.

Problem structure:

struct Inner_S { double a; double b[4][4]; }; #pragma pack(1) struct Packed_S { uint8_t c; Inner_S d; }; 

The server tells the client that the external structure has alignment 1 and the internal structure has alignment 8. The protocol specification says:

Field matching in the stream structure is performed in accordance with the 64-bit specification of the Itanium application's C ++ binary interface interface (i.e., similar to the typical GNU compiler on a typical 64-bit platform).

I found the specification of the binary interface of an application based on a 64-bit C ++ processor . I think the part I'm looking for is "Distribution of members other than virtual databases", but I'm lost there.

On the C # side, I read the data stream and pack my own class with the values ​​extracted from the structure. I need to know exactly where in the stream to look for each element of the structure.

I am currently processing the structure in a way that does not match my users:

(start structure with alignment 1) (no need to fill) (read simple value) c (start internal structure with alignment 8) (add padding to alignment 8) 0000000 (read field) aaaaaaaa (start of array) (read simple value) BBBBBBBB .....

This method is supported by at least one site.

So, when I parse this data, how do I handle alignment in Inner_S ?

caaaaaaaabbbbbbbbb .... (i think?) caaaaaaaa0000000bbbbbbbbb .... (looks wrong)

Answer 1

As suggested by @Cameron, I tried this with offsetof , as this applies to POD types.

 #include <iostream> #include <cstddef> #include <cstdint> using namespace std; struct Inner_S { double a; double b[4][4]; }; #pragma pack(1) struct Packed_S { uint8_t c; Inner_S d; }; int main() { cout << "Size: " << sizeof(Packed_S) << endl; cout << "c offset: " << offsetof(Packed_S, c) << endl; cout << "d offset: " << offsetof(Packed_S, d) << endl; cout << "a offset: " << offsetof(Packed_S, da) << endl; cout << "b offset: " << offsetof(Packed_S, db) << endl; return 0; } 

Exit

 Size: 137 c offset: 0 d offset: 1 a offset: 1 b offset: 9 

Thus, using your notation, the structure is packaged as caaaaaaaabbbbbbbb.... Note that if you select the #pragma pack(1) directive, the compiler will add 3 bytes of padding after c .

See here