Print a struct with a known size - c++

Question

I have some structs that may contain some certain number of unsigned integer (They are either uint32_t or uint64_t). I want to print out the value of these struct in an understandable way.
For example I may have a struct like below.
struct test {
uint32_t ab = 0;
uint64_t cd = 1;
uint32_t ef = 2;
};
I think I could have a method pass the address of this struct and print it out by using the size of this struct. But not sure how to write the code.

Answer 1

As mentioned, C++11 has no reflection mechanism. The only way to obtain a list of members is to role out your own mechanism. Since you mentioned each member always has one of two types, it should be fairly straight forward. For instance, by creating a trait class.
template<class T>
struct mem_ptr {
// Tagged union type to generically refer to a member of a struct T
enum {u32, u64} alive;
union {
uint32_t T::* u32_ptr;
uint64_t T::* u64_ptr;
};
mem_ptr(uint32_t T::* u32_ptr) : alive(u32), u32_ptr(u32_ptr) {}
mem_ptr(uint64_t T::* u64_ptr) : alive(u64), u64_ptr(u64_ptr) {}
};
template<class> struct struct_members;
template<>
struct struct_members<test> {
mem_ptr<test> members[3] = {
&test::ab, &test::cd, &test::ef
};
};
template<class T>
auto operator<<(std::ostream& os, T const& str) -> decltype(struct_members<T>::members, os) {
struct_members<T> const mem;
char const *delim = "";
os << "{ ";
for(auto& m : mem.members) {
os << delim;
delim = ", ";
switch(m.alive) {
case m.u32: os << (str.*(m.u32_ptr)); break;
case m.u64: os << (str.*(m.u64_ptr)); break;
default: break;
}
}
os << " }";
return os;
}
Putting the above to the test (pun intended) on wandbox, prints:
{ 0, 1, 2 }
With that in-place, you can add support for a new structure by just defining the struct_members table for it:
struct test2 {
uint32_t ab1 = 5;
uint64_t cd2 = 3;
uint32_t ef3 = 8;
};
template<>
struct struct_members<test2> {
mem_ptr<test2> members[3] = {
&test2::ab1, &test2::cd2, &test2::ef3
};
};
And the stream operator previously written will work for it too.

Answer 2

If you need just a basic understanding about what is inside, you may reinterpret the structure as an array of uint32_t-s and print them in hex.
#include <iostream>
#include <iomanip>
struct test {
uint32_t ab = 0;
uint64_t cd = 1;
uint32_t ef = 2;
};
// For those who don't respect strict aliasing rules mentioned in comments
/*
template<class T>
void printStruct(const T& s)
{
auto* b = reinterpret_cast<const uint32_t*>(&s);
auto* e = b + sizeof(T)/sizeof(uint32_t);
std::cout << std::hex;
for (auto* i = b; i != e; ++i)
std::cout << std::setw(sizeof(uint32_t)*2) << std::setfill('0') << *i << ' ';
std::cout << std::dec;
}
*/
// For those who do respect strict aliasing rules mentioned in comments
template<class T>
void printStruct(const T& s)
{
const auto sc = sizeof(char);
const auto n = sizeof(uint32_t)/sc;
auto* b = reinterpret_cast<const unsigned char*>(&s);
auto* e = b + sizeof(T)/(sc*n);
std::cout << std::hex;
for (auto* i = b; i != e; i += n)
{
for (auto j = 0; j < n; ++j)
// For a big-endian machine n - 1 - j must be replaced by j
std::cout << std::setw(sc*2) << std::setfill('0') << *(i + n - 1 - j);
std::cout << ' ';
}
std::cout << std::dec;
}
int main()
{
printStruct(test());
return 0;
}
But the routine will print also alignment bytes and on a little-endian machine the two parts of an uint64_t will be reversed.
E.g. on my machine it prints
00000000 00000000 00000001 00000000 00000002 00007ffe
Where the first 00000000 is ab, the second 00000000 is alignment, 00000001 00000000 is cd, 00000002 is de and 00007ffe is alignment again.

Answer 3

One option would be to use std::tuple for your structures. e.g. your struct could be defined as:
typedef std::tuple< uint32_t, uint64_t, uint32_t > test;
You can then print any tuple using:
template<class Tuple, std::size_t N>
struct TuplePrinter {
static void print(const Tuple& t)
{
TuplePrinter<Tuple, N - 1>::print(t);
std::cout << ", " << std::get<N - 1>(t);
}
};
template<class Tuple>
struct TuplePrinter<Tuple, 1> {
static void print(const Tuple& t)
{
std::cout << std::get<0>(t);
}
};
template<class... Args>
void print(const std::tuple<Args...>& t)
{
std::cout << "(";
TuplePrinter<decltype(t), sizeof...(Args)>::print(t);
std::cout << ")\n";
}
If you want to get back your named members you could derive a struct from your tuple, something like this:
struct test : public std::tuple< uint32_t, uint64_t, uint32_t >
{
typedef std::tuple< uint32_t, uint64_t, uint32_t > base;
test()
: base( 0, 1, 2 ),
ab( std::get< 0 >( *this ) ),
cd( std::get< 1 >( *this ) ),
ef( std::get< 2 >( *this ) )
{
}
uint32_t& ab;
uint64_t& cd;
uint32_t& ef;
};
or alternatively:
template<typename T>
void print(const T& t)
{
print(t.tuple);
}
struct test
{
uint32_t ab = 0;
uint64_t cd = 1;
uint32_t ef = 2;
typedef std::tuple< uint32_t&, uint64_t&, uint32_t& > tuple_t;
const tuple_t tuple = { ab, cd, ef };
};
or (as suggested by #Jarod42):
void print(const test& t)
{
print(std::tie(t.ab, t.cd, t.ef));
}