Types de données primitifs

Ces types de données sont considérés comme primitifs car ils sont très étroitement liés au matériel machine. Cela signifie que le format, ou motif binaire, des valeurs réelles peut être reconnu par les registres et l'unité arithmétique et logique (UAL) de l'ordinateur. Quelques exemples de types de données primitifs sont le nombre, le caractère et le booléen (Boolean) (qui contient les valeurs true ou false), comme visible dans le Tableau 7.2.

Nous avons appris que le typage fort fait référence à la caractéristique d'un HLL dans lequel une variable est restreinte à contenir des valeurs du type avec lequel elle est définie. Le concept de coercition (coercion) fait référence à la capacité d'une variable d'un type de données à être forcée de contenir une valeur d'un type de données différent. En d'autres termes, les règles de coercition sont un assouplissement de la vérification de type. Par exemple, un type de données Java int contient un nombre entier de quatre octets, tandis qu'un short int contient un nombre entier de deux octets. Nous pouvons légalement affecter la valeur du short int à l'int : elle est coercée par l'affectation, ce qui a un sens absolu car la valeur courte peut s'insérer dans la valeur plus longue.

D'autre part, nous ne pouvons pas affecter un type de données Java long de 8 octets à un int Java de 4 octets ; il est trop grand pour tenir, et si nous essayons, nous obtiendrons une erreur de compilation qui ne permettra pas au programme de s'exécuter. Cependant, nous pouvons forcer l'affectation en utilisant un mécanisme appelé transtypage (type cast). C'est un mécanisme dans de nombreux HLL qui nous permet de forcer la valeur plus grande dans l'espace plus petit qui nous est donné par la variable plus petite. Cela peut avoir des effets secondaires, qui doivent être connus du programmeur pour utiliser le mécanisme efficacement. L'effet secondaire de l'exemple Java long vers int est la troncation : quatre des octets sont supprimés.

Types de données complexes

Nous avons appris que certains des types de données d'un langage sont des types primitifs, ce qui signifie que les données de ce type peuvent être directement représentées dans les registres et les emplacements mémoire de la machine. Cependant, les langages contiennent généralement aussi des types de données complexes.

Un type de données complexe est un type composé de plusieurs types primitifs utilisés comme blocs de construction, c'est pourquoi nous les appelons également types composites. Ces multiples types peuvent être du même type, comme dans un type de données complexe connu sous le nom de tableau, ou ils peuvent consister en des collections de types de données différents dans une seule construction, comme une classe C#.

Tableaux

Un tableau est un type composite typique qui est utilisé comme conteneur de données. Une excellente façon de visualiser un tableau est comme une unité d'étagères, une structure connectée où nous pouvons placer des éléments sur chaque emplacement. Une instance d'un tableau dans ce cas pourrait être une bibliothèque destinée à contenir des livres (un livre serait un autre type composite).

Un tableau (array) est une variable nommée qui référence un bloc d'emplacements mémoire contigus, et chaque « étagère » du tableau est un élément, qui occupe exactement autant d'octets contigus qu'il en faut pour accueillir une valeur du type de données stocké. Dans le type de structure de tableau le plus simple, un tableau indexé (indexed array), les étagères sont numérotées avec un index, commençant à zéro, ou l'emplacement mémoire le plus bas. Dans un langage fortement typé (strongly typed), tous les éléments d'un tableau doivent être du même type de données, ce qui signifie que chaque élément aura une longueur uniforme en octets.

La Figure 7.10 illustre un tableau dans n'importe quel nombre de HLL, y compris Java, C et C#. Nous commençons par la déclaration du tableau, qui donne le type de données de chacun de ses éléments, nomme la variable de tableau numbers, indique qu'il s'agit d'un tableau avec les crochets ouvrants et fermants ([]), et lui affecte cinq valeurs avec ce que l'on appelle un initialiseur de tableau (array initializer) (valeurs séparées par des virgules placées entre accolades). Nous pouvons voir que la longueur du tableau est de 5, les index vont de 0 à 4, et chacun des éléments est contigu en mémoire et a une longueur de 4 octets. L'instruction suivante affecte un élément du tableau à une variable :

int myNumber = numbers[5];

Figure 7.10 Chaque valeur d'un tableau se voit attribuer un index et une adresse mémoire. (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)

String myUniversity = "Union Technical College";

Identifiants

Un nom de variable est appelé un identifiant (identifier). Différents HLL ont des règles différentes concernant la syntaxe légale des identifiants. Par exemple, en C#, les règles sont les suivantes :

• Un identifiant ne peut pas être un mot-clé (keyword), qui est un mot réservé par le langage et qui a une signification spéciale.
• Une lettre, un symbole @ ou un trait de soulignement doit commencer un identifiant, tandis que la partie restante peut être composée de chiffres, du symbole de trait de soulignement et/ou de lettres (différemment de cela, un identifiant en PHP commence par un signe dollar ($)).
• Les identifiants sont sensibles à la casse (case-sensitive), où les lettres majuscules et minuscules sont traitées comme distinctes. Par conséquent, l'identifiant C# myAge est une entité différente de myAGE (Fortran, BASIC et Pascal ne sont pas sensibles à la casse).

Déclarations de variables

Une variable doit être portée à la connaissance d'un compilateur ou d'un interpréteur avant de pouvoir être utilisée par un programme informatique. Ce processus (process) est la déclaration et/ou la définition de variable. Dans les langages fortement typés, une déclaration de variable (variable declaration) consiste en une instruction qui spécifie le nom de la variable et son type de données. Les langages faiblement typés omettent le type de données lorsque des valeurs sont affectées à la variable, qui peuvent être de types différents à des moments différents.

Les définitions de variables dans différents langages sont les suivantes :

Java:             int myAge;

JavaScript:   var myAge;

PHP:             $myAge = 21;

L'affectation de sa première valeur à une variable est connue sous le nom d'initialisation (initialization), qui peut être effectuée à tout moment après la déclaration, comme dans l'extrait Java suivant :

int myAge;
myAge = 21;

C'est une bonne pratique (best practice) de toujours initialiser les variables lorsqu'elles sont déclarées. C'est ce qu'on appelle la déclaration et l'initialisation. Cela empêche la valeur stockée d'être indéfinie à tout moment, ce qui peut avoir de graves conséquences dans le code dans diverses situations. Par exemple, dans le langage de programmation C, ne pas initialiser un pointeur vers un tableau de caractères dans un programme et copier une chaîne de caractères à l'emplacement mémoire (non initialisé) référencé par ce pointeur plus tard dans le programme fera planter le programme. Voici un autre exemple en Java :

int myAge = 21;

Affectation

Un littéral (literal) est une valeur de l'un des types de données légaux d'un HLL qui peut être écrite directement dans le code. Par exemple, en JavaScript, l'un des types de données est numérique, qui peut être représenté soit par le nombre entier littéral 2, soit par le nombre à virgule flottante 2.0. En C++, un littéral de type char peut être écrit comme la séquence entre guillemets simples a.

Le stockage d'une valeur dans une variable (variable) est effectué en créant une instruction d'affectation (assignment statement) : la valeur affectée peut être un littéral, ou elle peut être la valeur qui a été placée dans une autre variable ou le résultat d'une expression. La valeur d'une variable peut également être remplacée par affectation. Par conséquent, les variables peuvent contenir des valeurs différentes à des moments différents.

Dans une expression PHP qui constitue une affectation comme indiqué, la variable est située à gauche. Notez que l'identifiant commence par le signe dollar ($), conformément aux règles d'identifiant de PHP. Le signe égal (=) est connu comme l'opérateur d'affectation, comme dans la plupart des langages avec une syntaxe de type C (C/C++, Java, C#, Python, JavaScript, PHP).

$myAge = 21;

Dans les langages de programmation, nous appelons la partie gauche d'une instruction d'affectation de variable (la variable) la lvaleur (lvalue). La valeur de droite (le littéral) est appelée la rvaleur (rvalue). L'opérateur d'affectation est un opérateur binaire (binary operator), ce qui signifie qu'il est entouré de deux opérandes. L'opérande est la lvaleur ou la rvaleur de chaque côté de l'opérateur. La rvaleur d'une instruction d'affectation de variable peut être la valeur d'une autre variable comme indiqué ici ou le résultat d'une expression. Un exemple de ceci en Java est le suivant :

myAge = yourAge;

Examinons le concept un peu plus en profondeur. Les variables peuvent être des emplacements mémoire nommés. Nous donnons un nom à une variable pour qu'il soit facile pour les humains de la gérer. C'est une bonne pratique d'utiliser des noms qui sont indicatifs à la fois du but de la variable (à quoi elle servira) et du type de données qu'elle contiendra. Ainsi, la variable myAge dans l'exemple précédent répond aux deux caractéristiques. Une bonne pratique des HLL est d'utiliser une convention convenue pour les noms de variables. Un exemple est camelCase, une convention de nommage qui élimine les espaces et la ponctuation en faveur de la capitalisation de mots spécifiques ; dans ce cas, la première lettre du premier mot est en minuscules et si le nom a plusieurs mots, les mots suivants commencent par une majuscule (par exemple, firstName et lastName). D'autres conventions existent telles que snake case (par exemple, first_name, last_name), kebab case (par exemple, first-name, last-name) et Pascal case (par exemple, FirstName, LastName).

Lorsqu'un programme est compilé, le compilateur alloue un emplacement mémoire pour contenir les valeurs des variables et réserve la quantité de mémoire nécessaire pour contenir cette valeur en fonction du type de données de la variable. Les adresses des emplacements mémoire que le compilateur affecte aux variables sont relocalisables, ce qui signifie que l'éditeur de liens (linker) peut modifier ces adresses lors de la création de la version exécutable du programme, et le chargeur de programme les modifiera également lors de l'exécution du programme pour correspondre aux adresses mémoire réelles dans la mémoire machine. La Figure 7.11 illustre à quoi cela ressemble.

Figure 7.11 En JavaScript, la variable, dans ce cas myNumber, a une valeur qui est affectée à une adresse mémoire. (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)

Constantes nommées

Une variable peut contenir des valeurs différentes, dans les limites des restrictions de type de données du langage, à divers moments de l'exécution du programme. Il y a des moments où nous souhaiterions qu'une valeur soit affectée à un emplacement mémoire spécifique et ne pas permettre qu'elle soit modifiée par la suite. La plupart des HLL modernes et des DLL (bibliothèques de liens dynamiques) associées fournissent une construction à cet effet appelée constante nommée (named constant). C'est également une bonne pratique dans la plupart des cultures de langage d'utiliser des majuscules avec des traits de soulignement séparant plusieurs mots. L'instruction suivante en C++ crée une constante nommée :

const int PAY_RATE = 15;

Le mot const est un mot-clé, int est un type de données entier C++ suivi du nom de la constante, égal (=) est l'opérateur d'affectation suivi de la rvaleur, et l'instruction se termine par un terminateur. C'est une bonne pratique en programmation d'utiliser des constantes nommées chaque fois que cela est indiqué et possible. Dans cet exemple, si le taux de rémunération d'un employé devait changer, il n'aurait à être modifié qu'à un seul endroit dans le programme plutôt que d'avoir à localiser ses utilisations dans de nombreuses lignes de code.

Opérateurs

Tout comme en algèbre, un opérateur (operator) dans les HLL effectue divers types d'opérations (processus) sur des valeurs. Différents HLL peuvent prendre en charge les opérateurs différemment. Quelques exemples des types d'opérations par lesquelles les valeurs peuvent être manipulées sont les opérateurs arithmétiques (mathématiques), les opérateurs relationnels (comparaison), les opérateurs logiques et les opérateurs de chaînes (séquences de caractères). Ils effectuent ces opérations au sein d'expressions du langage. Pour rappel, une expression (expression) est une construction dans un langage de programmation qui évalue à une valeur. Les opérateurs peuvent agir sur différents nombres d'opérandes, généralement un (un opérateur unaire (unary operator)), deux (un opérateur binaire) ou trois (un opérateur ternaire (ternary operator)). Les opérateurs fonctionnent selon certaines règles qui dictent l'ordre des opérations, ou précédence. Bien que de nombreux HLL utilisent les mêmes opérateurs, lors de l'apprentissage d'un nouveau langage, il est nécessaire de rechercher ses opérateurs pour identifier les très rares exceptions.

Documentation et commentaires

Tous les langages de programmation permettent à un programmeur de documenter son code pour améliorer la lisibilité du code. C'est une bonne pratique (best practice) en programmation et un candidat à un emploi potentiel pourrait ne pas obtenir un poste sans démontrer des compétences en documentation.

La documentation est réalisée en utilisant une structure appelée commentaire (comment), un conteneur utilisé pour contenir la documentation dans le code. Un commentaire commence par un symbole ou un ensemble de symboles définis du langage, suivi du texte du commentaire lui-même. Les commentaires peuvent être sur une seule ligne ou sur plusieurs lignes selon le symbole utilisé. Les symboles de commentaire sur une seule ligne indiquent que tout ce qui suit sur la ligne est ignoré par le compilateur (compiler) ou l'interpréteur. Les commentaires multilignes ont un symbole ou un ensemble de symboles d'ouverture et de fermeture. Les exemples sont les suivants :

// commentaire sur une seule ligne en C#
int myAge = 21;
int myAge = 21; // un autre commentaire sur une seule ligne en C#
/* ceci est un commentaire multiligne en JavaScript
myAge sera utilisé pour contenir l'âge d'un étudiant
*/
int myAge = 21;

D'autres langages peuvent utiliser une syntaxe différente pour les commentaires ; en Python, le symbole est le signe dièse (#). En BASIC, c'est le mot-clé REM, qui est l'abréviation de « remark ».

Exécution séquentielle

L'exécution des instructions dans l'ordre où elles apparaissent, l'exécution séquentielle (sequential execution), est un ordonnancement linéaire des instructions dans lequel une instruction suit directement une autre. C'est le flux de contrôle par défaut ; il est automatique. Un exemple d'exécution séquentielle serait le suivant :

int myAge = 35;
String myName = "Johnathan";
boolean isStudent = true;

Ces instructions s'exécuteront une par une dans l'ordre dans lequel elles sont écrites.

Un bloc de code (code block) est une instruction qui consiste en une ou plusieurs instructions structurées en un groupe séquentiel et délimitées comme telles. Cela est nécessaire pour qu'un groupe entier de commandes puisse être exécuté comme une seule structure séquentielle. Dans les langages de type C, les accolades ouvrantes et fermantes ({ }) sont généralement utilisées pour dénoter le début et la fin d'un bloc de code. Nous pouvons modifier l'exemple précédent en un bloc de code comme suit en Java :

{
   int myAge = 18;
   String myName = "Johnathan";
   boolean isStudent = true;
}

Notez que les variables définies dans les blocs de code n'existent que dans le contexte de ce bloc de code, ce qui permet de gérer la portée des variables dans le code plus précisément. C'est une bonne pratique en programmation d'indenter le code contenu dans les structures afin que le code soit à la fois lisible et maintenable.

Sélection

La prise de décision en programmation est appelée sélection (selection). Une construction de prise de décision nous permet de choisir parmi un ou plusieurs chemins d'exécution dans un programme. Pour voir comment elles fonctionnent, il faut comprendre le concept d'expressions conditionnelles.

Instructions de sélection

La forme la plus simple d'instruction de sélection est une structure de décision connue sous le nom de branche unidirectionnelle, comme affiché dans la Figure 7.12. La plupart des langages représentent une instruction de sélection qui est une branche unidirectionnelle avec une construction connue sous le nom d'instruction if. D'autres langages peuvent utiliser une syntaxe légèrement différente. En Java, une instruction if relativement simple utilisant un bloc de code ressemble à ceci (il est recommandé d'utiliser des blocs de code pour les instructions de sélection sur une seule ligne afin d'éviter des erreurs ultérieures si d'autres instructions sont ajoutées) :

short temp = 90;
(…)
if (temp >= 95) {
   System.out.println("It is hot");
}

Figure 7.12 Ce diagramme d'activités du langage de modélisation unifié (UML) représente une instruction de sélection qui est une branche unidirectionnelle. (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)

Le seul type d'instruction conditionnelle dont un langage a besoin est la simple branche unidirectionnelle et n'importe quel nombre d'entre elles peut être placé dans un ordre séquentiel pour exécuter n'importe quelle tâche de prise de décision. Cependant, une variété de structures de décision ont évolué en différentes variantes qui rendent les programmes plus faciles à coder, plus lisibles et plus maintenables. Sa logique est présentée dans la Figure 7.13.

Figure 7.13 Un diagramme d'activités du langage de modélisation unifié (UML) représentant une instruction de sélection qui est une branche bidirectionnelle. (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)

En Java, cela pourrait être codé avec une branche bidirectionnelle utilisant une instruction if…else :

int myNumber = 4;
if (myNumber % 2 == 0)
{
   System.out.println("The number is even.");
}
else
{
   System.out.println("The number is odd.");
}

Parfois, les décisions peuvent entraîner trois chemins possibles ou plus. Dans les langages de type C, cette situation pourrait être codée avec une branche multi-directionnelle utilisant une instruction if…else…if :

if (myGrade >= 90)
{
   System.out.println("You got an A.");
}
else if (myGrade >= 80)
{
   System.out.println("You got a B.");
}
else if (myGrade >= 70)
{
   System.out.println("You got a C.");
}
else
{
   System.out.println("You need to work harder.");
}

De nombreux langages de programmation ont employé une instruction de sélection supplémentaire pour les moments où les décisions entraînent trois chemins possibles ou plus. C'est ce qu'on appelle une instruction switch ou case, et elle peut être beaucoup plus lisible et maintenable que de nombreuses instructions if enchaînées. Cela ressemble à ce qui suit :

switch (myGrade)
{
   case 90: System.out.println("You got an A.");
   break;
   case 80: System.out.println("You got a B.");
   break;
   default: System.out.println("You need to work harder.");
   break;
}

Itération

Également connu sous le nom de bouclage, l'itération (iteration) consiste à répéter et à ré-exécuter des séquences d'instructions. L'une des grandes forces des ordinateurs est leur capacité à répéter des actions encore et encore. Les structures d'itération nous permettent d'écrire des instructions à répéter une seule fois, la répétition étant surveillée par des structures de flux de contrôle.

Le nombre d'itérations est contrôlé par des expressions conditionnelles, tout comme la sélection. Le type d'instructions conditionnelles utilisées pour contrôler les boucles est catégorisé comme contrôlé par condition ou contrôlé par compteur. Dans le scénario contrôlé par condition (condition-controlled), la boucle continuera à itérer jusqu'à ce qu'une condition soit remplie. Dans une situation contrôlée par compteur (count-controlled), la boucle se répète un nombre spécifique de fois.

Les structures d'itération peuvent également être catégorisées comme testées en tête ou testées en fin. Dans une boucle testée en tête (top-tested loop), une condition est définie à l'entrée du bloc de code. Si la condition est remplie, la boucle s'exécute et continuera à se répéter jusqu'à ce que la condition soit fausse. Notez que si la condition dans une boucle testée en tête n'est jamais vraie, la boucle ne s'exécutera pas du tout (par exemple, « while True: » comme test en tête d'une boucle en Python entraînera l'exécution de la boucle indéfiniment).

Dans la boucle à test en fin (bottom-tested loop), la sentinelle (sentinel), l'expression qui définit la condition à l'entrée ou à la sortie d'une boucle pour une itération continue, est à la sortie après le bloc de code. Une boucle de ce type est garantie de s'exécuter au moins une fois. La sentinelle décide si la boucle s'exécute à nouveau. Il est utile de garantir au moins une répétition d'une boucle.

Comme pour les instructions de sélection, la plupart des langages ont une variété de structures à choisir et, tout comme en sélection, il n'y en a qu'une seule qui est nécessaire pour tout type d'itération : la boucle testée en tête et contrôlée par condition. Sa logique est représentée par la Figure 7.14. Notez qu'il est supposé dans cet exemple que la variable « raining » peut changer suite à un événement externe en réaction, par exemple, à la sortie d'un capteur qui détecte la pluie et émet un rappel à un gestionnaire d'événements (non montré ici) qui change la valeur de la variable « raining » pour qu'elle soit vraie.

Figure 7.14 Ce diagramme d'activités du langage de modélisation unifié (UML) représente une boucle while. (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)

Dans la plupart des langages modernes, une boucle testée en tête est connue sous le nom de boucle while. Sa syntaxe en C# est la suivante :

Boolean happy = true;
Boolean rainin = false;
while (happy == true) 
{
   Console.out("I am happy");
   if (raining == true) // valeur de raining contrôlée par le gestionnaire d'événements 
   {
      Console.out("I am frowning");
      happy = false;
   }
}

La sentinelle dans cette boucle est la variable happy, et si cette condition reste vraie, la boucle itérera.

Ce type de boucle est non déterminatif (non determinative), une boucle pour laquelle nous ne pouvons pas prédire le nombre d'itérations (contrôlée par condition). Une boucle déterminante (determinative) qui est prévisible en ce sens que son nombre d'itérations s'exécutera exactement cinq fois et pourrait être construite en C# comme suit :

int count = 1;
while (count <= 5) 
{
   Console.out("I am smiling");
   count = count + 1;
}

Dans la plupart des langages modernes, une boucle à test en fin est connue sous le nom de boucle do…while, comme mis en évidence dans la Figure 7.15. Sa syntaxe en C# est la suivante :

Boolean happy = true;
Boolean raining = false;
do 
{
   Console.out("I am smiling");
   if (raining == true) // valeur de raining contrôlée par le gestionnaire d'événements
   {
      Console.out("I am frowning");
      happy = false;
   }
} while (happy == true)

La sentinelle dans cette boucle est toujours la variable happy ; la boucle itérera au moins une fois, et si cette condition reste vraie, la boucle continuera à itérer.

Figure 7.15 Ce diagramme d'activités du langage de modélisation unifié (UML) représente une boucle do…while. (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)

La sentinelle dans cette boucle est à nouveau la variable happy ; elle itérera au moins une fois et continuera si cette condition reste vraie. Ce type de boucle est non déterminatif car nous ne pouvons pas prédire quand il pleuvra et, par conséquent, combien de fois elle s'exécutera. Nous pourrions la construire de manière à la rendre contrôlée par compteur. Pour les boucles contrôlées par compteur, un autre style est une boucle for (for loop). Cette structure est testée en tête et contrôlée par compteur. Elle est concise, élégante, facile à maintenir et efficace. Un exemple de boucle for en PHP est le suivant :

for ($count = 1; $count <= 5; $count = $count +1) {
   print("the count is: "", $count);
}

Les règles sont les suivantes : à l'intérieur des parenthèses, la première expression est exécutée une seule fois à la première entrée de la boucle. La deuxième expression est la sentinelle et elle est testée à toutes les itérations de la boucle. La dernière expression est exécutée à la fin de chaque itération et prépare le terrain pour la prochaine itération.

Modularité

Cela fait référence à la nécessité de diviser un programme en diverses tâches. Un programme d'employés effectuerait probablement de nombreuses tâches, dont l'une pourrait être de calculer le salaire hebdomadaire. La conception modulaire nous permet de spécifier ces tâches, de les nommer et de les appeler sans le code final. Nous pouvons définir les tâches comme des fonctions et construire leur squelette sans tous les détails. Ensuite, nous pouvons les appeler depuis notre flux de contrôle principal et les faire répondre à l'appel.

Maintenabilité

Si nous devions changer la façon dont nous payons nos employés, peut-être en raison d'un changement de déductions, nous devrions changer ce code à une multitude d'endroits. En utilisant une fonction pour effectuer le travail pour tous les employés, les changements peuvent être limités à un seul endroit dans le code.

Réutilisabilité

Construire des fonctions pour effectuer des tâches signifie que nous pouvons soit réutiliser le code dans d'autres logiciels et/ou appeler le même code depuis d'autres emplacements. Une API (API) qui est livrée avec la plupart des langages est un exemple parfait. Notre code appelant la routine d'impression PHP montre l'efficacité de cela — elle ne fait pas partie du langage lui-même ; elle fait plutôt partie de l'API qui est livrée avec.

Signature de fonction

Pour construire une fonction dans un HLL, il faut définir sa signature de fonction (function signature). La signature définit une fonction et informe le compilateur (compiler) ou l'interpréteur des détails dont il a besoin pour appeler cette fonction à exécuter. Elle définit également ce qu'elle peut retourner au code qui a appelé la fonction. Ce qui suit illustre une signature de fonction en Java (dans ce cas, la fonction peut être une méthode) pour la tâche de payer un employé :

public double payEmp(String empName, double empBasePay, double empHours);

La fonction peut être appelée pour faire son travail avec le code suivant :

myPay = payEmp("John Doe", 15.0,40.0);

Le montant de la rémunération serait calculé par la fonction et la valeur résultante serait retournée au point de l'appel et placée dans la variable.

Le mot public est un mot-clé en Java qui est appelé un modificateur d'accès (access modifier) ; il indique où dans le code cette méthode peut être accédée. Dans ce cas, elle est disponible de n'importe où dans le code du programme.

Le mot-clé double indique que cette méthode retournera une valeur de ce type de données à l'endroit où la méthode a été appelée. Dans ce cas, nous voulons qu'elle retourne la rémunération totale de l'employé. En Java, si nous utilisons le mot-clé vide (void) pour le retour, cela indique au compilateur que nous ne retournerons aucune valeur.

L'identifiant payEmp est le nom que nous avons donné à la méthode. Sa syntaxe suit les mêmes règles et bonnes pratiques (best practice) que celles utilisées pour un identifiant de variable dans ce langage.

Les parenthèses indiquent qu'il s'agit d'une fonction (méthode), la distinguant ainsi d'un identifiant de variable.

Un paramètre formel (formal parameter) représente les valeurs que la fonction doit recevoir pour faire son travail. Les paramètres ne sont pas obligatoires, mais s'ils sont spécifiés, l'appel de la fonction doit leur passer des valeurs de paramètres réels dans la fonction. Ne pas le faire entraînerait une erreur de compilation qui ne permettrait pas au programme de s'exécuter. En fait, ne pas se conformer à l'un des éléments de la signature entraîne une erreur de compilation.

Appel de fonction

Un appel de fonction dans un HLL doit être conforme à la signature de fonction. Un appel Java à la fonction ressemble à ceci :

double thisSalary = payEmp(thisName, thisPayRate, thisHrs);

De gauche à droite, nous déclarons une variable thisSalary et lui affectons la valeur qui sera le retour de la fonction. Nous appelons ensuite la fonction, en passant les valeurs requises pour ses paramètres définis. Le terme argument (argument) est utilisé pour les valeurs d'un appel de fonction qui doivent correspondre aux paramètres en nombre et en type de données.

Passage de paramètres

Les paramètres sont passés en utilisant l'une des deux méthodes. Dans le passage par valeur (pass by value), une copie de la valeur est faite et la copie est passée comme argument au paramètre. Lorsqu'il rencontre le paramètre, la valeur est affectée et les valeurs de la variable originale ne peuvent pas être affectées par les changements qui peuvent survenir à l'intérieur de la fonction.

D'autre part, le passage par référence (pass by reference) est employé en Java pour passer un type de données complexe, ce qui signifie que la valeur stockée à l'intérieur de la variable est un pointeur vers l'adresse mémoire de l'objet complexe réel. La valeur copiée dans le paramètre dans ce cas donne au code l'accès à l'objet lui-même dans la portée de la fonction, de sorte que toute modification apportée à sa valeur sera reflétée dans l'objet réel qui a été passé à la fonction, comme le montre la Figure 7.16.

Figure 7.16 Comparez le passage d'un paramètre par valeur et le passage par référence en C++. (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)

Codons la fonction entière en Java pour avoir une vue complète de ses composants :

public double payEmp(String empName, double empBasePay, double empHours) {
    double empPay = empBasePay * empHours;
    System.out.println(empName + " is being paid " + empPay);
    return empPay;
}

Dans l'exemple, empBasePay et empHours sont passés par valeur de types de données primitifs. D'autre part, empName est passé par référence car la chaîne est un type de données complexe.

Pile d'appels

La pile d'appels (call stack) (pile d'exécution) est une structure de données qui contrôle l'appel et le retour des fonctions. D'autres fonctions incluent le stockage des variables locales, ce qui dicte la portée (scope), définie comme la visibilité et la durée de vie des variables. Elle contrôle également le passage de paramètres.

La description de la pile d'appels se fait généralement en la comparant à une unité de plateaux de cafétéria. Les plateaux propres sont poussés sur l'unité au fur et à mesure qu'ils arrivent et sont retirés de l'unité selon les besoins. Ce concept est connu sous le nom de dernier entré, premier sorti (LIFO). Ainsi, lorsqu'une sous-routine est appelée, elle est poussée sur la pile d'appels. Sa présence et toutes ses parties sur la pile sont appelées un cadre de pile (stack frame). Lorsqu'elle termine son exécution, elle est retirée. Le flux de contrôle du programme suit l'état actuel de la pile d'appels. Une pile d'appels est décrite dans la Figure 7.17.

Figure 7.17 Ceci est représentatif d'une pile d'appels. (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)

Dans cette implémentation, function1 est appelée en premier. Elle est poussée sur la pile au format de cadre de pile et les paramètres avec leurs valeurs sont poussés en premier, suivis par l'adresse de retour afin que le flux de contrôle puisse revenir à l'emplacement de l'appel de fonction après que le cadre de pile a été retiré de la pile. Enfin, les variables locales sont poussées sur le cadre de pile au fur et à mesure qu'elles sont définies. Dans cet exemple, function1 a appelé function2 et a été poussée sur la pile. Lorsqu'elle est retirée de la pile, le contrôle reviendra au cadre de pile de function1.

En regardant function1, nous voyons que les paramètres prennent vie lorsque la fonction est poussée sur la pile et disparaissent lorsque la fonction est retirée de la pile. La même chose est vraie pour toutes les variables locales déclarées dans la fonction. C'est une illustration de la portée d'une variable qui contrôle à la fois la visibilité et la durée de vie d'une variable (c'est-à-dire qu'une variable locale à une fonction n'est visible que dans la portée de cette fonction pendant la durée d'exécution de cette fonction). Cette portée est locale car la visibilité et la durée de vie sont locales à la fonction ; elles n'existent pas et ne peuvent pas être vues d'ailleurs dans le programme.

Récursivité

La récursivité est la séquence dans laquelle une fonction s'appelle elle-même. Si une fonction s'appelle elle-même, alors la prochaine instance de la fonction s'appellera également elle-même. Cela continue indéfiniment jusqu'à ce que la pile d'appels manque de mémoire, à moins qu'il n'y ait un moyen au sein de la fonction d'arrêter le processus (process). Cette condition est connue sous le nom de débordement de pile (stack overflow).

Certains problèmes ou tâches que nous voulons qu'un programme aborde se prêtent à la récursivité, comme avec un lancement de fusée. Si nous voulons programmer l'affichage d'une séquence de compte à rebours pour le lancement, nous pouvons le faire de manière récursive. La signature, connue sous le nom de prototype en C++, pourrait ressembler à ceci :

void countDown(long);

Comme indiqué par le void, la fonction ne retournera rien à son point d'appel. Elle a un paramètre qui représente le point de départ du compte à rebours. Par conséquent, si nous voulons commencer le compte à rebours à 100, l'appel ressemblera à ceci :

countDown(100);

La construction de la fonction récursive pourrait se faire comme suit :

void countDown(long count) {
   if (count < 0)
   {
      return;
   }
   cout << count << endl;
   count = count - 1;
   countDown(count);
}