y a-t-il une utilisation de & func ou class :: func en c ++?

Question

Cela semble incohérent. Pourquoi utilisons-nous & Example :: func au lieu de Example :: func? y a-t-il une utilisation pour Example :: func ou & exampleFunction? il ne semble pas que nous puissions faire référence à une fonction pour exclure Example :: func. et je ne vois pas comment utiliser & exampleFunction, car exampleFunction renvoie déjà un pointeur.

#include <iostream>
class Example {
public:
    void func() { std::cout <<"print me\n"; }
};
void exampleFunction() { std::cout << "print me too\n"; }
typedef void (Example::*ExampleFunc_t)(); 
typedef void (*ExampleFunction_t)();
int main()
{
    Example e;
    ExampleFunc_t     f  = &Example::func;
    ExampleFunction_t f2 = exampleFunction;
    (e.*f)();
    f2();
    return 0;
} 

Answer 1

Parce que c'est ainsi que la norme définit les pointeurs vers les fonctions.

Vous devez en fait toujours utiliser l'opérateur d'adresse & amp; pour obtenir un pointeur sur une fonction. Toutefois, pour les fonctions ordinaires et les fonctions membres statiques, une conversion implicite d'une fonction à une autre est défini dans la norme.

Ceci n'est pas défini pour une fonction membre (non statique) car vous ne pouvez pas obtenir de valeur lvalue pour une fonction membre non statique.

À partir du standard C ++:

  

4.3 Conversion de fonction en pointeur

     

  
1. Une lvalue du type de fonction T peut être convertie en une rvalue de type   “Pointeur sur T”. Le résultat est un pointeur sur la fonction.
  

avec note de bas de page 52:

  

Cette conversion ne s'applique jamais aux fonctions membres non statiques, car   une valeur qui fait référence à une fonction membre non statique ne peut pas être obtenue.

Je pense qu'ils préfèrent uniquement autoriser & amp; fonction, pour des raisons de cohérence, mais que la conversion implicite est simplement un artefact de l'héritage C ...

Answer 2

Il s’agit d'utiliser les pointeurs de fonction . Pour un exemple très approximatif, supposons qu'une classe comportant plusieurs variables de membre vous permette de trier les éléments d'un tableau de ce type de classe, comme ceci:

struct CL {
    int x, y, z;
};

bool sort_by_x(const CL& obj1, const CL& obj2);
bool sort_by_y(const CL& obj1, const CL& obj2);
bool sort_by_z(const CL& obj1, const CL& obj2);

...

CL obj[100];
...
sort(obj, obj+100, sort_by_x);
...
sort(obj, obj+100, sort_by_y);
...
sort(obj, obj+100, sort_by_z);

Ici, std :: sort est utilisé pour trier un tableau d'objets CL. Regardez le troisième paramètre, c'est le nom d'une fonction. La fonction std :: sort peut prendre un pointeur de fonction dans le troisième paramètre et utiliser cette fonction comme comparateur pour trier le tableau. C’est à nous de voir comment définir les fonctions sort_by_ * pour que std :: sort fonctionne comme prévu.