Accessing unions in struct - c++

Question

Consider following code:
struct test1str
{
int testintstr : 2;
int testintstr2 : 1;
};
struct test2str
{
int testintstr : 2;
int testintstr2 : 1;
};
union test1uni
{
int testint1;
test1str str1;
};
union test2uni
{
int testint2;
test2str str2;
};
struct finalstruct
{
test1uni union1;
test2uni union2;
} finstr;
int* ptr = &finstr.union1.testint1;
finstr.union1.testint1 = 2;
finstr.union2.testint2 = 4;
cout << &finstr.union1 << endl;
cout << &finstr.union2 << endl;
printf("val: %i addr: %x\n", *ptr, ptr);
ptr++;
printf("val: %i addr: %x\n", *ptr, ptr);
Is there more appropriate way of accessing values from unions inside example finalstruct? Using code from above example, I could iterate throught all unions inside "finalstruct", and get int that was needed, but is there some other way to do this?
Assume that data size from all structs will be less or equal to the size of variable inside union - structs will be treated as bitfields, and data will be read through union variable.
This will be used only on one type of processor, compiled with one compiller (gcc) and sizes of all structs and unions will be the same (except of finalstruct of course). What I'm trying to achieve is to be able to change different bits easily by using struct (test1str, test2str), and for reading I need to know only what will be final value that these bits will make - for that I will use union (test1uni, test2uni). By packing these unions inside struct (finalstruct), I can easily process all data.

Answer 1

ptr++
ptr does not point to an element of an array, so after you increment it, it is no longer valid - even if there happens to be another object in that address. When you indirect through it, the behaviour of the program is undefined.
What you really need to iterate members of a class is language feature called "reflection". C++ has very limited support for reflection. You could store references to the members in an array, and iterate the array. Note that since we cannot have arrays of references, we need to wrap them, and in case of printf, explicitly convert the wrapper back:
std::array members {
std::ref(finstr.union1.testint1),
std::ref(finstr.union2.testint2),
};
auto ptr = std::begin(members);
printf("val: %i addr: %p\n", ptr->get(), (void*)&ptr->get());
ptr++;
printf("val: %i addr: %p\n", ptr->get(), (void*)&ptr->get());
P.S. I took the liberty of fixing the printf call. %x is wrong for a pointer.

Answer 2

I don't think I've quite understood what you're trying to achieve, but...
If you're sure that sizeof(test1uni) == sizeof(test2uni) == sizeof(int) and there's nothing else in the struct, then you can treat finalstruct itself as an array of ints:
int *ptr = (int*)&finstr;
for(int i=0; i<sizeof(finstr)/sizeof(int); i++)
printf("val: %i addr: %x\n", ptr[i], &ptr[i]);
But as raised in the comments, casting the struct to an int probably violates strict aliasing, and "type-punning" using the members of union is no longer explicitly allowed in C++ (as opposed to explicitly not allowed). Thus this is in the realm of undefined behaviour, so you need to either:
Disable optimisations based on strict aliasing. Eg. pass -fno-strict-aliasing to GCC 3.4.1 and above. Still have the type-punning issue though.
Check the assembly to make sure the compiler is doing what you want.
Change to C.
Also be aware of other gotchas: int has to be a multiple of a word, finstr has to be aligned to a word boundary, the compiler/platform has to follow convention. So I certainly wouldn't consider this portable without a fair bit more rigour.