Comment l'opérateur de conversion de modèle ne de pointeur à la syntaxe fonction membre travail

Question

Je regardais la emulated version of nullptr et a vu cet opérateur conversion (un membre de nullptr_t):

template<class C, class T> // or any type of null 
operator T C::*() const  // member pointer... 
{ return 0; } 

Cette syntaxe pour pointer vers une fonction membre me embrouille. Je pense généralement à voir un tel type que quelque chose comme

R (C::*)(I1, I2, ...) 

Avec le modèle ci-dessus, il n'y a pas d'arguments d'entrée. Je ne peux pas comprendre comment la déduction de type fonctionne dans ce cas. J'ai de la difficulté à formuler une question spécifique, autre que, comment cela fonctionne-t-il? Si j'ai le code comme ceci:

typedef int (MyClass::*MyTypedef)(float); 
MyTypedef m = nullptr; 

Je suppose que T déduit à int, et C déduit à MyClass. Qu'est-ce qui "arrive" à flotter?

Answer 1

qui est un pointeur à un membre, pas nécessairement un pointeur à un membre fonction. La différence est qu'il peut générer un pointeur vers la fonction membre ou un pointeur vers un membre non-fonction. Maintenant, dans le cas d'utilisation particulier, la destination est un pointeur sur member, le compilateur voit une expression dans laquelle il a besoin d'un int (MyClass::*)(float), et d'un autre côté, il a un nullptr. Il essaie de trouver une conversion et il trouve le , qui est une conversion valide si C est déduit pour être MyClass et T est déduit pour être int (float) [fonction prenant un float et renvoyant un int].

Je trouve aussi ce coin de la langue un peu déroutant (ayant typedefs, ou types déduisent pour les fonctions), par exemple cela est légal si bizarre:

typedef void int_f(int); 
struct X { 
    int_f m; 
}; 
void X::m(int x) { std::cout << x << '\n'; } 

La même chose se passe dans l'opérateur de conversion qui vous intéresse.