Quel est le point de pointeurs de fonction?

La plupart des exemples se résument à rappels: Vous appelez une fonction f() en passant l'adresse d'une autre fonction g(), et f() appels g() pour certains tâche spécifique. Si vous passer f() l'adresse de h() au lieu de cela, puis f() ne h() à la place.

Fondamentalement, c'est une façon de paramétrer une fonction: une partie de son comportement n'est pas codée en dur dans f(), mais dans la fonction de rappel. Les appelants peuvent faire f() se comportent différemment en passant par les différentes fonctions de rappel. Un classique est qsort() de la bibliothèque C standard qui prend son critère de tri comme un pointeur vers une fonction de comparaison.

En C++, cela se fait souvent à l'aide de fonction des objets (également appelé foncteurs). Ce sont des objets que la surcharge de l'opérateur d'appel de fonction, de sorte que vous pouvez les appeler comme si elles étaient une fonction. Exemple:

class functor {
  public:
     void operator()(int i) {std::cout << "the answer is: " << i << '\n';}
};

functor f;
f(42);

L'idée derrière cela est que, contrairement à un pointeur de fonction, un objet de fonction peut porter non seulement un algorithme, mais également des données:

class functor {
  public:
     functor(const std::string& prompt) : prompt_(prompt) {}
     void operator()(int i) {std::cout << prompt_ << i << '\n';}
  private:
     std::string prompt_;
};

functor f("the answer is: ");
f(42);

Un autre avantage est qu'il est parfois plus facile de l'inclure des appels à la fonction des objets que des appels par le biais de pointeurs de fonction. C'est une des raisons pourquoi le tri en C++ est parfois plus rapide que le tri de C.

Exemples:

1. Un tri personnalisé/recherches
2. Différents
   les modèles (comme la Stratégie, de l'Observateur)
3. Rappels

Je vais aller à contre-courant ici.

En C, les pointeurs de fonction sont la seule façon de mettre en œuvre la personnalisation, car il n'est pas OO.

En C++, vous pouvez utiliser des pointeurs de fonction ou de foncteurs (objets de fonction) pour le même résultat.

Foncteurs ont un certain nombre d'avantages par rapport aux premières pointeurs de fonction, en raison de leur objet, la nature, notamment:

• Ils peuvent présenter plusieurs surcharges de la operator()
• Ils peuvent avoir l'état /de référence pour les variables existantes
• Ils peuvent être construits sur place (lambda et bind)

Personnellement, je préfère les foncteurs de pointeurs de fonction (en dépit du code réutilisable), principalement parce que la syntaxe des pointeurs de fonction peut facilement s'arracher les cheveux (à partir de la Pointeur De Fonction Tutoriel):

typedef float(*pt2Func)(float, float);
  //defines a symbol pt2Func, pointer to a (float, float) -> float function

typedef int (TMyClass::*pt2Member)(float, char, char);
  //defines a symbol pt2Member, pointer to a (float, char, char) -> int function
  //belonging to the class TMyClass

La seule fois où j'ai vu des pointeurs de fonction utilisé lorsque les foncteurs ne pouvaient pas été dans le coup de pouce.Esprit. Ils ont totalement abusé de la syntaxe de transmettre un nombre arbitraire de paramètres que d'un seul paramètre du modèle.

 typedef SpecialClass<float(float,float)> class_type;

Mais depuis variadic templates et les lambdas sont autour du coin, je ne suis pas sûr que nous allons utiliser des pointeurs de fonction en C++ pur code pour longtemps.

D'accord avec tout ce qui précède, plus....
Lorsque vous chargez une dll dynamiquement à l'exécution, vous aurez besoin de pointeurs de fonction pour appeler les fonctions.

Comme Riche dit ci-dessus, il est très habituel pour les pointeurs de fonctions dans Windows pour faire référence à une adresse qui stocke la fonction.

Lorsque vous la programmation en C language sur la plateforme Windows, vous avez la charge, le fichier DLL dans la mémoire primaire(à l'aide de LoadLibrary) et à utiliser les fonctions stockées dans la DLL, vous devez créer des pointeurs de fonctions et de point à cette adresse (à l'aide de GetProcAddress).

Références:

• LoadLibrary

• GetProcAddress

Mon utilisation principale d'entre elles a été RAPPELS: lorsque vous avez besoin pour enregistrer des informations sur une fonction de appeler plus tard.

Dire que vous êtes en train de rédiger Bomberman. 5 secondes après que la personne laisse tomber la bombe, elle doit exploser (la explode() fonction).

Maintenant, il y a 2 façons de le faire. Un moyen est de "sonder" toutes les bombes sur l'écran pour voir si ils sont prêts à exploser dans la boucle principale.

foreach bomb in game 
   if bomb.boomtime()
       bomb.explode()

Une autre façon est d'attacher un rappel de votre horloge de système. Quand une bombe est planté, vous ajouter un rappel à faire appel à la bombe.explode() quand le moment est venu.

//user placed a bomb
Bomb* bomb = new Bomb()
make callback( function=bomb.explode, time=5 seconds ) ;

//IN the main loop:
foreach callback in callbacks
    if callback.timeToRun
         callback.function()

Ici callback.function() peut être toute fonction, parce que c'est un pointeur de fonction.

Un point de vue différent, en plus d'autres bonnes réponses ici:

Dans C, il existe seulement des pointeurs de fonction, il n'y a pas toutes les fonctions.

Je veux dire, vous écrire des fonctions, mais tu ne peux pas manipuler fonctions. Il n'y a aucun moment de l'exécution de la représentation d'une fonction en tant que telle. Vous ne pouvez même pas l'appeler "fonction". Lorsque vous écrivez:

my_function(my_arg);

ce que vous êtes en train de dire est "effectuer un appel à l' my_function pointeur avec l'argument spécifié". Vous faites un appel via un pointeur de fonction. Cette la carie de pointeur de fonction signifie que les commandes suivantes sont équivalentes aux précédentes appel de la fonction:

(&my_function)(my_arg);
(*my_function)(my_arg);
(**my_function)(my_arg);
(&**my_function)(my_arg);
(***my_function)(my_arg);

et ainsi de suite (merci @LuuVinhPhuc).

Donc, vous êtes déjà à l'aide de pointeurs de fonction en tant que valeurs. Évidemment, vous voulez avoir des variables pour ces valeurs - et c'est là où toutes les autres utilisations metion venir: Polymorphisme/personnalisation (comme dans qsort), les rappels, sauter tables etc.

En C++, les choses sont un peu plus compliquées, puisque nous avons des lambdas, et les objets de operator(), et même un std::function classe, mais le principe est toujours essentiellement la même.

J'utilise des pointeurs de fonction largement, pour l'émulation de microprocesseurs qui ont 1 octet opcodes. Un tableau de 256 pointeurs de fonction est le moyen naturel de le mettre en œuvre.