¿Qué son los Pointer-to-Member -> * y. * Operadores en C++?

Question

Sí, he visto this question y this FAQ (enlace mal) this FAQ, pero todavía No entiendo lo que quiere decir ->* y .* en C++.
Estas páginas proporcionan información sobre los operadores (tales como la sobrecarga), pero no parecen explicar bien lo que son .

¿Qué son ->* y .* en C++, y cuándo los necesita en comparación con -> y .?

Answer 1

espero que este ejemplo se borrará cosas para usted

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

Ahora, no se puede utilizar x.somePointer(), o px->somePointer() porque no hay ningún miembro de la clase X. Para que la sintaxis especial llamada puntero de función miembro se usa ... solo pruebe algunos ejemplos, se acostumbrará

Answer 2

En pocas palabras: usted usa -> y . si sabe a qué miembro desea acceder. Y usa ->* y .* si no sabe a qué miembro desea acceder.

Ejemplo con una simple lista intrusiva

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

Answer 3

Los llamados "punteros" a los miembros de C++ se parecen más a las compensaciones, a nivel interno. Necesita tanto un "puntero" miembro y un objeto para hacer referencia al miembro en el objeto. Pero los "punteros" de miembro se usan con sintaxis de puntero, de ahí el nombre.

Hay dos maneras en que puede tener un objeto a la mano: tiene una referencia al objeto o tiene un puntero al objeto.

Para la referencia, utilice .* combinarlo con un puntero miembro, y para el puntero, utilice ->* combinarlo con un puntero miembro.

Sin embargo, como norma, no utilice punteros de miembro si puede evitarlo.

Obedecen reglas bastante contraintuitivas, y permiten eludir el acceso protected sin ningún tipo de conversión explícita, es decir, inadvertidamente y hellip;

Saludos & HTH,

Answer 4

no se puede referencia a un puntero a los miembros como punteros normales -. Porque requieren funciones miembro this puntero, y usted tiene que pasar de alguna manera. Por lo tanto, debe usar estos dos operadores, con el objeto en un lado y el puntero en otro, p. (object.*ptr)().

considerar el uso de function y bind (std:: o boost::, dependiendo de si se escribe C++ 0x o 03) en lugar de los que, sin embargo.

Answer 5

EDITAR: Por cierto, se pone raro para virtual member functions pointers.

Para variables miembro:

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

Las funciones miembro son casi los mismos.

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

Answer 6

Cuando usted tiene un puntero normal (a un objeto o un tipo básico), se utiliza para eliminar la referencia *:

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

Conceptualmente, estamos haciendo lo mismo con un miembro indicador de función:

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

Espero que esto ayude a explicar el concepto. Estamos efectivamente desreferenciando nuestro puntero a la función miembro. Es un poco más complicado que eso: no es un puntero absoluto a una función en la memoria, sino solo un desplazamiento, que se aplica a foo o p arriba. Pero conceptualmente, estamos desreferenciando, al igual que eliminaríamos un puntero de objeto normal.