Genericite

Généricité

En programmation, la généricité d'une fonction repose sur son indépendance vis-à-vis du type, et éventuellement du nombre, de ses arguments. C'est un concept important pour un langage de haut niveau car il permet d'augmenter le niveau d'abstraction du langage. Plusieurs mécanismes visant à permettre l'écriture de fonctions génériques ont donc été mis en œuvre par les différents langages de programmation.

Polymorphisme

Dans un langage à typage dynamique, on utilise le polymorphisme ad hoc : les paramètres passés en arguments à la fonction doivent se conformer à une interface donnée (un protocole définissant quelles méthodes sont supportées par cet argument). Ce mécanisme est supporté par tous les langages orientés objets, y compris ceux que l'on qualifie généralement comme étant à typage statique (Java, ou méthodes virtuelles du C++ par exemple). En effet, même si le langage apporte des outils pour vérifier la cohérence des interfaces à la compilation, la détermination du type réel de l'argument (c’est-à-dire la résolution de l'adresse du code implémentant les méthodes de l'interface) n'est effectuée qu'à l'exécution dans certains cas.

Programmation générique

Principe

Un avantage de la programmation générique consiste à abstraire un ensemble de concepts cohérents pour construire des algorithmes au-dessus indépendamment de leur implémentation. Ainsi la fonction de tri de la STL a besoin en entrée d'itérateurs aléatoires sur une collection d'objets et d'une fonction de comparaison sur ces objets ; cela rend ainsi cette fonction utilisable dans de très nombreux contextes.

Ce mécanisme permet une programmation générique purement statique puisque l'ensemble des résolutions de types est fait au moment de la compilation.

Par exemple, si l'on veut créer une liste générique, une déclaration (ici en utilisant les templates de C++) serait : List<T>, où T représente un type. À l'instanciation, on pourrait créer une List<Integer> ou une List<Animal>. La liste est ensuite traitée comme si le type correspondant avait été spécifié.

Langages d'implémentation

La programmation générique est supportée par certains langages à typage statique dans lesquels il est possible d'utiliser des types génériques ou « templates ».

La toute première implémentation fut en Ada 83, bien avant les templates de C++ qui ont popularisé la programmation générique, en permettant d'écrire du code sans considérer explicitement les types de données avec lesquels le code sera utilisé. Ceci est intensivement utilisé dans la Standard Template Library (STL).

D'autres langages de programmation, comme Java depuis la version 1.5 ou encore Eiffel, supportent la programmation générique. Objective Caml permet également une programmation générique assez subtile et très puissante grâce au système de modules paramétrés qu'il propose. VB.NET et C# commencent à le faire avec .NET 2.0.

Arguments optionnels

Certains langages offrent également la possibilité de rendre des arguments optionnels en leur définissant une valeur par défaut. Des langages comme Python ou Java (depuis la version 1.5) ou le D offrent par ailleurs la possibilité de définir des fonctions qui acceptent un nombre arbitraire de paramètres. Le langage C propose également un mécanisme de fonction variadic destiné à l'implémentation des fonctions à nombre variables d'arguments.

Surcharge et multi-méthodes

Dans certains langages, il est possible d'utiliser la surcharge des opérateurs ou des fonctions. Cette technique consiste à donner le même nom à plusieurs fonctions sémantiquement équivalentes mais agissant sur des paramètres de type différent. Lorsqu'il rencontre ce nom de fonction, le compilateur choisit l'implémentation la plus adaptée en se basant sur le nombre et le type des arguments. Des langages comme CLOS étendent ce principe en choisissant parmi les fonctions homonymes non plus à la compilation mais à l'exécution. Ce mécanisme est appelé multi-méthode et est souvent présenté par ailleurs comme une extension du polymorphisme.

Autres techniques

Il est également possible de réaliser des fonctions génériques dans des langages non objets. C'est ainsi que l'outil utilisé pour développer en C des fonctions génériques est le pointeur de fonction. Par exemple la fonction qsort de la bibliothèque standard accepte en argument un pointeur sur une fonction chargée de comparer les éléments à trier.

Ce document provient de « G%C3%A9n%C3%A9ricit%C3%A9 ».