Comparatif d'implémentations, fonctions

Pour testA() :

appliquer(f, 3.5) == 4

Pour testB() :

f(3.5) == 4

Pour testC() :

gen(), gen(), gen() -> 0, 1, 2

En C#, depuis les tout débuts, la métephore privilégiée pour manipuler des méthodes en tant que méthodes est le délégué.

Représenté par le type delegate dans le langage, un délégué est une entité polymorphique sur la base de la signature. En C#, ceci couvre à la fois les méthodes d'instance et les méthodes de classe.

Dans cet exemple, un delg est un délégué qui peut pointer sur n'importe quelle méthode prenant en paramètre un double et retournant un int.

La classe X contient une propriété privée, un constructeur paramétrique, et surtout (pour notre exemple) une méthode d'instance F et une méthode de classe G, toutes deux ayant la même signature (qui correspond à celle supportée par le type delg, plus haut).

Dans le code de test, j'utilise une méthode de classe Tester() prenant en paramètre un Func<double,int> et un double.

Un Func<T0,T1,...,R> est une sorte de délégué générique prenant en paramètre un T0, un T1, ... et retournant un R. Dans notre cas, le Func représente une fonction unaire (à un paramètre), et Tester(f,arg) appelle f(arg) pour en afficher le résultat.

La méthode de classe TesterGénérique() se comporte comme le fait Tester(), mais ne se limite pas à un Func<double,int>, acceptant plutôt un Func<T,U> pour deux types T et U quelconques.

La méthode de classe Créer() retourne un objet (une λ, concrètement) pouvant s'utiliser comme un délégué unaire prenant un double et retournant un int. Puisque le type d'une λ est inaccessible au programme, nous entreposons cet objet dans un Func de signature adéquate.

La méthode de classe Générateur(n) retourne un objet (une λ, concrètement) se comportant comme une opération nullaire (sans paramètres). L'objet en question capture une copie de n dans une fermeture; à chaque utilisation de cet objet comme une fonction, il retournera n++, modifiant chaque fois sa copie interne de n.

Le programme de test procède aux opérations suivantes :

• Une instance de X, nommée x, est créée. Ceci nous permettra de tester un délégué sur une méthode d'instance comme sur une méthode de classe
• Un délégué nommé fct est ensuite placé sur x.f, ce qui permettra de l'utiliser comme la méthode d'instance f de l'objet x. Cette syntaxe concise peut surprendre un programmeur C++, langage où le passage de this aux méthodes d'instance est moins transparent
• Des tests sont faits en traitant fct comme un Func<double,int> et comme un Func<T,U> pris au sens large du terme
• Par la suite, fct est utilisé pour mener sur une λ de signature appropriée
• Enfin, un test est fait sur Créer(), méthode qui retourne une sorte de fonction, et sur gen, méthode qui retourne un objet muni d'état et pouvant être utilisé pour générer une séquence d'entiers

Remarquez que pour les fonctions Créer() et Générateur(), j'ai utilisé var pour indiquer le type de l'objet retourné. En utilisant var, le type de la variable est déduit du type de l'expression utilisée pour l'initialiser.

Pour les besoins de nos exemples, nous définirons plusieurs fonctions. L'une d'elles sera tite_somme(), qui calculera la somme de trois entiers et retournera cette somme.

template <class T>
   T tite_somme(T && arg) {
      return arg;
   }
template <class T, class ... Args>
   auto tite_somme(T && arg, Args && ... args) {
      return arg + tite_somme(tite_somme(std::forward<Args>(args)...));
   }

template <class ... Args>
   auto tite_somme(Args && ... args) {
      return (args + ...);
   }

La fonction tester() prend en paramètre une opération f de signature int(double), donc prenant en paramètre un double et retournant un int, de même qu'un double nommé arg, et appelle f(arg).

Un std::function est un proche cousin d'un délégué en C#, en ce sens qu'un objet de ce type encapsule une entité appelable sur la base d'une signature précise. Les deux sont distincts l'un de l'autre sur le plan de l'utilisation avec une méthode d'instance, cela dit : en C#, le lien entre this et sa méthode est encapsulé dans le délégué, alors qu'en C++, this apparaît comme premier paramètre (habituellement silencieux) dans la signature de la méthode. Nous montrerons un exemple plus bas.

La fonction tester_generique() prend en paramètre une opération f et un paramètre arg, et appelle f(arg). Elle ne connaît pas de prime abord les types de l'un et de l'autre, mais il importe pour elle qu'utiliser f comme une fonction et lui passer arg en paramètre soit légal.

Ceci permet entre autres un cas où f est de signature std::string(int) et où arg est un short, car il est légal de passer un short en paramètre à une fonction s'attendant à recevoir un int.

Les fonctions tester_variadique(f, args...) et afficher_params(args...) permettent respectivement d'appeler f(args...) et d'afficher les valeurs de chaque paramètre dans args...

On peut dire de tester_variadique() qu'il s'agit en quelque sorte d'une généralisation de tester_generique().

La fonction creer() retourne une λ encapsulée dans un function<int(double)> et pouvant s'utiliser comme telle. Puisque le type d'une λ est inaccessible au programme, nous entreposons cet objet dans un function de signature adéquate.

La fonction generateur(n) retourne une λ encapsulée dans un function<int()> et pouvant s'utiliser comme telle (sans paramètres). L'objet en question capture une copie de n dans une fermeture; à chaque utilisation de cet objet comme une fonction, il retournera n++, modifiant chaque fois sa copie interne de n.

Notez qu'en C++, par défaut, l'opérateur () d'une λ est une méthode const. Pour éviter cette situation, dans un cas comme celui-ci où nous souhaitons que les attributs capturés par copie à la construction de la λ soient modifiables, il convient de qualifier la λ de mutable.

Nous utiliserons plusieurs formats de fonctions pour les fins de notre démonstration. La fonction fglob() est une fonction globale de signature int(double).

Dans la classe X, on trouve deux méthodes de signature int(double), soit la méthode d'instance f et la méthode de classe g.

Notez que dans le cas de X::f(), la signature est trompeuse car en réalité, le premier paramètre passé à l'appel de cette fonction est this, ici de type const X*. Ceci se reflétera dans notre utilisation de std::function pour l'appeler, un peu plus bas.

Il est souvent utile de définir un type (avec typedef) pour un pointeur de fonction; une raison pour cette habitude répandue est que la syntaxe des pointeurs de fonctions, héritée de C, est quelque peu lourde (le nom du type apparaît en plein centre de l'expression!). Consolez-vous cependant : la syntaxe d'un pointeur de méthode d'instance est pire encore!.

Ici, le type pfct est un pointeur sur une fonction prenant un double en paramètre et retournant un int.

Depuis C++ 11, une nouvelle écriture, plus générale, est possible avec using. Ici, le type pfct11 est un pointeur sur une fonction prenant un double en paramètre et retournant un int.

Bien que les écritures pour pfct et pfct11 soient équivalentes sur le plan opératoire, il est probable que celle utilisée pour pfct11 vous semble plus lisible.

Le programme de test commence en utilisant un pfct et un pfct11 pour mener à fglob et montre qu'appeler fglob de manière directe ou indirecte, que ce soit par l'un ou l'autre de ces types, donne exactement le même résultat en pratique.

int (*pointeur_fonction)(double) = fglob;

Une méthode de classe n'a pas de paramètre this silencieux; en ce sens, il s'agit d'une fonction globale, bien que son nom soit qualifié par celui de la classe à laquelle elle appartient. Pour cette raison, nos types pfct et pfct11 permettent tous deux de prendre l'adresse d'une méthode de classe ayant la signature qu'ils décrivent.

Une méthode d'instance a par contre une syntaxe plus complexe, du fait qu'il faut tenir compte du passage de this (en tant que premier paramètre, habituellement implicite, à la fonction). Ainsi, à droite, pmeth est une variable du type « pointeur sur une méthode d'un X qualifié const, prenant en paramètre un double et retournant un int », alors que l'adresse de la méthode f dans un X s'écrit &X::f.

Notez qu'en exprimant &X::f, nous savons où la méthode f d'un X se trouve peu importe ce X, mais pas à quelle instance de X elle se rattache (pas quel est le this à lui passer).

À l'utilisation, on peut appeler la méthode f d'un X spécifique avec son opérateur .* s'il s'agit d'un objet ou d'une référence, ou à travers son opérateur ->* s'il s'agit d'un pointeur. Oui, je sais, ces syntaxes sont épouvantables, mais on parle ici de code pour spécialistes, pas d'opérateurs « de tous les jours ». Notez l'utilisation de parenthèses, nécessaire dans ce cas-ci pour réguler la priorité des opérateurs.

Depuis C++ 11, il est plus « normal » d'avoir recours à un std::function applicable à la signature souhaitée pour manipuler fonctions, méthodes et λ. Quelques exemples sont présentés ici. Portez en particulier attention à meth, qui déclare un std::function applicable à une méthode d'instance d'un const X : la signature du function prend deux paramètres plutôt qu'un, le premier étant le this pour cette méthode (de type const X), et à l'utilisation de meth, l'instance sur laquelle le pointeur de méthode doit être utilisé est explicitement passée en tant que paramètre.

Il est possible de ramener la syntaxe d'utilisation d'un pointeur de méthode unaire à celle d'une fonction unaire en liant le premier paramètre lors de l'appel à une instance spécifique. Ici, nous y arrivons en utilisant std::bind(), et en indiquant que x doit être utilisé en tant que premier paramètre à l'appel de meth (le std::placeholders::_1 représente conceptuellement ce premier paramètre).

Enfin, quelques exemples d'utilisation de fonctions en tant que paramètres à des fonctions sont proposés, pour compléter le portrait.

Contrairement à C# ou à C++, Java ne supporte ni les délégués, ni les λ – les λ sont l'un des ajouts les plus attendus pour la version 8 du langage.

Ce qui ressemble le plus à un délégué en Java est une classe anonyme, implémentant une interface donnée. Nous en utiliserons deux ici, soit Appelable, dont la méthode f() prend un double et retourne un int, et AppelableGénérique<T,U>, dont la méthode f() prend un T et retourne un U.

Pour les besoins de la démonstration, nous utilisons une classe X (qualifiée static car elle sera utilisée dans la méthode de classe main()), qui a un attribut privé, un constructeur paramétrique public et (surtout, pour nos fins) une méthode d'instance f et une méthode de classe g, toutes deux de même signature.

Nous utiliserons deux méthodes de test pour nos interfaces concrète et générique, soit tester(app,arg) qui appellera app.f(arg) et testerGénérique<T,U>(app,arg) qui fera de même, mais sur un app générique.

La méthode de classe créer() montre un idiome de Java, soit l'instanciation « juste à temps » d'une classe anonyme. Par classe anonyme, on entend une classe qui n'a pas de nom explicite dans le programme.

Ici, l'expression new Appelable() { ... } crée un dérivé d'une classe anonyme implémentant Appelable, ce qui est légal dans la mesure où toutes les méthodes déclarées dans Appelable y sont bel et bien implémentées. Ici, on parle de la méthode f prenant en paramètre un double et retournant un int.

L'interface Générateur expose un service prochain() retournant un entier. Elle pourrait servir de porte d'entrée pour les services d'un générateur d'entiers séquentiels ou aléatoires, par exemple.

La méthode de classe générer(n) retourne une instance d'une classe interne à la méthode mais implémentant Générateur. La raison pour laquelle nous devons utiliser une classe nommée ici est que nous ne pouvons utiliser de constructeur paramétrique pour une classe anonyme si celle-ci instancie une implémentation d'une interface.

Le programme de test procède comme suit :

• Il instancie d'abord X pour obtenir l'instance x. Notez le recours à une référence qualifiée final ici : que la référence soit inamovible est nécessaire pour la capturer dans iune fermeture, ce que nous ferons incessamment
• En effet, l'instruction suivante instancie app0, instance d'une classe anonyme implémentant Appelable de manière telle que sa méthode f(arg) délègue le traitement à x.f(arg). Pour qu'une telle capture soit légale en Java, il faut que x soit une référence qualifiée final
• Des appels à tester() et à testerGénérique() apparaissent à divers endroits, pour montrer comment ces objets créés sur demande peuvent être traités comme des implémentations de l'interface dont ils sont issus
• Notez que dans le cas des implémentations de l'interface AppelableGénérique, le fait que la généricité en Java passe nécessairement par des classes et implique du Boxing réduit la généralité de la solution :
  • en effet, le double (un primitif) passé en paramètre à l'origine est réifié en Double (une classe) pour assurer la généricité de la méthode f()
  • tristement, le fait que nous appelions à l'interne une méthode prenant en paramètre un double force la conversion du Double en sa valeur de type double
  • pour obtenir le double dans un Double, la méthode à appeler porte un nom qui indique le type de destination (ici : doubleValue()) plutôt qu'être général (quelque chose comme value() serait idéal)
• Le reste va un peu de soi

L'implémentation proposée ici se décline en trois temps. Le premier est fait :

• D'une fonction appliquer(f,arg), où f est une fonction unaire et arg est le paramètre à y suppléer. Une exécution de appliquer(f,arg) a pour effet d'appeler f(arg), et
• D'une fonction testA(), qui réalise un appel à appliquer() en lui passant une fonction f et un paramètre (un nombre à virgule flottante)

Dans testA(), la fonction passée à appliquer() est une variable locale nommée f, associée à une fonction unaire. Cet exemple montre qu'il est simple de mettre une fonction dans une variable et de passer celle-ci en paramètre à une autre fonction qui, enfin, l'appellera.

Le deuxième  est fait :

• D'une fonction creer() qui retourne une fonction unaire (à un paramètre) qui retourne le résultat d'un calcul réalisé sur son paramètre, et
• D'une fonction testB(), qui appelle creer() et place le résultat (la fonction ainsi créée) dans une variable, puis l'utilise en appelant la fonction en question.

Enfin, le troisième est fait :

• D'une fonction generer(n), qui retourne une fonction nullaire (qui ne prend aucun paramètre) capturant n dans une fermeture et retournant n++ à chaque appel, et
• D'une fonction testC() qui crée, avec generer(0) une fonction associée à la variable gen l'appelle trois fois