Paradigme – L’impératif

La programmation impérative est un style de programmation qui consiste à fournir une séquence d’instructions qui vont être exécutées les unes à la suite des autres et qui vont par ce biais entraîner la modification de l’état du programme. Ce style de programmation est celui qui est à l’heure actuelle le plus commun, sûrement pour deux raisons :

  • Il est très intuitif et accessible à l’homme car il représente la manière classique d’exécuter une tâche dans la réalité (la réalisation d’une recette de cuisine par exemple).
  • Les processeurs des ordinateurs actuels fonctionnent principalement sur le principe d’exécution de suite d’instructions et sur la modification de l’état de la machine (état de la mémoire, état du programme).

Le langage impératif de plus bas niveau est l’assembleur.

Exemple concret

J’aimerais présenter ce petit cas de figure qui montre que nous sommes tous susceptibles d’exécuter des tâches comparables à de la programmation impérative un jour ou l’autre dans notre vie.

Le problème

J’aimerais envoyer une boite de dix biscuits à chacun de mes amis pour Noël. J’ai dix amis au total et pour « simplifier », on va considérer qu’ils s’appellent tous Jack.

État du programme au départ

  • 10 Boites
  • 10×10 = 100 Biscuits

Instructions du programme

  1. Je prend une boite (j’en retire donc une du total)
  2. Je l’ouvre et je met 10 biscuit dedans (j’en retire donc 10)
  3. Je l’envoie à mon ami Jack
  4. Je répète l’opération tant qu’il reste assez de boîtes et assez de biscuits.

Avec l’exemple ci-dessus on visualise, je l’espère, comment fonctionne la programmation impérative. On effectue une liste d’actions qui vont modifier l’état du programme tout au long de son exécution. Ici le nombre de boites et de biscuits vont décrémenter par pas de 10 et le nombre de boites par pas de 1 à chaque répétition de l’opération.

Instructions impératives

On trouve quatre types principaux d’instructions impératives.

La séquence d’instruction

La séquence d’instruction est tout simplement une suite d’instructions exécutées les unes à la suite des autres.

Javascript

console.log('Bonjour');
console.log('Au revoir');

C++

printf("Bonjour");
printf("Au revoir");

Il s’agit d’une séquence de deux instructions traitées l’une après l’autre. En programmation impérative, l’ordre dans lequel les instructions sont écrites est très important car il s’agira de l’ordre d’exécution, ce qui n’est pas forcément le cas lors d’un traitement parallèle par exemple.

L’affectation

L’affectation est une instruction classique et centrale du paradigme impératif. Elle va permettre d’associer une valeur à une variable, c’est cette instruction qui va permettre la modification de l’état du programme.

Javascript

var a = 10;
a = a + 1;

C++

int a = 10 ;
a += a + 1 ;

Les branchements conditionnels

Les branchements conditionnels permettent d’exécuter une séquence d’instruction ou une autre selon le résultat d’une condition.

En javascript, C et C ++ :
if (10 == 10) {
    console.log('normal'); // Ou printf pour C/C++
} else {
    console.log('bizarre...'); // Ou printf pour C/C++
}

Les boucles

Les boucles permettent d’effectuer une séquence d’instruction tant qu’une condition n’a pas été vérifiée.

Javascript / C++

var i = 0; // Ou int à la place de var pour C++

while (true) {
    console.log(i); // Ou printf pour C++
    i++;
}

ou encore

Javascript / C++

for (var i = 0 ; i < 10 ; i++) // ou int à la place de var pour C/C++
    console.log(i) ; // Ou printf pour C/C+

Les sauts

Goto ! Les sauts permettent de transférer l’exécution d’un point à un autre du programme. Il s’agit de l’instruction goto mais concerne aussi l’instruction break qui permet de quitter une boucle – éventuellement avec une étiquette – ou encore les appels aux fonctions, méthodes, sous programmes, modules, etc… Ils sont donc essentiels à la programmation procédurale dont nous parlerons tout à l’heure.

Un point important du paradigme impératif

Ce paradigme autorise la mutabilité des variables (leur modification) et les effets de bords, le fait qu’une portion de code puisse avoir un comportement différent lorsqu’elle appelée à un moment différent ou dans un contexte différent.

Mutabilité

Le paradigme impératif étant basé sur les changements d’états autorise la modification des variables, on parle de mutabilité. Cela peut paraitre évident si vous avez l’habitude de la programmation impérative objet, mais sachez que certains langages n’acceptent pas la mutabilité des variables, c’est le cas de certains langages fonctionnels purs tel que Haskell. Mutabilité est un terme très large qui correspond dans notre exemple au fait qu’une valeur associée à un symbole donné peut-être modifié.

Exemple

C#

var a = 0;
a += 1;

L’opération ci-dessus est autorisée en programmation impérative mais proscrite dans un langage fonctionnel pur.

Effets de bords

En programmation impérative rien n’interdit l’introduction et l’utilisation des effets de bords, vous savez, le truc qui généralement fou le bazar dans vos programmes ! En fait à partir du moment ou un programme accepte la modification de son état, il peut être soumis aux effets de bords. Les effets de bords se manifestent par le fait que l’exécution de deux portions de code identiques peuvent avoir un comportement différent selon le moment où elles sont utilisées et l’état général du programme ou du système à cet instant.

Cela est du au fait qu’une variable utilisée au sein d’un processus peut être modifiée par un autre processus. Les effets de bords ne sont pas forcément négatifs, en fait ils sont même utilisé dans des tâches basiques tel que la lecture d’un fichier – pensez au readline – ou encore la fonction random, etc.

Exemple du readline

C#

while ((var line = streamReader.ReadLine()) != null)
{
    Console.WriteLine(line);
}

Vous remarquerez que la fonction readline ne renvoie pas le même résultat à chaque appel, en effet, elle nous donne à chaque appel la ligne suivante si elle existe. Cette fonction utilise les effets de bords.

Exemple de random

C#

var random = new Random();
var a = random.Next();
var b = random.Next();
...

La fonction random est une fonction à effet de bord : a chaque appel de la fonction, on obtiendra un nombre différent. Cela parce que cette fonction est basée soit sur un générateur utilisant des variables basées sur un état du système constament modifié (par exemple l’heure) ou soit sur une variable interne qui permet de contrôler la position dans un flux de nombres pseudo-aléatoire générés en amont.

Les fonctions que l’on peut définir avec le paradigme impératif ne sont pas forcément des fonctions mathématiques au sens propre du terme. Une fonction mathématique est déterminée, pour des paramètres d’entrée X le résultat de sortie sera toujours Y. Pour un langage impératif rien n’interdit que ce principe soit violé.

C’est principalement par la mutabilité des variables et les effets de bords que le paradigme impératif se distingue du paradigme fonctionnel ou logique.

One thought on “Paradigme – L’impératif”

Laisser un commentaire

%d blogueurs aiment cette page :