C++ Access memory which isn't part of the object itself

It sounds weird, I guess, but I'm creating some low-level code for a hardware device. Dependend on specific conditions I need to allocate more space than the actual struct needs, store informations there and pass the address of the object itself to the caller.

When the user is deallocating such an object, I need to read these informations before I actually deallocate the object.

At the moment, I'm using simple pointer operations to get the addresses (either of the class or the extra space). However, I tought it would be more understandable if I do the pointer arithmetics in member functions of an internal (!) type. The allocator, which is dealing with the addresses, is the only one who know's about this internal type. In other words, the type which is returned to the user is a different one.

The following example show's what I mean:

struct foo
开发者_C百科{
    int& get_x() { return reinterpret_cast<int*>(this)[-2]; }
    int& get_y() { return reinterpret_cast<int*>(this)[-1]; }

    // actual members of foo

    enum { size = sizeof(int) * 2 };
};


int main()
{
    char* p = new char[sizeof(foo) + foo::size];
    foo* bar = reinterpret_cast<foo*>(p + foo::size);

    bar->get_x() = 1;
    bar->get_y() = 2;

    std::cout << bar->get_x() << ", " << bar->get_y() << std::endl;

    delete p;
    return 0;
}

Is it arguable to do it in that way?

---

It seems needlessly complex to do it this way. If I were to implement something like this, I would take a simpler approach:

#pragma pack(push, 1)
struct A
{
   int x, y;
};

struct B
{
   int z;
};
#pragma pack(pop)

// allocate space for A and B:
unsigned char* data = new char[sizeof(A) + sizeof(B)];

A* a = reinterpret_cast<A*>(data);
B* b = reinterpret_cast<B*>(a + 1);

a->x = 0;
a->y = 1;
b->z = 2;

// When deallocating:
unsigned char* address = reinterpret_cast<unsigned char*>(a);

delete [] address;

This implementation is subtly different, but much easier (in my opinion) to understand, and doesn't rely on intimate knowledge of what is or is not present. If all instances of the pointers are allocated as unsigned char and deleted as such, the user doesn't need to keep track of specific memory addresses aside from the first address in the block.

---

The very straightforward idea: wrap your extra logic in a factory which will create objects for you and delete them smart way.

---

You can also create the struct as a much larger object, and use a factory function to return an instance of the struct, but cast to a much smaller object that would basically act as the object's handle. For instance:

struct foo_handle {};

struct foo
{
    int a;
    int b;
    int c;
    int d;

    int& get_a() { return a; }
    int& get_b() { return b; }
    //...more member methods

    //static factory functions to create and delete objects
    static  foo_handle* create_obj() { return new foo(); }
    static void delete_obj(foo_handle* obj) { delete reinterpret_cast<foo*>(obj); }
};

void another_function(foo_handle* masked_obj)
{
    foo* ptr = reinterpret_cast<foo*>(masked_obj);
    //... do something with ptr
}

int main()
{
    foo_handle* handle = foo::create_obj();
    another_function(handle);
    foo::delete_obj(handle);

    return 0;
}

Now you can hide any extra space you may need in your foo struct, and to the user of your factory functions, the actual value of the pointer doesn't matter since they are mainly working with an opaque handle to the object.

---

It seems your question is a candidate for the popular struct hack.

Is the "struct hack" technically undefined behavior?