La Surcharge
S’il demeure aujourd’hui impossible de définir le langage de programmation le plus performant, c’est parce que selon l’objectif à atteindre, le moyen d’y parvenir peut-être plus ou moins efficace selon le langage utilisé. Dans notre monde informatique, les différents moyens définissent les langages que nous pouvons rencontrer, chacun ayant sa propre implémentation pour faciliter le travail du programmeur. Cependant même si les moyens changent d’un point de vue global, il arrive souvent que plusieurs langages utilisent une même recette. Ce dont nous allons parler dans cet article illustre une de ces “recettes” permettant à l’utilisateur d’utiliser plusieurs types de paramètres, tout en évitant l’utilisation d’une syntaxe lourde et stricte. Nous retrouvons celle-ci un peu partout : il s’agit de la surcharge (overloading en anglais).
Définition générale
La surcharge est une technique de programmation qui permet de changer l’opération à effectuer sur des paramètres, en fonction du type de ces derniers. En effet, le type des variables placées de part et d’autre de ces opérateurs, ou les paramètres saisis lors d’un appel de méthodes, peuvent être des entiers, des booléens ou bien toute autre sorte de type primitif et objets. Ce grand nombre de possibilités résulte d’un changement de logique d’implémentation. Nous avons alors affaire à un langage ayant plus de souplesse.
Pourquoi surcharger ?
On surcharge dans le but de répondre à un besoin des concepteurs de programmes. De ce fait, dans un code client, nous pouvons avoir envie d’effectuer une même logique d’opération mais sur différents types et nombre de variables. La conception d’un tel API deviendrais plus complexe mais l’utilisation d’un tel langage deviendrais tout de suite plus agréable car nous aurons des méthodes plus intelligentes qui exécuterons des commandes distinctes. Cela rend aussi l’écriture d’un code client plus simple, efficace et sûr qu’un code écrit dans un langage bloquant à chaque incohérence sur le paramétrage, évitant ainsi l’appel de mauvaises méthodes.
Plusieurs types de surchargent existent et pas tous opèrent de la même manière.
La Surcharge d’opérateurs
Nous voudrions que l’utilisation des opérateurs classiques comme le « + », le « * », le « < », le « == » sur des types différents n’impliques pas syntaxe différente. Même si la logique par derrière change, surtout au moment de la compilation ou de l’interprétation, certains langages vont accepter des opérations prenants différentes formes, reconnaissant la bonne implémentation à faire.
Considérons l’exemple ci-dessous sur MatLab :
Nous observons deux utilisations différentes pour le même opérateur d’addition : l’une se fait entre deux nombres complexes et l’autre entre un nombre complexe et un entier. Ceci est un premier exemple de surcharge. Lorsque nous additionnons un entier avec un complexe, l’interpréteur ne réalisera pas la même opération que lorsque nous ne manipulons que des entiers. De fait, il devra réaliser une première opération intermédiaire qui consiste à changer le type de la variable « 3 » en un complexe avec partie imaginaire égale à 0. Ainsi, l’opération d’addition classique des nombres complexes ne sera effectuée que dans un second temps.
La nécessité de passer par l’étape intermédiaire dépend donc des types utilisés : il y a un phénomène de surcharge de l’opérateur « + ». Dans ce cas, la surcharge était déjà définie dans l’API. Mais nous pouvons aussi manuellement les définir dans le code client. Cependant ceci nécessite de certaines spécificités de la part de l’API.
Qui peut Surcharger ?
Il n’est pas possible d’utiliser cet outil très pratique dans tous les langages de programmation. Pour pouvoir surcharger, il faut d’abord que le compilateur du programme reconnaisse que les paramètres d’un opérateur ou d’une méthode peuvent prendre différentes formes. Cela n’est réalisable que dans les langages qui associent à chaque variable un « type » précis : chaque type différent sera manipulé de manière différente et ciblée par l’ordinateur. Cela s’appelle un langage avec typage, celui-ci étant fort ou faible.
Les différents types de surcharges
Il y a donc deux sortes de langages qui respectent ce critère : ceux à typage statique et ceux à typage dynamique.
Statique
Le typage statique consiste à exiger que le programmeur explicite le type de chaque variable instanciée. Ainsi, au moment de compiler, une vérification de la cohérence des types de variables utilisées est réalisée. La surcharge est donc mise en œuvre lors de ce processus. L’interprétation adéquate d’une méthode ou d’un opérateur utilisé est donc fonction des types identifiés.
Nous pouvons rencontrer une surcharge statique en Java ou en Haskell par exemple. Dans la programmation orientée objet ceci est largement utilisé.
Dynamique
D’autres langages permettent une écriture moins explicite en tolérant de créer une variable sans avoir à indiquer son type. Le choix du type sera donc fait par le compilateur ou l’interpréteur selon la cohérence du code. Ceci est le cas avec Python par exemple, où l’on peut utiliser différents types pour un même variable au sein d’une seule méthode : tant que la logique est vérifiée, le compilateur tolère.
Ceci peut sembler effacer légèrement l’utilité de la surcharge. Cependant, elle est toujours présente dans ce genre de langage lorsque nous cherchons à modifier les actions d’une méthode en fonction du nombre de paramètres.
Passez de ce coté de la force
La surcharge peut être qualifiée comme un outil puissant de la programmation. Que ça soit pour un API à typage fort ou faible elle permet des raccourcis lors de l’utilisation de méthodes et l’élargissement de l’application des opérateurs arithmétiques. La surcharge rend l’utilisation de l’API plus attrayante pour client, qui pourra alors élaborer plus en faisant moins.
