Faire passer un pointeur vers une fonction membre comme un argument de modèle. Pourquoi ce travail?

Question

J'ai un code que 100% fonctionne pour le cas d'utilisation je. Je me demande si quelqu'un peut expliquer comment et pourquoi cela fonctionne.

I ai une classe de modèle qui se trouve entre un code qui gère le filetage et la communication de réseau et l'utilisateur de la bibliothèque pour transmettre des données reçues à partir du serveur à l'utilisateur.

template <class Bar,
          class Baz,
          class BazReturnType,
          void (Bar::*BarSetterFunction)(const BazReturnType &),
          BazReturnType (Baz::*BazGetterFunction)(void) const>
class Foo
{
    Foo( Bar *bar )
        : m_bar(bar)
    {
    }

    void FooMemberFunction( const Baz *baz )
    {
        boost::bind( BarSetterFunction, m_bar,
                     boost::bind( BazGetterFunction, baz )() ) ();
    }

    Bar *m_bar;
};

Ce modèle est instancié et utilisé dans la bibliothèque en fonction des types de Bar et Baz comme ceci:

typedef Foo<MyBar,
            MyBaz,
            ReturnTypeFromBazGetterFunction,
            &MyBar::ActualSetterFunction,
            &MyBaz::ActualGetterFunction >
    MyFoo;

MyBar *bar = new MyBar;
MyBaz *baz = new MyBaz;
MyFoo *f = new MyFoo( bar );
f->FooMemberFunction( baz );

Tout cela fonctionne et boost :: bind appelle les fonctions getter / setter pour transmettre les données autour d'où il doit aller. Comment et pourquoi passer des pointeurs vers des fonctions membres comme argument de modèle comme dans ce travail de cas?

---

En réponse aux commentaires, je n'avais pas réalisé que des pointeurs vers les fonctions membres étaient des arguments de modèle valides. Ce n'est pas quelque chose que j'avais vu « dans la nature » avant. Je l'ai essayé et cela a fonctionné, mais je ne m'y attendais pas à.

Answer 1

Je pense qu'il ya une meilleure explication pourquoi il est possible de le faire que « parce que la norme le dit »:

La raison pour laquelle cela fonctionne est parce que les pointeurs-à-membres sont des valeurs constantes connues au moment de la compilation (pointeur à membre est effectivement un décalage d'un membre depuis le début d'une classe). Ainsi, ils peuvent être utilisés en tant que paramètres de modèles, comme tout autre constante entière peut être.

D'autre part, les pointeurs normaux sont compilent pas constantes de temps, car ils dépendent de la mise en page de la mémoire qui n'existe que lors de l'exécution. Ils ne peuvent pas être des arguments modèle.

Answer 2

Lorsque vous posez une question sur les lignes de « pourquoi quelque chose fonctionne? », Cela implique que le fait que cela fonctionne est en quelque sorte surprenant de vous. Il est impossible de répondre à la question, à moins que vous EXPLIQUER pourquoi vous trouvez surprenant.

Pourquoi ça marche? Parce que la spécification du langage dit explicitement qu'il doit travailler. Il n'y a pas d'autre réponse, jusqu'à ce que vous expliquez vos préoccupations plus en détail.