将（常规）指向结构的成员变量的指针转换为指向整个结构的指针

Question

I'll start with the context - I'm writing a memory management subsystem and for that I'm providing substitutes for new[]/delete[] operators. One of the problems I had to solve was how to store the size of an array allocated by new[] so that delete[] can call destructors on deallocated objects. My chosen solution was to allocate more memory and store the size of an array before the first element of an actual array and return the pointer to that element. I came up with the following code:

template<typename T, typename AllocatorType>
T* NewArrayHelper(size_t count, AllocatorType* allocator, const char* file, int line) {
    // Helper struct
    struct Helper {
        size_t Count;
        T Array[1];
    };

    Helper* ptr = allocator->Allocate(sizeof(Helper) + sizeof(T)*(count-1), ALIGNOF(Helper), file, line);

    // Call constructors, etc. ...

    return &ptr->Array[0];
}

I should mention that what I like about this approach is that the compiler figures out the right alignment for the array and size_t and I don't have to do anything except reading it and passing to allocator (ALIGNOF is a macro that does that). Also I do not have to do any cast-through-union or cast to char* hacks that have to problems with aliasing etc.

Now on the other hand I have a problem with replacement for the delete[] operator. Namely it is handed a pointer to the internals of that struct.

template<typename T, typename AllocatorType>
void DeleteArrayHelper(T* ptr, AllocatorType* allocator, const char* file, int line) {
    // Helper struct
    struct Helper {
        size_t Count;
        T Array[1];
    };

    // Here ptr points to Array[0] in Helper struct
}

How can I convert such a pointer to the pointer to a whole struct in a manner that does the least hacking and is possibly portable?

Answer 1

Something like this will work, and should be portable:

Helper *h = (Helper*)((uintptr_t)ptr - offsetof(Helper, Array[0]));

uintptr_t is usually in stdint.h .