Quels sont le Pointeur de Membre ->* et .* Les opérateurs en C++?

Oui, j'ai vu cette question et cette FAQ (mauvais lien) cette FAQ, mais je encore ne comprends pas ce ->* et .* moyenne en C++.

Ces pages fournissent des informations sur les opérateurs (tels que la surcharge), mais ne semblent pas bien expliquer ce qu'ils sont.

Quels sont ->* et .* en C++, et quand avez-vous besoin de les utiliser comme comparé à -> et .?

  • Je pense que cette FAQ il explique assez bien.
  • Je ne peux pas croire que j'ai posté dans le mauvais lien. X___X c'est celui que je voulais poster, pas de MSDN! - Je l'ai regardé, mais je ne comprenais pas grand-chose. Tout ce qu'ils disent, c'est que "le type est différent", mais j'ai trouvé ce genre de confusion...
InformationsquelleAutor Mehrdad | 2011-07-05
  1. 66

    J'espère que cet exemple sera de clarifier les choses pour vous

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

    Maintenant, vous ne pouvez pas utiliser x.somePointer(), ou px->somePointer() car il n'est pas membre de la classe X. Pour que la fonction de membre du pointeur de la syntaxe d'appel est utilisé... juste essayer quelques exemples vous-même ,vous allez en prendre l'habitude

    • Ajouter le obligatoire extra accolades pour compenser la priorité de l'opérateur.
    • Ohh je vois ce qui se passe maintenant... je n'ai jamais vu ou besoin de quelque chose comme ça avant. C'est cool (+1), mais je suppose que la question est maintenant: Comment est pointer différents à partir d'un pointeur de fonction qu'il nécessite une syntaxe différente? (par exemple, Est-il plus grand?)
    • Le point est que pour appeler une fonction normale, vous venez de fournir les arguments. Mais dans le cas de fonctions membres non statiques vous avez également besoin d'un objet sur lequel vous voulez l'appeler la fonction. D'où la nouvelle syntaxe.
    • Un pointeur-à-membres de la fonction peut être plus qu'un simple pointeur vers la fonction: spécifiquement pour faire face à l'héritage de l'iirc
    • Quelqu'un peut-il expliquer comment le &X::f œuvres? Voir this question.
    InformationsquelleAutor Armen Tsirunyan
  2. 18

    EDIT: En passant, c'est bizarre pour membre virtuel des pointeurs de fonctions.

    Pour les variables membres:

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

    Fonctions membres sont presque les mêmes.

    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 ();
}
    • +1 pour montrer que la syntaxe s'applique à tous les membres, et pas seulement des fonctions de membre du. Je trouve que des pointeurs vers des variables membres sont très rarement utilisés, bien que, en dépit de leur grand nombre plutôt intéressant applications potentielles.
    InformationsquelleAutor spraff
  3. 11

    En un mot: Vous utilisez -> et . si vous savez ce membre auquel vous souhaitez accéder. Et vous utilisez ->* et .* si vous ne pas savoir ce membre auquel vous souhaitez accéder.

    Exemple avec un simple 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;
};
    • +1 pour la première phrase, bien que jamais dans ma vie je n'ai pas qui membre je veux accéder, haha. 🙂
    InformationsquelleAutor Johannes Schaub - litb
  4. 7

    Dite de "pointeurs" pour les membres en C++ sont plus comme des décalages, en interne. Vous avez besoin d'un membre de "pointeur", et un objet, pour faire référence au membre dans l'objet. Mais membre de "pointeurs" sont utilisés avec le pointeur de la syntaxe, d'où le nom.

    Il y a deux façons vous pouvez avoir un objet à portée de main: vous avez une référence à l'objet, ou si vous avez un pointeur vers l'objet.

    Pour la référence, l'utilisation .* de le combiner avec un pointeur de membre, et pour le pointeur, utilisation ->* de le combiner avec un pointeur de membre.

    Cependant, en règle générale, ne pas utiliser de pointeurs si vous pouvez l'éviter.

    Ils obéissent assez contre-intuitive, les règles, et elles permettent de contourner protected d'accès sans aucun explicite de la coulée, qui est, par inadvertance...

    Cheers & hth.,

    • +1 pour l'expliquer, sans code. 🙂 Question: Pourquoi ne peut-on pas prendre l'adresse de la fonction comme une fonction normale? Est le pointeur vers une fonction membre différent à partir d'un pointeur vers une autre fonction? (par exemple, est-il plus grand?)
    • Si vous pouviez avoir un pointeur sur fonction membre qui a été limitée à la non-membre virtuel fonctions, alors qu'il pourrait en effet être simplement l'adresse. Cependant, la quasi-ness ou pas ne fait pas partie de la fonction de membre de type pointeur. Et donc sa représentation doit inclure des informations sur la manière dont la valeur se rapporte à une fonction virtuelle ou pas, et si le virtuel, pour une vtable basée sur la mise en œuvre de l'information qui détermine le décalage dans la vtable de la classe, le type de pointeur est associé.
    InformationsquelleAutor Cheers and hth. - Alf
  5. 5

    Vous ne pouvez pas déréférencement de pointeur comme normal pointeurs — en raison des fonctions de membre du besoin this pointeur, et vous devez passer en quelque sorte. Donc, vous avez besoin d'utiliser ces deux opérateurs, avec l'objet sur un côté, et un pointeur sur l'autre, par exemple (object.*ptr)().

    Envisager d'utiliser function et bind (std:: ou boost::, selon que vous écrivez en C++03 ou 0x) à la place de ceux-ci, cependant.

    • Je pense que cela peut être la meilleure explication ici.
    InformationsquelleAutor Cat Plus Plus
  6. 5

    Lorsque vous avez un pointeur normal (d'un objet ou d'un type de base), vous pouvez utiliser * de déréférencement d'elle:

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

    Sur le plan conceptuel, nous faisons la même chose avec un membre de pointeur de fonction:

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

    Je l'espère, ce qui contribue à expliquer le concept. Nous sommes effectivement référence à notre pointeur à la fonction de membre. C'est un peu plus compliqué que ça-ce n'est pas un absolu pointeur vers une fonction dans la mémoire, mais juste un décalage, qui est appliqué à foo ou p ci-dessus. Mais sur le plan conceptuel, nous sommes de déférence, tout comme nous le ferions à déréférencer un objet normal pointeur.

    InformationsquelleAutor Tim