Is there a way to reinterpret_cast to a virtual derived* and calling overriden from parent?

Question

#include <iostream>

template<typename T>
struct printer {

    virtual const T* get(size_t& sz) const = 0;

    void print() {
        size_t sz;
        const T* _t = get(sz); //tries to access 'this'
        for (size_t t = 0; t < sz; t++)
            std::cout << _t[t] << std::endl;
    }
};

template<typename T, size_t sz>
struct mask_t : public printer<T> {
    T data[sz];

    virtual const T* get(size_t& _sz) const override {
        _sz = sz;
        return data;
    }
};

int main(int argc, char** argv) {

    char* buffer = new char[1024];
    {
        using mask_f = mask_t<float, 12>;
        using mask_i = mask_t<int, 12>;

        mask_f* mf = reinterpret_cast<mask_f*>(buffer + 42);
        mask_i* mi = reinterpret_cast<mask_i*>(buffer + 42);

        //'this' is uninitialized
        mf->print();
        mi->print();

        mask_f _mf = *mf;
        mask_i _mi = *mi;

        //ok
        _mf.print();
        _mi.print();
    }
    delete[] buffer;

    return 0;
}

print() tries to access this when invoking get() is it because of a vfptr lookup ? In other words is this impossible to do ?

Edit : I know I can create a new mask_t with either new or as I have done here by dereferencing the pointer. Then mask_t::this is defined.

The reason I don't want to create the instance is for performance issues [and that's not visible in my example I admit]. If you want to answer please address the only question in this post.

Answer 1

This is not valid code regardless of the types. In C++, you can't just cast a random pointer to an object and pretend one exists.

And yes, in C++20, they do allow you to do that under certain circumstances. But even there, those circumstances do not include operations on types with virtual member functions (as they are insufficiently trivial).

Just use placement-new to construct the object. That's how you're supposed to create objects in storage.

---

print() tries to access this when invoking get() is it because of a vfptr lookup ?

Does it matter? That's a implementation aspect of how the undefined behavior causes a crash.

This: mask_f* mf = reinterpret_cast<mask_f*>(buffer + 42); causes undefined behavior. As does this: mask_f _mf = *mf;. Both of these access an object which does not exist. Therefore, they both exhibit undefined behavior.

That a particular compiler (version) might make one of these appear to do what you want and might make the other crash is a matter of detail and implementation. Both of these pieces of code are equally nonsensical, and neither can be relied upon to do what you want.

I could explain why the assembly the compiler generated allowed you to get away with UB in one case and not in the other. But that ignores the fact that, either way, you're relying on UB.

I am reading memory of a remote process.

That just isn't a reasonable thing to do in C++. Not for types with virtual members, at any rate. The traditional method is to serialize the data of that type into memory, then de-serialize it in the receiving process back into a new object of that type.

Now yes, if you're willing to write platform-specific hackery, there are ways to pass virtual types between processes like this. They require extracting vtable pointers (from valid objects) and writing them into the object data received from the remote process, thus effectively "fixing" the object in-situ.

But these are platform-specific hackery; if you want something portable, you have to work with serialization.

Answer 2

"I know I can create a new mask_t with either new or as I have done here by dereferencing the pointer. Then mask_t::this is defined."

That is wrong. An object starts to exist when the body of its constructor is entered. new, including placement new, is a way to cause the constructor to run. Other ways are just declaring a local or global variable. But "dereferencing the pointer" as you assume does not magically cause a constructor to run, and an object to be created. And without an object, this cannot point to the current object.

Instead, you get Undefined Behavior. Anything can happen. Your harddisk could be erased.