Why casting in C++ prints an unexpected result? - c++

Question

I know basics of casting in C++—or I thought I knew.
Yesterday, I was trying to convert an 8-element uint_8 type array to a 2-element uint_32 type array.
I cast my values to 32bit format and while trying to display them into 32bit format, the computer gives me their address not their values.. You can see where I became confused about this code from comment part.
int main()
{
uint8_t info[8];
info[0] = '2';
info[1] = '0';
info[2] = '2';
info[3] = '0';
info[4] = '0';
info[5] = '0';
info[6] = '0';
info[7] = '0';
uint32_t *divided = (uint32_t*)&info[0];
uint32_t *dividedTwo = (uint32_t*)&info[4];
std::cout << "Address of info " << &info << std::endl; //Output 0x7ffdd25cabe0 as expected.
std::cout << "Expected value of info " << (uint8_t*)info<< std::endl; //Output 20200000 as expected.
std::cout << "Expected value of divided " << (uint32_t*)divided << std::endl; //Output 0x7ffdd25cabe0 not as my expected. What is the reason?
std::cout << "But why this return the true value? " << (uint8_t*)divided << std::endl; //Output 20200000 but why 8bit returns the true value instead of 32bit casting?
std::cout << "Same here, my value was type of 32... " << (uint8_t*)dividedTwo << std::endl; //Output 0000
}

Answer 1

Many of your print statements cause undefined behaviour or don't make sense.
std::cout << "Address of info " << &info << std::endl; //Output 0x7ffdd25cabe0 as expected.
This line prints the address of your array. As you see, you get some pointer value out.
std::cout << "Expected value of info " << (uint8_t*)info<< std::endl; //Output 20200000 as expected.
This line prints the contents of your array as a C string, and causes undefined behaviour since your string is not null terminated.
std::cout << "Expected value of divided " << (uint32_t*)divided << std::endl; //Output 0x7ffdd25cabe0 not as my expected. What is the reason?
This line prints the same pointer as in #1, just with a different type.
std::cout << "But why this return the true value? " << (uint8_t*)divided << std::endl; //Output 20200000 but why 8bit returns the true value instead of 32bit casting?
Same pointer, same string as in #2. Same undefined behaviour.
std::cout << "Same here, my value was type of 32... " << (uint8_t*)dividedTwo << std::endl; //Output 0000
This line prints the second half of your string - same undefined behaviour.
What you actually mean to print is likely something along these lines (in C to take the implicit type handling of iostream out of the example):
#include <inttypes.h>
printf("%p\n", (void *)info); // address of the array
printf("%" PRIx64 "\n", *(uint64_t *)info); // entire 64-bit value
printf("%" PRIx32 "\n", *divided); // first 32 bits of the 64-bit array
printf("%" PRIx32 "\n", *dividedTwo); // second 32 bits of the 64-bit array
Note that you are filling your array with char literals (e.g. '2'), not integer literals - you may want to fix that to make the output clearer for yourself.
Watch out for potential alignment problems with this type of casting - it's not (strictly speaking) legit.

Answer 2

std::cout << "Expected value of info " << (uint8_t*)info<< std::endl; //Output 20200000 as expected.
uint8_t is not only an integer type, but also a character type. It is an alias of unsigned char. When you insert a pointer to character type into a character stream, the behaviour is to treat it as a null terminated character string. The null termination is a pre-coondition and lack of null termination results in undefined behaviour.
Your array is not null terminated. Therefore the behaviour of the program is undefined.
std::cout << "But why this return the true value? " << (uint8_t*)divided << std::endl; //Output 20200000 but why 8bit returns the true value instead of 32bit casting?
std::cout << "Same here, my value was type of 32... " << (uint8_t*)dividedTwo << std::endl; //Output 0000
Both of these are the same. Attempts to print a non-null terminated strings resulting in undefined behaviour.
std::cout << "Expected value of divided " << (uint32_t*)divided << std::endl; //Output 0x7ffdd25cabe0 not as my expected. What is the reason?
uint32_t is not a character type. Pointers to types other than character types are treated differently. Instead of printing a null terminated character string, the address of the pointed object is printed. In this case the address happens to be 0x7ffdd25cabe0. It is unclear what you expected instead.
Note that attempting to access the pointed object through the reinterpreted divided and dividedTwo pointers would result in undefined behaviour because no object of such type exist at the pointed address.
Is there any better solution to convert an 8-element uint_8 type array to a 2-element uint_32 type array instead of "shifting (<< >> etc.)"?
Shifting is usually the best way because it can be used to produce the same output regardless of the byte endianness of the CPU, and is therefore portable and can be used for communication between separate systems over the network or transfer of files.
Other, non-shifting ways to convert produce output depending on the endianness, so they cannot be used for example in communication between different systems. But, here is a correct example of how to do that:
uint8_t info8 [8] = ...;
uint32_t info32[sizeof info8 / sizeof(uint32_t)];
std::memcpy(info32, info8, sizeof info32);