punto asterisco operatore in C++

Question

c'è, e se, che cosa fa?

.* 

Answer 1

sì, c'è. È l'operatore pointer-to-member da usare con i tipi pointer-to-member.

E.g.

struct A 
{ 
    int a; 
    int b; 
}; 

int main() 
{ 
    A obj; 
    int A::* ptr_to_memb = &A::b; 

    obj.*ptr_to_memb = 5; 

    ptr_to_memb = &A::a; 

    obj.*ptr_to_memb = 7; 

    // Both members of obj are now assigned 
} 

Qui, A è una struct e ptr_to_memb è un puntatore a int membro A. Il .* combina un'istanza A con un puntatore al membro per formare un'espressione di lvalue che fa riferimento al membro appropriato della data istanza Aobj.

Il puntatore ai membri può essere un riferimento ai membri dei dati o ai membri delle funzioni e persino "fa la cosa giusta" per i membri delle funzioni virtuali.

E.g. questo programma in uscita f(d) = 1

struct Base 
{ 
    virtual int DoSomething() 
    { 
     return 0; 
    } 
}; 

int f(Base& b) 
{ 
    int (Base::*f)() = &Base::DoSomething; 
    return (b.*f)(); 
} 

struct Derived : Base 
{ 
    virtual int DoSomething() 
    { 
     return 1; 
    } 
}; 

#include <iostream> 
#include <ostream> 

int main() 
{ 
    Derived d; 
    std::cout << "f(d) = " << f(d) << '\n'; 
    return 0; 
} 

Answer 2

si possono incontrare l'operatore quando si utilizzano i puntatori membri:

struct foo 
{ 
    void bar(void); 
}; 

typedef void (foo::*func_ptr)(void); 

func_ptr fptr = &foo::bar; 
foo f; 

(f.*fptr)(); // call 

Anche in relazione è l'operatore di ->*:

func_ptr fptr = &foo::bar; 
foo f; 
foo* fp = &f; 

(fp->*fptr)(); // call