Что такое `int foo::*bar::*`?

Вот "действительный" способ инициализации такого чудовища:

struct bar;

struct foo
{
    int y;    
    int bar::* whatever;
};

struct bar
{
    foo aFoo;
};

int bar::* foo::* ptr = &foo::whatever;

Как мы видим, ptr является указателем на элемент foo (foo::*, читается справа налево), где этот элемент сам является указателем на член bar (bar::*), где этот элемент является целым числом.

Как бы я использовал int bar::* foo::*

Вы бы не стали, надеюсь! Но если вы находитесь под принуждением, попробуйте это!

struct bar
{
    foo aFoo;

    int really;
};

int bar::* foo::* ptr = &foo::whatever;
foo fleh;
fleh.whatever = &bar::really;
bar blah;
blah.*(fleh.*ptr) = 42;
std::cout << blah.really << std::endl;

Это будет указатель на член данных, который сам является указателем на член данных (член int из bar).

Не спрашивайте меня, для чего это вообще полезно - голова немного кружится :)

РЕДАКТИРОВАТЬ: Вот полный пример этого в действии:

#include <iostream>

struct bar {
    int i;
};

struct foo {
    int bar::* p;
};

int main()
{
    bar b;
    b.i = 42;

    foo f;
    f.p = &bar::i;

    int bar::*foo::*ptr = &foo::p;
    std::cout << (b.*(f.*ptr));
}

Выход, конечно, 42.

Это может быть еще интереснее — вот несколько указателей на функции-члены, которые возвращают указатели на функции-члены:

#include <iostream>

struct bar {
    int f_bar(int i) { return i; };
};

struct foo {
    int(bar::*f_foo())(int)
    {
        return &bar::f_bar;
    }
};

int main()
{
    int(bar::*((foo::*ptr)()))(int) = &foo::f_foo;

    bar b;
    foo f;

    std::cout << (b.*((f.*ptr)()))(42);
}

Давайте разберем объявление int bar::*foo::*ptr;.

§8.3.3 [dcl.mptr]/p1:

В объявлении T D, где D имеет форму

nested-name-specifier * attribute-specifier-seq_opt cv-qualifier-seq_opt D1

а спецификатор вложенного имени обозначает класс, а тип идентификатора в объявлении T D1 — «список-типов-производных-деклараторов T», тогда тип идентификатора D — « список-производных-деклараторов cv-qualifier-seq указатель на член класса вложенный-спецификатор-имени типа T».

• Шаг 1: Это объявление приведенной выше формы, где T = int, вложенный-спецификатор-имени = bar:: и D1 = foo::* ptr. Сначала мы смотрим на объявление T D1 или int foo::* ptr.

• Шаг 2: Мы снова применяем то же правило. int foo::* ptr — это объявление приведенной выше формы, где T = int, описатель вложенного имени = foo:: и D1 = ptr. Очевидно, тип идентификатора в int ptr — «int», поэтому тип идентификатора ptr в объявлении int foo::* ptr — это «указатель на член класса foo типа int».

• Шаг 3. Возвращаемся к исходному объявлению; тип идентификатора в T D1(int foo::* ptr) — «указатель на член класса foo типа int» на шаге 2, поэтому список-производных-деклараторов — это «указатель на член класса foo». типа". Подстановка говорит нам, что это объявление объявляет ptr "указателем на член класса foo типа указателя на член класса bar типа int".

Надеюсь, вам никогда не понадобится использовать такое чудовище.

Если кому-то интересно, вы не можете создать указатель на элемент, который вложен в несколько слоев. Причина этого в том, что все указатели на члены на самом деле намного сложнее, чем кажутся на первый взгляд; они не просто содержат конкретное смещение для этого конкретного члена.

Использование простого смещения не работает из-за виртуального наследования и тому подобного; в основном может случиться так, что даже в пределах одного типа смещения определенного поля различаются между экземплярами, и поэтому разрешение указателя на член необходимо выполнять во время выполнения. В основном это связано с тем, что в стандарте не указано, как может работать внутренняя компоновка для типов, отличных от POD, поэтому нет способа заставить ее работать статично.

Если это так, то выполнение двухуровневого глубокого разрешения не может быть выполнено с обычным указателем на член, но потребуется, чтобы компилятор сгенерировал указатель таким образом, чтобы он содержал вдвое больше информации, чем одноглубокий указатель на член. .

Я предполагаю, что, поскольку указатели на член не так распространены, нет необходимости фактически создавать синтаксис, позволяющий устанавливать многоуровневые глубокие члены, когда вы все еще можете использовать несколько указателей для достижения того же результата.

Во-первых, чтобы улучшить "читабельность", вы можете использовать круглые скобки (компиляция будет работать):

struct bar;

struct foo
{
    int y;
    int (bar:: *whatever); // whatever is a pointer upon an int member of bar.
};

struct bar
{
    foo aFoo;
};

// ptr is a pointer upon a member of foo which points upon an int member of bar.
int (bar:: *(foo:: *ptr)) = &foo::whatever;

Обратите внимание, что

int (бар :: * что угодно)

эквивалентно

интервал (* что угодно)

с ограничением на принадлежность к бару.

Что касается

int (бар:: *(foo:: *ptr))

, это эквивалентно

интервал (*(*указатель))

с двумя ограничениями на членство в foo и bar.

Они просто указатели. Они не проверяют, действительно ли у bar или foo есть совместимый член, потому что это помешало бы использовать предварительное объявление класса bar, а class bar не проверяет, ссылаются ли другие классы на его члены через указатели. Кроме того, вам также может понадобиться сослаться на непрозрачный класс (то есть иметь панель классов, определенную в отдельном модуле).

А полезность? может быть, для отражения С++ как способ установить/получить значение члена класса через оболочку класса?

template< typename Class, typename Type >
struct ClassMember
{
    using MemberPointer = Type (Class:: *);
    MemberPointer member;
    ClassMember(MemberPointer member) : member(member) {}
    void operator()(Class & object, Type value) { object.*member = value; }
    Type operator()(Class & object)  { return object.*member; }
};

template< typename Class, typename Type > ClassMember< Class, Type > MakeClassMember(Type(Class:: *member))
{
    return ClassMember< Class, Type >(member);
}

struct Rectangle
{
    double width;
    double height;

    Rectangle(double width = 0., double height = 0.) : width(width), height(height) {}
};

int main(int argc, char const *argv[])
{
    auto r = Rectangle(2., 1.);

    auto w = MakeClassMember(&Rectangle::width);
    auto h = MakeClassMember(&Rectangle::height);

    w(r, 3.);
    h(r, 2.);

    printf("Rectangle(%f, %f)\n", w(r), h(r));

    return 0;
}

Конечно, в этом примере не показано конкретное использование двойного указателя на член, потому что я не вижу простого способа проиллюстрировать его здесь или хорошей причины для этого с концептуальной точки зрения.