Is casting an address by reinterpret_cast an undefined behaviour?

Question

I want to find a way to encapsulate a header-only 3rd party library without exposing its header files. In our other projects, we encapsulate by using void*: in the implementation, we allocate memory and assign to it, and cast to pointer of its original type when we use it. But this time, the encapsulated class is used frequently, hence dynamic allocation is unacceptable. Here is another solution I'm currently considering.

Assuming that the encapsulated class need N bytes, I will make a char array member variable of size N in the wrapper class, named data, for instance. In the implementation, when I try to assign an object of the encapsulated class to the wrapper, or forward a function call, I need to cast &data to the pointer of encapsulated class by reinterpret_cast, firstly. The char array is completely a placeholder. To make this clear, here is a sample code.

#include <iostream>

struct Inner {
    void print() const {
        std::cout << "Inner::print()\n";
    }
};

struct Wrapper;

Inner* addressof(Wrapper&);
const Inner* addressof(const Wrapper&);

struct Wrapper {
    Wrapper() {
        Inner* ptr = addressof(*this);
        *ptr = Inner();
    }

    void run() const {
        addressof(*this)->print();
    }
    
    char data[1];

};

Inner* addressof(Wrapper& w) {
    return reinterpret_cast<Inner*>(&(w.data));
}

const Inner* addressof(const Wrapper& w) {
    return reinterpret_cast<const Inner*>(&(w.data));
}

int main() {
    Wrapper wrp;
    wrp.run();
}

From the view of memory, this seems make sense. But I'm sure if this is some kind of undefined behaviour.

Additionally, I want to know if there is a list of undefined behaviour. Seems like cppreference doesn't contain such thing and C++ standard specfication is really hard to understand.

Answer 1

What you have here is undefined behavior. The reason is when you reinterpret an object to a different type, you are not allowed to modify it until you cast it back to the original type.

---

In your code, you originally have the data as a char[1]. Later, in your constructor, you reinterpret_cast &data as Inner*. At this point, modifying the its value will produce undefined behavior.

What you could do however, is to first create a Inner object, then cast it and store it in the char[1]. Later you can cast the char[1] back to the Inner object and do anything with the Inner object as wanted.

So now your constructor would look like this:

Wrapper() {
    Inner inner;
    char* ptr = reinterpret_cast<char*>(&inner);
    std::memcpy(data, ptr, 1);
}

However, if you did it like this, then you don't even need the reinterpret_cast there as you can directly memcpy from inner:

Wrapper() {
    Inner inner;
    std::memcpy(data, &inner, 1);
}

---

Better, if you have C++20, then you can and should use std::bit_cast, along with std::byte(C++17) and std::array(C++11):

struct Wrapper {
    Wrapper()
    : data(std::bit_cast<decltype(data)>(Inner{}))
    {}

    void run() const {
        std::bit_cast<Inner>(data).print();
    }
    
    std::array<std::byte, 1> data;
};

Demo: https://godbolt.org/z/MaT5sasaT