Question

Lately I’ve been doing a lot of exercises with file streams. When I use fstream.write(...)
to e.g. write an array of 10 integers (intArr[10]) I write:

fstream.write((char*)intArr,sizeof(int)*10);

Is the (char*)intArr-cast safe? I didn’t have any problems with it until now but I learned about static_cast (the c++ way right?) and used static_cast<char*>(intArr) and it failed! Which I cannot understand … Should I change my methodology?

Answer 1

A static cast simply isn’t the right thing. You can only perform a static cast when the types in question are naturally convertible. However, unrelated pointer types are not implicitly convertible; i.e. T* is not convertible to or from U* in general. What you are really doing is a reinterpreting cast:

int intArr[10];

myfile.write(reinterpret_cast<const char *>(intArr), sizeof(int) * 10);

In C++, the C-style cast (char *) becomes the most appropriate sort of conversion available, the weakest of which is the reinterpreting cast. The benefit of using the explicit C++-style casts is that you demonstrate that you understand the sort of conversion that you want. (Also, there’s no C-equivalent to a const_cast.)

Maybe it’s instructive to note the differences:

float    q  = 1.5;
uint32_t n  = static_cast<uint32_t>(q);      // == 1, type conversion
uint32_t m1 = reinterpret_cast<uint32_t>(q); // undefined behaviour, but check it out
uint32_t m2 = *reinterpret_cast<const uint32_t *>(&q); // equally bad

Off-topic: The correct way of writing the last line is a bit more involved, but uses copious amounts of casting:

uint32_t m;
char * const pm = reinterpret_cast<char *>(&m);
const char * const pq = reinterpret_cast<const char *>(&q);
std::copy(pq, pq + sizeof(float), pm);