Какво представляват операторите указател към член -›* и .* в C++?

Надявам се, че този пример ще ви изясни нещата

//we have a class
struct X
{
   void f() {}
   void g() {}
};

typedef void (X::*pointer)();
//ok, let's take a pointer and assign f to it.
pointer somePointer = &X::f;
//now I want to call somePointer. But for that, I need an object
X x;
//now I call the member function on x like this
(x.*somePointer)(); //will call x.f()
//now, suppose x is not an object but a pointer to object
X* px = new X;
//I want to call the memfun pointer on px. I use ->*
(px ->* somePointer)(); //will call px->f();

Сега не можете да използвате x.somePointer() или px->somePointer(), защото няма такъв член в клас X. За това се използва специалният синтаксис за извикване на указател на функция член... просто опитайте сами няколко примера, ще свикнете

РЕДАКТИРАНЕ: Между другото, става странно за указатели за виртуални членски функции.

За членски променливи:

struct Foo {
   int a;
   int b;
};


int main ()
{
    Foo foo;
    int (Foo :: * ptr);

    ptr = & Foo :: a;
    foo .*ptr = 123; // foo.a = 123;

    ptr = & Foo :: b;
    foo .*ptr = 234; // foo.b = 234;
}

Функциите на членовете са почти еднакви.

struct Foo {
   int a ();
   int b ();
};


int main ()
{
    Foo foo;
    int (Foo :: * ptr) ();

    ptr = & Foo :: a;
    (foo .*ptr) (); // foo.a ();

    ptr = & Foo :: b;
    (foo .*ptr) (); // foo.b ();
}

Накратко: използвате -> и ., ако знаете до кой член искате да получите достъп. И вие използвате ->* и .*, ако не знаете до кой член искате да получите достъп.

Пример с прост натрапчив списък

template<typename ItemType>
struct List {
  List(ItemType *head, ItemType * ItemType::*nextMemPointer)
  :m_head(head), m_nextMemPointer(nextMemPointer) { }

  void addHead(ItemType *item) {
    (item ->* m_nextMemPointer) = m_head;
    m_head = item;
  }

private:
  ItemType *m_head;

  // this stores the member pointer denoting the 
  // "next" pointer of an item
  ItemType * ItemType::*m_nextMemPointer;
};

Така наречените "указатели" към членове в C++ са по-скоро като отмествания, вътрешно. Нуждаете се както от такъв "указател" на член, така и от обект, за да посочите члена в обекта. Но "указателите" на члена се използват със синтаксиса на указателя, оттук и името.

Има два начина да имате обект под ръка: имате препратка към обекта или имате указател към обекта.

За препратка използвайте .*, за да го комбинирате с указател на член, а за указателя използвайте ->*, за да го комбинирате с указател на член.

Въпреки това, като правило, не използвайте указатели на член, ако можете да го избегнете.

Те се подчиняват на доста контраинтуитивни правила и правят възможно заобикалянето на protected достъп без изрично кастинг, тоест по невнимание

Наздраве и чт.,

Когато имате нормален указател (към обект или основен тип), бихте използвали *, за да го дереферирате:

int a;
int* b = a;
*b = 5;     // we use *b to dereference b, to access the thing it points to

Концептуално, ние правим същото нещо с указател на членска функция:

class SomeClass
{
   public:  void func() {}
};

// typedefs make function pointers much easier.
// this is a pointer to a member function of SomeClass, which takes no parameters and returns void
typedef void (SomeClass::*memfunc)();

memfunc myPointer = &SomeClass::func;

SomeClass foo;

// to call func(), we could do:
foo.func();

// to call func() using our pointer, we need to dereference the pointer:
foo.*myPointer();
// this is conceptually just:    foo  .  *myPointer  ();


// likewise with a pointer to the object itself:
SomeClass* p = new SomeClass;

// normal call func()
p->func();

// calling func() by dereferencing our pointer:
p->*myPointer();
// this is conceptually just:    p  ->  *myPointer  ();

Надявам се, че това помага да се обясни концепцията. Ние ефективно дереферираме нашия указател към функцията член. Това е малко по-сложно от това -- това не е абсолютен указател към функция в паметта, а просто отместване, което се прилага към foo или p по-горе. Но концептуално, ние го дереферираме, подобно на това, че бихме дереферирали нормален обектен указател.

Не можете да деименувате указател към членове като нормални указатели — защото членските функции изискват this указател и трябва да го предадете по някакъв начин. И така, трябва да използвате тези два оператора, с обект от едната страна и показалец от друга, напр. (object.*ptr)().

Обмислете обаче използването на function и bind (std:: или boost::, в зависимост от това дали пишете C++03 или 0x) вместо тях.

Оператори за достъп указател към член: .* и ->*

Операторите за достъп от указател към член, .* и ->*, са за дерефериране на указател към член в комбинация с обект и указател към обект съответно. Това описание се отнася както за указатели към членове с данни, така и за указатели към членски функции.

Например, разгледайте класа Foo:

struct Foo {
   int i;
   void f();
};

Ако декларирате указател на член, iPtr, към член на данни int от Foo:

int Foo::* iPtr;

Можете да инициализирате този указател на член iPtr, така че да сочи към члена Foo::i:

iPtr = &Foo::i;

За да дереферирате този указател, трябва да го използвате заедно с обект Foo.

Помислете сега за обекта foo и указателя към обект fooPtr:

Foo foo;
Foo* fooPtr = &foo;

След това можете да дереферирате iPtr в комбинация с foo или fooPtr:

foo.*iPtr = 0;
fooPtr->*iPtr = 0;

Аналогично, можете да използвате .* и ->* с указатели към функционални членове. Имайте предвид обаче, че ще трябва да ги поставите в скоби, тъй като операторът за извикване на функция, т.е. (), има по-висок приоритет от .* и ->*:

void (Foo::*memFuncPtr)() = &Foo::f;

(foo.*memFuncPtr)();
(fooPtr->*memFuncPtr)();

В заключение: имате нужда от обект, за да дереферирате указател към член и кой от тях използвате, или .* или ->* за дерефериране на указателя към член, зависи от това дали този необходим обект е предоставен директно или чрез указател на обект.

C++17 — Използване на std::invoke() вместо това

Използването на двата оператора може да бъде заменено от C++17 от std::invoke функционален шаблон. std::invoke предоставя унифициран начин за дерефериране на указатели на членове, независимо дали ги използвате в комбинация с обект или указател на обект, както и независимо дали указателят към член съответства на указател към член на данни или указател към членска функция:

// dereference a pointer to a data member
std::invoke(iPtr, foo) = 0;      // with an object
std::invoke(iPtr, fooPtr) = 0;   // with an object pointer

// dereference a pointer to a member function
std::invoke(memFuncPtr, foo);      // with an object
std::invoke(memFuncPtr, fooPtr);   // with an object pointer