Opérateurs C++ ésotériques

Question

Quel est le but des opérateurs C++ ésotériques suivants?

pointeur vers un membre

::* 

pointeur Bind à l'élément de pointeur

->* 

pointeur Bind à l'élément de référence

.* 

(reference)

Answer 1

Un pointeur vers un membre vous permet d'avoir un pointeur relatif à une classe spécifique. Ainsi, supposons que vous ayez une classe de contact avec plusieurs numéros de téléphone.

class contact 
{ 
    phonenumber office; 
    phonenumber home; 
    phonenumber cell; 
}; 

L'idée est que si vous avez un algorithme qui a besoin d'utiliser un numéro de téléphone, mais la décision dont le numéro de téléphone doit se faire en dehors de l'algorithme, les pointeurs de membre résoudre le problème:

void robocall(phonenumber contact::*number, ...); 

maintenant, l'appelant de robocall peut décider quel type de phonenumber à utiliser:

robocall(&contact::home, ...); // call home numbers 
robocall(&contact::office, ...); // call office number 

.* et ->* entrent en jeu une fois que vous avez un pointeur. Donc, à l'intérieur robocall, vous feriez:

contact c = ...; 
c.*number; // gets the appropriate phone number of the object 

ou:

contact *pc = ...; 
pc->*number; 

Answer 2

Vérifiez la C++ FAQ Lite's section on pointers to member functions. Recherchez les «opérateurs» spécifiques dont vous parlez (dans la plupart des navigateurs, Ctrl-F ouvre une boîte de dialogue Recherche/Recherche qui vous permet de rechercher du texte dans la page Web), et cela devrait vous aider à mieux comprendre les choses.

Answer 3

Une réponse simplifiée à l'extrême - ces opérateurs permettent d'appeler les fonctions membres comme des fonctions «régulières» (au moins, elles semblent identiques du point de vue de l'utilisateur final). Exemple du monde réel - ils sont beaucoup utilisés dans diverses implémentations de callback.

Answer 4

Il n'y a aucun opérateur tel que ::* et il n'y a jamais eu. Je ne sais pas où tu l'as eu.

Quant à ->* et .* - ce sont les opérateurs de déréférencer pour les pointeurs de de type pointeur à membre. En ce qui concerne les pointeurs aux membres ... que dit votre livre C++ préféré sur le sujet?

Answer 5

Elles vous permettent d'avoir des pointeurs vers des fonctions membres (et des variables membres) liées à une instance particulière de la classe.

Les pointeurs vers les fonctions membres peuvent être utiles pour des éléments tels que les implémentations allégées du modèle d'état.En règle générale, chaque fois que vous souhaitez modifier le comportement d'un objet au fil du temps sans recourir à la désactivation de l'objet entier, vous pouvez envisager l'utilisation de pointeurs sur les fonctions membres.

Des pointeurs vers des variables de membre peuvent être utilisés si vous voulez, par exemple, implémenter un algorithme générique pour rechercher un tableau de structures pour une entrée qui a une valeur particulière pour un champ donné.

Answer 6

Elles concernent les pointeurs vers les membres et les pointeurs vers les fonctions membres.

struct Foo { 
    int a() { return 1; } 
    int b() { return 2; } 
    int c; 
}; 

int main() { 
    Foo f; 
    f.c = 3; 

    typedef int (Foo::*member_fn)(); // pointer-to-member-function 
    typedef int (Foo::*data_member); // pointer-to-member 

    member_fn mf = &Foo::a; 
    (f.*mf)(); // calls the member function pointed to by mf. returns 1 
    mf = &Foo::b; 
    (f.*mf)(); // This time, returns 2, since mf points to b 
    Foo *fp = &f; 
    (fp->*mf)(); // same thing, via pointer to f instead of object/reference f. 

    data_member dm = &Foo::c; 
    f.*dm; // is 3 
    f.*dm = 5; 
    f.c; // is now 5. 

    Foo f2; // another instance 
    f2.c = 12; 
    f2.*dm; // is 12. Same pointer-to-member, different object. 
} 

Bien qu'il puisse ressembler à un, ::* n'est pas un opérateur. C'est l'opérateur :: et le modificateur de type * l'un à côté de l'autre. Pour prouver cela sans avoir recours à la lecture de la norme, essayez d'ajouter des espaces: :: * compile, . * ne fait pas, ni ne -> *.

Pour ce qu'ils sont réellement utiles pour - même principe que les pointeurs de fonction. Vous ne les utiliserez pas comme ci-dessus, dans une situation où vous pourriez simplement appeler la fonction par son nom, mais vous pouvez les passer en paramètres ou les renvoyer des fonctions, les stocker, ou en sélectionner un en fonction d'une logique compliquée.

Si elle aide, je crois que la syntaxe est choisie de sorte que même si .* est un opérateur unique indivisible, vous pouvez imaginer que *dm « signifie » c, le membre pointé par dm. Donc, si dm indique c, alors f.*dm est identique à f.c.