Статически получить смещение переменной-члена

Question

Я ищу способ получить смещение переменной-члена, чтобы статически передать это смещение переменной-члену.В основном я хочу добиться этого:

template <std::intptr_t OFFSET>
struct A
{
    std::intptr_t self()
    {
        return reinterpret_cast<std::intptr_t>(this) - OFFSET;
    }
};
struct B
{
    int some_variables[256];
    A<???> a;
};
int main()
{
    B b;
    assert(reinterpret_cast<std::intptr_t>(&b) == b.a.self()); // shall pass
    return 0;
}

Есть ли способ сделать это?

Answer 1

У меня была идея, и в конце концов я нашел способ статически получить адрес члена:

template <class T, class R, R T::* MEMBER>
struct B
{
    std::intptr_t self()
    {
        // got this reinterpret_cast from https://stackoverflow.com/a/5617632/4043866
        std::intptr_t offset = reinterpret_cast<std::intptr_t>(&(reinterpret_cast<T const volatile*>(NULL)->*MEMBER));
        std::intptr_t _this = reinterpret_cast<std::intptr_t>(this);
        return _this - offset - sizeof(R);
    }
};
template <class T, class... BASES>
constexpr std::size_t acc_sizes()
{
    return sizeof(T) + acc_sizes<BASES...>();
}
template <class... BASES>
struct B_START
{
    std::intptr_t self()
    {
        return reinterpret_cast<std::intptr_t>(this) - acc_sizes<BASES...>();
    }
};
struct Z
{
    int a;
};
#pragma pack(1)
struct A
    : Z
{
    B_START<Z> a;
    B<A, B_START<Z>, &A::a> b;
    B<A, B<A, B_START<Z>, &A::a>, &A::b> c;
};

Теперь я могу написать:

A a;
a.b.self();

Чтобы обратиться к правильной функции,без потери памяти.

Answer 2

Во-первых, как и просили, ваша цель недостижима, так как тип a воздействует на a внутри B:

struct B
{
    int some_variables[256];
    A</* offset of a inside B */> a;
};

Это выравнивание .

---

Вы можете использовать стандартный макрос offsetof.Это подразумевает две вещи:

1. Поскольку offsetof(type, member) четко определен только для стандартного макета type с, тип оболочки должен быть стандартного макета,
2. и поскольку offsetof можно "вызывать" только для полных типов, его статически вычисляемый результат может быть установлен только для подобъекта динамически;он не может быть параметром не типового шаблона, но может быть аргументом конструктора.

Полная программа

#include <cassert>
#include <cstdint>
#include <cstddef>

struct Location
{
    Location(std::size_t offset) : offset_(offset) {}
    std::size_t offset_;
    operator std::intptr_t () const { return reinterpret_cast<std::intptr_t>(this) - offset_; }
};

struct SomeType
{
    int some_variables[256];
    Location location = offsetof(SomeType, location);
};

int main()
{
    SomeType obj;
    assert(reinterpret_cast<std::intptr_t>(&obj) == obj.location); // does pass
}

live demo

Но, как вы прокомментировали, это совершенно бесполезно, поскольку Location можно просто определить как

template<class T>
struct Location
{
    Location(T* location) : location_(location) {}
    T* location_;
    operator T* () const { return location; }
};

и инициализировать с помощью Location location = this;.