Was sind die Pointer-zu-Member - & gt; * und. * Operatoren in C ++?

Ich hoffe, dieses Beispiel wird klar, Dinge, die für Sie

//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();

Nun, Sie können nicht x.somePointer() oder px->somePointer() weil es keine solche Mitglied in der Klasse X. Für Sie, dass die special-member-Funktion-Zeiger-Aufruf-syntax verwendet wird... probier einfach mal ein paar Beispiele zu sich selbst ,Sie werden sich daran gewöhnen

InformationsquelleAutor der Antwort Armen Tsirunyan

Kurz gesagt: Sie verwenden -> und . wenn Sie wissen, was die Sie zugreifen möchten. Und Sie verwenden ->* und .* wenn Sie nicht wissen, was die Sie zugreifen möchten.

Beispiel mit einem einfachen intrusive Liste

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;
};

InformationsquelleAutor der Antwort Johannes Schaub - litb

Wenn Sie einen normalen pointer (auf ein Objekt oder ein basic-Typ), verwenden Sie * zu dereferenzieren:

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

Konzeptionell, wir tun die gleiche Sache mit einer member-Funktion-Zeiger:

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  ();

Ich hoffe, dass hilft zu erklären, das Konzept. Wir sind effektiv dereferenzieren unsere Zeiger auf die Memberfunktion. Es ist ein wenig komplizierter als das-es ist nicht eine absolute Zeiger auf eine Funktion im Speicher, sondern nur einen offset, die angewendet wird, um foo oder p oben. Aber konzeptionell sind wir dereferenzieren, wie viel würden wir dereferenzieren einer normalen Objekt-Zeiger.

InformationsquelleAutor der Antwort Tim