ALGORITHMIQUE ET PROGRAMMATION EN C

Transcription

1 ALGORITHMIQUE ET PROGRAMMATION EN C Pierre Tellier 17/05/2006 Département d'informatique de l'université Louis Pasteur, 7 rue René Descartes, F67084 STRASBOURG CEDEX, tellier@dpt-info.u-strasbg.fr, Tel : +33 (0)

2 Algorithmique et programmation en C Page 2 Pierre Tellier Table des matières Table des matières... 2 Premiers programmes... 4 Objets : types, constantes,... 4 Objets élémentaires... 4 Objets élémentaires en C... 4 Expressions... 4 Identificateurs... 6 Constantes... 6 Variables... 7 Expressions avec des et des constantes... 7 Exécution : la séquentialité... 7 Séquentialité... 7 Affectation... 8 Entrées/sorties : écriture et lecture... 9 Premiers programmes Remarques Analyse descendante Fonctions Fonctions avec paramètres et résultat Fonctions sans résultat : procédures Fonctions et procédures sans paramètres Fonctions avec plusieurs résultats Résultat n-uplet Les structures en C Paramètres modifiables (passage par adresse) en C Variables et portée des Variables locales, globales Variables statiques et automatiques en C Fonctions en paramètre de fonctions Exemples de programmes avec des fonctions Volume de l'écrou Calcul de la durée Langage C : arguments de main Langage C : nombre quelconque de paramètres Conditionnelle Quelques exemples La deuxième pizza à moitié prix Équation du second degré Autres exemples simples Macros en C Condition et opérations Booléennes Quelques exemples portant sur la conditionnelle Calcul du temps de parcours Calcul simplifié de l'impôt sur le revenu Énumération des cas Syntaxe Calcul de la position d'un jour dans l'année : quantième...37 Itération et récursivité Itérations et conditions d'arrêt faire N fois Répétition d'un calcul Itérations et conditions d'arrêt Itérations et compteurs Récursivité Cas naturels Compteurs Moyenne d'une série de nombres Répétition d'un calcul... 53

3 Algorithmique et programmation en C Page 3 Pierre Tellier Itération et récursivité Exemples simples Calcul de l'intégrale par la somme de Riemann Tableau d'amortissement du remboursement d'un emprunt Calcul du jour dans l'année : quantième Récursivité croisée Tableaux statiques 1D Opérations élémentaires sur les tableaux Application : les ensembles Tri de tableaux Tableaux à trous... 74

4 Algorithmique et programmation en C Page 4 Pierre Tellier Premiers programmes Objets : types, constantes, Objets élémentaires Nombres entiers (relatifs) : on les note sous la forme habituelle, soit une suite de chiffres : 26, Nombres réels : Leur notation est elle aussi classique, identique à celle qu'on utilise pour les machines à calculer. Le séparateur décimal est le point. On peut également écrire les réels en notation scientifique : 2.7, 3.14, 2.0, Caractères : On les note entre apostrophes comme par exemple 'A' (caractère A), 'a' (caractère a), '0' (caractère 0), ',' (caractère virgule) etc. Les caractères spéciaux peuvent être désignés directement par leur symbole : ENTER (retour chariot), TAB (tabulation), BEEP (son) etc. Chaînes de caractères : Ce sont des suites de caractères délimitées par des guillemets. On procède comme cela dans la plupart des langages. Exemples : "oui", "bonjour", "ceci", "ceci est une chaîne". Booléens : Ce sont des objets particuliers qui peuvent prendre uniquement 2 valeurs : VRAI ou FAUX. Objets élémentaires en C Nombres entiers (relatifs) : En langage C, on a en plus la possibilité de noter les entiers sous forme hexadécimale (base 16) : 0x12 vaut 18 (1*16+2), 0x2A vaut 42 (2*16+10), ou octale (base 8) : 012 vaut 10 (1*8+2). Nombres réels : En langage C on utilise aussi la notation classique. Exemples : 12.38, 0.15,.15, 2.0, 2., -3.17, 1.e3, 0.1e-2, E19. Caractères : En C les caractères sont aussi notés entre apostrophes : 'a', 'Z', '?' etc. Les caractères spéciaux peuvent être désignés directement par leur symbole : ('\n' (retour chariot), '\t' (tabulation) etc.), ou par leur code ASCII, '\007' en octal ou '\x07' en hexadécimal (caractère de code ASCII 7 = bip), '7' (caractère 7). En fait, au niveau de la machine (et du langage C), chaque caractère correspond à un code (ASCII), ainsi 'A' correspond au code ASCII 65, 'a' au code ASCII 97, '0' au code ASCII 48, ',' au code ASCII 44, '\n' au code ASCII 10 etc. Chaînes de caractères : Exemples : "oui", "bonjour", "ceci", "ceci est une chaîne". Booléens : Attention, de tels objets n'existent pas explicitement en C, mais existent dans de nombreux autres langages de programmation. En principe, on attribue la valeur entière 0 pour FAUX et 1 pour VRAI. Expressions Le but étant de réaliser des calculs qui font intervenir les objets décrits précédemment, nous allons les combiner pour créer des expressions à l'aide d'opérateurs. Là encore, la notation est proche de la notation usuelle des mathématiques ou des calculettes. Opérateurs arithmétiques addition +, soustraction -, moins (unaire) -, multiplication *, division /, division entière div, modulo (reste de la division entière) mod. Booléens ET, OU, NON. de comparaison = (égal), <> (différent), <, >, <=, >=. Opérateurs en langage C arithmétiques +, - (unaire et binaire), *, / (entière, réelle), % (modulo), incrémentation ++ (augmente la valeur de 1), décrémentation -- (diminue la valeur de 1), accumulations : -=, +=, /=, *= (des explications sur ces notations seront fournies plus loin). Booléens && (ET), (OU),! (NON)

5 Algorithmique et programmation en C Page 5 Pierre Tellier de comparaison == (égal),!= (différent), <, >, <=, >=. Ces opérateurs ne s'appliquent pas aux chaînes de caractères en C. sur les bits (OU bit à bit), & (ET bit à bit), << (décalage à gauche), >> (à droite), ^ (ou exclusif bit à bit), ~ (inversion = NON bit à bit). Expressions arithmétiques La formulation des expressions arithmétiques est elle aussi similaire à la notation mathématique : * mod 2 7 div 2 (vaut 3 : division entière) 7 / 2 (vaut 3.5 : division réelle) 0.3 * ( )/5. Expressions arithmétiques en langage C * % 2 7 / 2 (vaut 3 : division entière) 7. / 2. (vaut 3.5 : division réelle) (0.3 * 168.2)+(( )/5.) 31 >> 4 (vaut 1 : on supprime les 4 derniers bits) Attention aux mélanges de types dans les expressions (certains langages comme le Caml les ont tout simplement interdits), et aux parenthèses. On peut mélanger les types, il existe des règles de conversion par défaut. On peut aussi ne pas mettre de parenthèses et dans ce cas des règles de priorité sont appliquées. Dans le doute, il vaut mieux mettre toutes les parenthèses nécessaires et convertir toutes les valeurs dans le même type. Expressions Booléennes 3<2 vaut FAUX. (3<2) ET (6=5). Comme (3<2) vaut FAUX, l'expression (FAUX ET quelque chose) donnera forcément FAUX. (3>2) OU (6=5). Comme (3>2) vaut VRAI, l'expression (VRAI OU quelque chose) donnera forcément VRAI. Expressions Booléennes en C : ordre d'évaluation En C, l'évaluation d'une expression n'est effectuée que si elle est nécessaire à l'obtention du résultat. 3<2. L'expression est fausse et vaut 0. (3<2)&&(6==5). Comme (3<2) est FAUX, l'expression (FAUX ET quelque chose) donnera forcément FAUX. L'expression (6==5) n'est pas évaluée. (3>2) (6==5). Comme (3>2) est VRAI, l'expression (VRAI OU quelque chose) donnera forcément VRAI. L'expression (6==5) n'est pas évaluée. Expressions arithmético-booléennes en langage C Ceci est propre au langage C, qui ne possède pas de véritable type Booléen. Une expression Booléenne valant VRAI prend la valeur 1 dans une expression arithmétique, et 0 si elle vaut FAUX. Une expression arithmétique qui vaut 0 est considérée comme valant FAUX dans une expression Booléenne, alors qu'elle est considérée à VRAI pour toute autre valeur. (3<4)*(1+((2+3)==5)) vaut (1)*(1+(1)) soit 2. (3 (4<3)4)) vaut 3 0 donc VRAI OU FAUX, donc VRAI soit 1.

6 Algorithmique et programmation en C Page 6 Pierre Tellier Les types en C Entiers On peut décrire les types entiers du langage C à l'aide de la règle suivante : [signed unsigned] [short long] [int] En pratique, les types entiers couramment utilisés sont : int : entiers signés sur 4 octets (de à ). unsigned int : entiers positifs sur 4 octets (de 0 à ). short : entiers signés sur 2 octets (de à ). unsigned short : entiers positifs sur 2 octets (de 0 à ). On utilise aussi parfois le type char pour coder les petits entiers : char : entiers signés sur 1 octet (de -2 7 à 2 7-1). unsigned char : entiers positifs sur 1 octet (de 0 à 2 8-1). Booléen Le type Booléen n'existe pas en C, en tout cas pas explicitement, mais peut être obtenu à l'aide des entiers : en effet, une expression Booléenne vaut 0 si elle vaut FAUX, 1 si elle vaut VRAI, et le langage C interprète la valeur 0 comme valant FAUX, et toute autre valeur comme valant VRAI. Ainsi l'expression (3<4) aura la valeur entière 1 car cette inégalité vaut VRAI. Réels float : nombres réels sur 4 octets. double (double précision) : nombres réels sur 8 octets. Caractère char Chaîne de caractères char[longueur + 1] où longueur est la longueur des plus grands mots qu'on veut pouvoir représenter. Identificateurs Ils permettent de donner des noms à des objets : constantes, ou fonctions pour les désigner plus facilement. Ce sont des noms, i.e. une suite "presque" quelconque de caractères, comme fact, pgcd, produit, somme, etc. Les identificateurs ne doivent pas commencer par un chiffre et doivent être choisis de la façon la plus parlante possible. Dans tous les langages, certains identificateurs sont réservés. Ainsi en C il existe quelques identificateurs qui désignent des fonctions prédéies, par exemple : printf (affichage), sqrt (racine carrée) etc. Constantes Ce sont des objets auxquels on donne des noms et dont on ne voudra modifier la valeur sous aucun prétexte. Par exemple, il est courant d'utiliser une constante qu'on peut nommer Pi pour désigner la valeur de π, ce qui évite une écriture fastidieuse de sa valeur décimale à chaque utilisation : constantes réel Pi vaut ; réel courseuro vaut ; entier nbcôtésducarré vaut 4; L'utilisation des constantes est primordiale, elle permet de modifier la dimension d'un problème et de son traitement avec un minimum de manipulations. En principe, la simple mise à jour des constantes suffit. Constantes en langage C En langage C il existe 2 manières de procéder. Avec const. On peut nommer une constante à l'aide du mot-clé const du langage C que l'on fait suivre du type de la constante puis de son nom et de la valeur associée, comme le montrent les exemples suivants : const float Pi= ; const float courseuro= ; const int NbCotesDuCarre=4; Pour les apprentis hackers, on peut faire remarquer qu'il existe des moyens de modifier la valeur des constantes déclarées de cette façon (voir le chapitre sur les pointeurs...). Avec #dee. L'autre façon de procéder est différente, puisqu'il ne s'agit pas à proprement parler d'une déclaration de constante, mais d'une déition. Il s'agit d'un mécanisme de réécriture (géré par le préprocesseur C) qui permet de remplacer directement le nom d'une constante par le texte associé sans engendrer la création d'un objet. Par exemple, la déition de la constante π peut se faire ainsi : #dee PI Chaque occurrence du mot PI dans le programme sera remplacée par le texte associé Nous verrons par la suite que ce mécanisme de déition peut servir à de nombreuses autres choses, mais que son utilisation est assez délicate pour la mise au point des

7 Algorithmique et programmation en C Page 7 Pierre Tellier programmes. D'autre part, nous recommandons l'usage de majuscules pour toutes les déitions (et uniquement pour les déitions). Variables Déclaration Ce sont des objets auxquels on donne des noms (identificateurs). Leur usage est fréquent dans la résolution de problèmes, en particulier pour poser des résultats intermédiaires. Ces objets sont des objets informatiques, chacun d'eux nécessite un emplacement dans la mémoire de l'ordinateur. La déclaration d'une variable permet de réserver dans cette mémoire un emplacement dont la taille est fonction du type. Ce type permet aussi de savoir comment il faudra utiliser l'information contenue dans cet emplacement. C'est pourquoi il est nécessaire de déclarer toute variable avant son utilisation. Une déclaration se termine par le symbole ";". Il est possible de déclarer plusieurs du même type en même temps, il suffit de les séparer par une virgule ",". entier nombreetudiants; entier age, nombrefrèresetsoeurs, taillefamille; réel rayon; réel a, b, c; Les mêmes déclarations en langage C : int nombreetudiants; int age, nombrefreresetsoeurs, taillefamille; float rayon; float a, b, c; Initialisation Il est possible de donner une valeur (que l'on pourra éventuellement modifier par la suite) à une variable dès sa déclaration. On parle alors d'initialisation, que l'on pratique comme suit : entier nombreetudiants init 20; entier age, nombrefrèresetsoeurs init 0, taillefamille init 3; réel rayon init -1.0, pisur2 init pi/2.0; Les mêmes déclarations en langage C : int nombreetudiants = 20; int age, nombrefreresetsoeurs=0, taillefamille=3; float rayon=-1.0, pisur2=pi/2.0; Expressions avec des et des constantes Elles s'écrivent exactement de la même manière que les expressions faisant intervenir des valeurs, mais font intervenir un ou plusieurs identificateurs : nombrefrèresetsoeurs * Pi * rayon Pi * rayon * rayon ou en C nombrefreresetsoeurs * Pi * rayon PI * rayon * rayon Exécution : la séquentialité Séquentialité Par la suite, nous étudierons les stratégies qui permettent de résoudre des problèmes à l'aide de programmes. Sans anticiper, nous pouvons dévoiler que la solution passera par le découpage du problème en sous-problèmes suffisamment simples (non décomposables) pour être résolus à l'aide de traitements élémentaires : les instructions, qui seront exécutées en séquence, les unes après les autres. Ces instructions sont séparées par un délimiteur syntaxique, le point-virgule ";" qui indique la d'une instruction et donc qu'il est possible de passer à la suivante. Il s'agit de la séquentialité.

8 Algorithmique et programmation en C Page 8 Pierre Tellier Cette syntaxe est retenue par de nombreux langages, en particulier le C. Certains se contentent de la de ligne, d'autres au contraire exigent deux points-virgules consécutifs. Il existe en C un autre séparateur d'instructions qui est la virgule (","). Il s'agit de l'opérateur de colatéralité : deux instructions séparées par une virgule peuvent être exécutées dans un ordre quelconque et pourquoi pas en même temps si cela est possible. Affectation Pour utiliser une variable dans une expression, il est nécessaire de lui donner une valeur. Cette opération s'appelle l'affectation, qui consiste à ranger une valeur (le résultat d'une expression) dans l'emplacement mémoire occupé par une variable. Nous utiliserons, comme en langage Pascal, le symbole := pour décrire cette opération. rayon := 5.0; nombrefrèresetsoeurs := 4; taillefamille:=nombrefrèresetsoeurs+1+2; Vous aurez compris que l'initialisation n'est qu'un raccourci qui permet de regrouper en une seule ligne déclaration et première affectation. Affectation en C En C, c'est le symbole "=" qui permet cette opération. Attention à ne pas se mélanger avec l'opérateur de comparaison "=="! rayon = 5.0; nombrefreresetsoeurs=4; taillefamille=nombrefreresetsoeurs+1+2; a=b=1.0; En C, toute affectation a une valeur, la valeur affectée. Ainsi l'expression b=1.0; vaut 1.0, et peut être affectée à a. Notion de variable informatique Comme nous l'avons dit, une variable informatique est conditionnée par l'emplacement mémoire qu'elle occupe. L'affectation a pour effet de modifier le contenu de cette mémoire. En informatique, il est possible d'écrire des expressions comme x := x*2; qui signifie : ranger dans la variable x son ancien contenu multiplié par 2. En fait une affectation se passe en 2 temps. D'abord l'expression en partie droite est évaluée, ce qui suppose que toutes les ont une valeur connue, et seulement ensuite le résultat de cette expression est affecté à la variable en partie gauche. Il n'est donc pas choquant ni faux de trouver en partie droite la variable qui se trouve aussi en partie gauche. La différence est qu'en partie droite on utilise l'ancienne valeur, le résultat de l'expression devient alors la nouvelle valeur. En C on peut aussi écrire de telles expressions, des opérateurs spéciaux ont même été prévus pour les accumulations : on peut remplacer toute expression x = x op v; où op est +, -, * ou / par x op= v;. Par exemple, x = 2*x; peut s'écrire x *= 2;. Le langage C est même allé plus loin, en offrant des opérateurs d'incrémentation et de décrémentation : i=i+1; peut s'écrire i+=1; ou bien i++; ou encore ++i;. Si l'incrémentation (ou la décrémentation) apparaît dans une expression, utiliser i++; provoque l'incrémentation après que la valeur de i ait été utilisée, alors qu'utiliser ++i; la provoque avant, comme le montre l'exemple suivant : int i,j,k,l; i = 3; j = 2*i++; k = 2*i; l = 2*++i; Après exécution, j vaudra 6 (la valeur de i utilisée est 3, puis i passe à 4), k vaut 8 (i vaut 4 puisqu'il a été incrémenté). En, l vaut 10 car i est d'abord incrémenté avant d'être multiplié par 2. L'opérateur de décrémentation (--) fonctionne de la même façon. La raison de l'existence de ces opérateurs est historique : les anciens compilateurs, peu performants, n'étaient pas capables de détecter une accumulation, et donc de la traduire en utilisant au mieux le jeu d'instructions du processeur cible. Ce n'est bien sûr plus le cas aujourd'hui, néanmoins on trouve encore abondamment ce genre d'écriture, même dans les programmes écrits de nos jours. Échanger le contenu de 2 montre bien la connotation physique de la notion de variable informatique. Pour bien comprendre, pensez à 2 verres d'eau dont on veut échanger les contenus. Il faut passer par un troisième verre. Il en est de même pour les :

9 Algorithmique et programmation en C Page 9 Pierre Tellier entier a init 1, b init 2; entier tmp; tmp := a; a := b; b := tmp; A la de cette exécution, a vaudra 2, et b vaudra 1. Le même programme, cette fois en langage C : int a = 1, b = 2, tmp; tmp = a; a = b; b = tmp; Entrées/sorties : écriture et lecture Les sont destinées à contenir des valeurs elles mêmes réutilisables dans d'autres expressions. Mais ceci n'a d'intérêt que si à un moment ou un autre il est possible de connaître ces valeurs, ou de donner de manière interactive une valeur à une variable, car l'intérêt des programmes est de pouvoir exécuter un même traitement sur des données différentes. Cela est rendu possible grâce à l'usage des. Néanmoins, il est fastidieux et peu interactif de devoir corriger un programme à chaque fois que l'on désire modifier la valeur d'une variable. On dispose pour remédier à cela de mécanismes permettant la modification des grâce à la lecture de valeurs au clavier, et permettant l'affichage de leur valeur à l'écran. Ceci est réalisé par les fonctions d'entrée sortie : variable:=lire() et afficher(expression). La fonction lire attend la saisie (au clavier) d'une valeur, et une fois que celle-ci est tapée, puis suivie de la touche ENTER, la valeur est transmise à la variable. Au contraire, la fonction affiche provoque un affichage à l'écran de la valeur de la variable. On pourra utiliser cette dernière avec plusieurs données en même temps, l'affichage des différentes données sera alors fait les unes à la suite des autres. Comme exemple, on cherche à réaliser un programme qui fait la somme de 2 nombres entiers (ce que fait très bien une calculatrice). Pour cela on devra entrer 2 valeurs, et on souhaite, après la saisie de la deuxième, que le résultat s'affiche. entier x, y, z; x := lire(); y := lire(); z := x+y; afficher(z); Remarque. On aurait pu se passer de la variable z, et écrire à la place : entier x, y; x := lire(); y := lire(); afficher(x+y); Ce programme peut fonctionner, mais il est peu bavard et ne renseigne pas l'utilisateur sur sa conduite à tenir. Pour cela, il est nécessaire d'agrémenter le déroulement du programme de messages qui aident à son utilisation. Voici par exemple comment on pourrait procéder : entier x, y, z; afficher("somme de 2 valeurs "); afficher("entrez la 1ere valeur "); x := lire(); afficher("entrez la 2eme valeur "); y := lire(); z := x+y; afficher("la somme vaut : ", z); Nous n'insisterons pas trop sur ce type d'entrées et sorties, car de nos jours, cette façon de procéder est de plus en plus remplacée par l'utilisation d'interfaces graphiques avec zones de saisies et boites de dialogue, dont la programmation dépend de l'environnement de développement utilisé. En langage C, l'affichage à l'écran de la valeur d'une variable est réalisé grâce à la fonction printf dont le fonctionnement dans un premier temps peut se résumer ainsi : Affichage d'un message : printf("message");

10 Algorithmique et programmation en C Page 10 Pierre Tellier Affichage d'un message puis passage à la ligne : printf("message\n"); Affichage de la valeur d'une variable mavarent entière (int) : printf("%d",mavarent); Affichage de la valeur d'une variable mavarreel réelle (float) : printf("%f",mavarreel); Affichage de la valeur d'une variable mavarent entière (int) dans un texte : printf("la variable mavarent vaut %d",mavarent); En fait, il faut retenir pour l'instant que la fonction printf affiche un texte à l'écran. Ce texte peut être un texte simple, ou un texte construit (on dit formaté) à partir de (et de texte). Les règles %d et %f sont là pour indiquer comment le contenu de la variable doit être interprété : %d = interpréter l'information binaire contenue par la variable comme une valeur entière et la convertir comme telle, %f = interpréter l'information binaire contenue par la variable comme une valeur réelle et la convertir comme telle. Il est aussi possible d'afficher plusieurs en un seul ordre, comme le montre cet exemple : printf("mavarent vaut %d et mavarreel vaut %f\n",mavarent,mavarreel);. Nous verrons en cours comment intervenir sur le format des nombres affichés (taille de l'affichage, nombre de chiffres après la virgule etc.). La fonction qui réalise les lectures est scanf. Elle s'utilise de manière un peu particulière sur les entières et réelles (ne parlons pas des caractères!) : lecture au clavier de la valeur d'une variable mavarent entière (int) : scanf("%d",&mavarent); lecture au clavier de la valeur d'une variable mavarreel réelle (float) : scanf("%f",&mavarreel); La grande différence avec printf est la présence du symbole & devant chaque variable. Il signifie adresse de. Nous verrons plus tard les raisons de sa présence, mais pour l'instant contentons nous de considérer ça comme une facétie syntaxique (ce qui est loin d'être le cas en réalité). Il est aussi possible d'ordonner la lecture de la valeur de plusieurs en un seul ordre, comme sur cet exemple : scanf("%d %f",&mavarent,&mavarreel); Il suffira alors d'entrer 2 valeurs, séparées par au moins un espace, tabulation ou retour-chariot. Il s'agit d'entrée formatée, les valeurs entrées sous forme décimale seront converties selon les règles de conversion précisées et rangées aux emplacements correspondant à chaque variable. Voici donc la traduction en C de notre petit programme d'addition : int x, y, z; printf("somme de 2 valeurs\n"); printf("entrez la 1ere valeur "); scanf("%d",&x); printf("entrez la 2eme valeur "); scanf("%d",&y); z = x+y; printf("la somme vaut : %d\n",z); Premiers programmes Structure des programmes élémentaires Un programme élémentaire est constitué uniquement d'un programme principal, délimité par les mots-clé (indique que l'exécution du programme e ici) et (provoque la terminaison du programme). On y trouve d'abord les déclarations nécessaires (constantes, ), puis la séquence d'instruction (affectations, entrées et sorties) qui constitue l'algorithme. Ainsi, notre exemple sur l'addition ne devient un programme qu'encadré de et. entier x, y, z; afficher("somme de 2 valeurs "); afficher("entrez la 1ere valeur "); x := lire(); afficher("entrez la 2eme valeur "); y := lire(); z := x+y; afficher("la somme vaut : "); afficher(z); Programmes élémentaires en C En langage C, un programme principal (sous sa forme la plus rudimentaire) se présente sous la forme d'une suite de déclarations, suivie d'une suite d'instructions, le tout entre accolades et précédé de main() :

11 Algorithmique et programmation en C Page 11 Pierre Tellier main() /* déclarations */ /* instructions */ Remarque : Le texte compris entre /* et */ est un commentaire. À ce propos, il n'est pas possible d'imbriquer les commentaires. En pratique, il est courant d'avoir recours à une première partie consacrée aux inclusions de types et prototypes (tous ces termes seront expliqués par la suite), ainsi qu'aux déitions de constantes. En particulier, si on utilise printf ou scanf dans un programme, il faut le préciser, en général en tout, grâce à la directive #include <stdio.h> qui indique qu'il faut inclure au programme le fichier entête stdio.h (.h = header) qui décrit le comportement des fonctions d'entrées/sorties standard (io=input/output, std=standard). En C, notre programme d'addition donne donc : #include <stdio.h> main() int x, y, z; printf("somme de 2 valeurs\n"); printf("entrez la 1ere valeur "); scanf("%d",&x); printf("entrez la 2eme valeur "); scanf("%d",&y); z = x+y; printf("la somme vaut : %d\n",z); Première compilation et exécution Il est de coutume de donner un nom qui it par ".c" aux fichiers qui contiennent des programmes en langage C. Nous allons donc sauvegarder les instructions ci-dessus dans un fichier appelé addition.c, qu'il nous faut d'abord compiler : gcc -o addition addition.c puis exécuter, une fois le fichier exécutable addition généré : addition ou./addition Autres exemples Voici un exemple de petit programme qui calcule le périmètre d'un cercle, obtenu par la formule : périmètre = 2.π.rayon. constantes réel pi vaut ; réel rayon, périmètre; afficher("entrez la valeur du rayon du cercle : "); rayon := lire(); périmètre := 2.0 * pi * rayon; afficher("le périmètre vaut : ", périmètre); Puis voici seulement le programme C, que nous appelons pericercle.c #include <stdio.h> #dee PI main() float rayon, perimetre; printf("entrez la valeur du rayon du cercle : "); scanf("%f", &rayon); perimetre = 2.0 * PI * rayon; /* 2.0 et non 2 car il s'agit de réels */ printf("le périmètre vaut %f : ",perimetre); Pour exécuter ce programme il est d'abord nécessaire de le compiler :

12 Algorithmique et programmation en C Page 12 Pierre Tellier gcc -o pericercle pericercle.c Une fois le fichier exécutable pericercle généré, on l'exécute ainsi : pericercle ou./pericercle Maintenant écrivons un petit programme permettant le calcul de la surface du disque, grâce à la formule surface=π.rayon 2. Cet exemple montre qu'il n'est pas toujours nécessaire d'utiliser de intermédiaires. Nous avons aussi rendu globale la déclaration de constante. constantes réel pi vaut ; réel rayon; afficher("entrez la valeur du rayon du cercle : "); rayon := lire(); afficher("la surface vaut : ", PI * rayon * rayon); La traduction de cet algorithme en C fait l'objet du programme surfadisque.c : #include <stdio.h> #dee PI main() float rayon; printf("entrez la valeur du rayon du cercle : "); scanf("%f", &rayon); printf("la surface vaut : %f ", PI * rayon * rayon); compilation : gcc -o surfadisque surfadisque.c exécution : surfadisque En algorithmique, on peut supposer pour résoudre nos problèmes l'existence de fonctions prédéies, en particulier pour les traitements mathématiques et les traitements sur les chaînes. Si jamais ces fonctions n'existaient pas, il serait toujours temps d'y remédier. Nous verrons plus tard que cette façon de procéder est à la base du raisonnement algorithmique. En C, il est aussi possible d'utiliser certaines fonctions arithmétiques prédéies, comme sqrt qui calcule la racine carrée d'un nombre réel. Comme pour les fonctions d'entrée/sortie, il faut inclure l'entête concernant ces fonctions. De plus, l'usage de la librairie mathématique doit être indiqué lors de la compilation. Ainsi le programme qui calcule la diagonale d'un rectangle de longueur L et de largeur l se présente ainsi : réel largeur, longueur, diagonale; afficher("entrez la longueur et la largeur du rectangle : "); longueur := lire(); largeur := lire(); diagonale := racinecarrée(longueur * longueur + largeur * largeur); afficher("la diagonale vaut : ", diagonale); Sa traduction en C est saisie dans le fichier diagonale.c : #include <stdio.h> #include <math.h> main() float largeur, longueur, diagonale; printf("entrez la longueur et la largeur du rectangle : "); scanf("%f %f",&longueur,&largeur); diagonale = sqrt(longueur*longueur+largeur*largeur); printf("la diagonale vaut : %f ", diagonale); compilation : gcc -o diagonale diagonale.c -lm exécution : diagonale

13 Algorithmique et programmation en C Page 13 Pierre Tellier Remarques Le programme suivant est faux d'un point de vue sémantique, car une variable est utilisée (en partie droite d'une affectation), sans jamais avoir été à gauche ni fait l'objet d'un lire(). Son contenu est donc indéterminé et cette pratique formellement interdite, car il n'existe pas de valeur par défaut pour les. entier x, y; y := x+1; afficher("y vaut : ", y); Ce genre d'erreur non syntaxique est difficile à détecter en C, à moins d'utiliser toutes les possibilités des compilateurs. Voici la traduction en C de ce programme faux (pasbon.c). #include <stdio.h> main() int x, y; y = x+1; /* ce programme est faux, x n'a pas été initialisé */ /* cette erreur n'est pas détectée par la plupart des compilateurs */ printf("y vaut : %d \n", y); compilation : gcc pasbon.c -Wall -o pasbon Cette option -Wall permet de détecter l'existence de possiblement non initialisées (et plein d'autres choses encore). exécution : pasbon Analyse descendante Dans cette section, nous illustrons par un exemple comment résoudre un problème encore extrêmement simple, toutefois un peu plus compliqué que ceux que nous avons pu évoquer jusqu'à présent. Il s'agit du volume d'un écrou à 8 pans de longueur l, évidé par un cylindre de rayon r et dont la hauteur est h. Nous sommes amenés à décomposer ce problème en sous-problèmes pour nous approcher de la solution. L'arbre qui suit montre la démarche descendante qui permet d'aboutir à des problèmes élémentaires faciles à résoudre.

14 Algorithmique et programmation en C Page 14 Pierre Tellier La réalisation du programme correspondant se fait exactement dans l'ordre inverse : on réalise d'abord les opérations élémentaires, que l'on enchaîne pour aboutir au résultat : constantes réel pi vaut ; réel l, h, r, hauteurt, surfacet, surfaceo, surfacec, surfacee, volumee; afficher("entrez la taille du côté, le rayon du trou et la hauteur de l'écrou :"); l := lire(); r := lire(); h := lire(); hauteurt := (l/2.0)/tangente(pi/8.0); /* tangente : fonction mathématique prédéie */ surfacet := l*hauteurt/2.0; surfaceo := 8.0*surfaceT; surfacec := pi*r*r; surfacee := surfaceo-surfacec; volumee := surfacee*h; afficher("son volume est : ",volumee); En voici une traduction en langage C : #include <stdio.h> #include <math.h> main() float l, h, r, hauteurt, surfacet, surfaceo, surfacec, surfacee, volumee; printf("entrez taille du côté, rayon du trou et hauteur de l'écrou :"); scanf("%f %f %f",&l,&r,&h); hauteurt=(l/2.0)/tan(m_pi/8.0); /* tan et M_PI : fonction et constante mathématiques prédéies */ surfacet=l*hauteurt/2.0; surfaceo=8.0*surfacet; surfacec=m_pi*r*r; surfacee=surfaceo-surfacec; volumee=surfacee*h; printf("son volume est : %f\n",volumee);

15 Algorithmique et programmation en C Page 15 Pierre Tellier Fonctions Nous avons déjà vu quelques fonctions dans le chapitre précédent : afficher, lire, tangente, racinecarrée. En C nous avons aussi rencontré ces fonctions : printf, scanf, tan, sqrt (et main qui est une fonction particulière, celle par laquelle l'exécution de tout programme commence). Nous allons maintenant étudier ce concept de fonction plus en détail. En mathématique, une fonction est une relation qui associe à une variable (ou plusieurs) une et une seule valeur. Nous allons procéder de la même façon en programmation, quoique certaines différences pourront dans certains cas apparaître. La possibilité de réaliser des fonctions informatiques présente de nombreux intérêts. En nous basant sur le concept des fonctions mathématiques, cela permet une meilleure abstraction grâce à une meilleure description (spécification) de ce que doit réaliser le programme et sur la façon dont cela doit être fait. En outre, cela concourt grandement à une meilleure structuration des programmes. En effet, l'analyse descendante préconisée précédemment sera réalisée au moyen d'un découpage fonctionnel. En, la mise au point des programmes s'en trouve facilitée, grâce à une meilleure lisibilité et à une meilleure localisation des traitements. Chaque fonction sera responsable d'un traitement bien déi, et sera suffisamment courte pour tenir d'un seul tenant à l'écran. Elle pourra donc être mise au point facilement et indépendamment du reste du programme. Fonctions avec paramètres et résultat Il s'agit du cas le plus classique de fonction, qui s'apparente aux fonctions mathématiques. Prenons l'exemple de la fonction à une variable f(x)=2x+3, déie de R dans R. On a coutume de spécifier un telle fonction de cette façon : f : R R x a2 x+ 3 Le passage à une fonction informatique est immédiat et presque automatique : fonction f(réel x) : réel f := 2.0*x+3.0; dont la traduction en C est float f(float x) return 2.0*x+3.0; Ceci mérite quelques explications supplémentaires : :réel indique que la valeur de la fonction est de type réel (le domaine d'application). Après le nom de la fonction, (réel x) indique que la fonction f est une fonction à une variable réelle. En informatique, on dit que f admet un paramètre x, et qu'il est de type réel. On parle de paramètre formel, car cette fonction délivre un résultat fonction de x, peu importe sa valeur. En, l'affectation f := expression permet de donner la valeur à la fonction, calculée à partir de celle du paramètre. Les règles de bonne programmation préconisent de n'affecter qu'une fois la fonction et de placer cet ordre exclusivement comme dernière instruction de la fonction. Détaillons maintenant la syntaxe de la même fonction en langage C. float f indique que la fonction s'appelle f est qu'elle est de type float, i.e. qu'elle délivre des résultats de type float. (float x) indique que la fonction f est une fonction à une variable réelle (un paramètre x de type float). L'instruction return permet de délivrer le résultat. Là aussi, Les règles de bonne programmation préconisent de placer cet ordre exclusivement à la de la fonction. Une fois la fonction déclarée (avant toute utilisation), on peut l'utiliser autant de fois qu'on le désire, dans diverses formes d expressions, ou en pratiquant la composition de fonctions, comme le montrent les exemples d'appels de fonction suivants : réel x init 4.0, y, z init 1.0; y := f(x); y := f(5.5); y := f(z+f(3.7)); afficher(f(x)); qui sont presque les mêmes en C :

16 Algorithmique et programmation en C Page 16 Pierre Tellier float x = 4.0, y, z = 1.0; y = f(x); y = f(5.5); y = f(z+f(3.7)); printf("%f",f(x)); Dans ces exemples, les valeurs passées à la fonction f : x, 5.5 et z+f(3.7) sont appelées paramètres effectifs : les valeurs effectivement passées à la fonction. Il s'agit d'un passage de paramètre par valeur, c'est-à-dire que l'expression en paramètre est d'abord évaluée, et qu'ensuite sa valeur est transmise à la fonction. Le paramètre formel prend alors cette valeur pour l'exécution de la fonction. Prenons un autre exemple, celui de la moyenne de 2 nombres réels. La spécification de la fonction moyenne est : moyenner : R R ( a, b) a ( a+ b)/2 La fonction qui réalise ce traitement est fonction moyenne(réel a; réel b) : réel réel res; res := (a+b)/2.0; moyenne := res; afficher(moyenne(12.5, 14)); z := moyenne(x, y); Lorsqu'on a plusieurs paramètres, la syntaxe ressemble à celle de la déclaration de. On peut regrouper les par type, ou les séparer à l'aide d'un ";" : fonction moyenne(réel a, b) : réel est équivalent à fonction moyenne(réel a; réel b) : réel. En voici une traduction possible en C : float moyenne(float a, float b) float res; res = (a+b)/2.0; return res; printf("%f",moyenne(12.5, 14)); z = moyenne(x, y); Encore une nouveauté dans cette fonction : la variable res déclarée à l'intérieur de la fonction est une variable locale. Sa portée (durée de vie) est limitée à la fonction, il n'y a donc pas d'interférences avec d'autres du même nom déclarées dans d'autres fonctions ou comme globales. Nous reparlerons des différentes portées des avant la de ce chapitre. Fonctions sans résultat : procédures On parle de procédures (ou de sous-programmes) pour de telles fonctions car on s'éloigne ici de la signification mathématique des fonctions, qui possèdent en général au moins une variable et une valeur. L'intérêt de fonctions qui n'ont pas d'effet sur les est assez limité en algorithmique, à part peut être pour faire l'affichage de : procédure afficheentier(entier x) afficher ("valeur : ", x); En C, on ne fait pas de distinction entre fonctions et procédures. L'absence de résultat est simplement signifiée par le type de retour void. La dernière instruction de la fonction est un simple return suivi de rien, qui est de plus facultatif. void afficheentier(int x) /* affichage d'un entier */ printf("valeur : %d",x); return; /* facultatif */ /* appel */ afficheentier(age);

17 Algorithmique et programmation en C Page 17 Pierre Tellier Fonctions et procédures sans paramètres Là encore, on s'éloigne ici de la signification mathématique des fonctions. Leur usage est moins fréquent que les fonctions classiques, et la plupart du temps correspond à des traitements de type "système" ou génération de valeur (lecture, production de nombre aléatoire etc.). Nous avons déjà utilisé la fonction lire() qui répond à ce schéma. Pour déclarer une telle fonction, il suffit de ne rien écrire à l'intérieur des parenthèses normalement censées contenir les paramètres. En C, on écrira simplement void à l'intérieur de ces parenthèses. L'appel se fait toujours avec des parenthèses vides. fonction lireentier() : entier entier x; x := lire(); lireentier := x; int lireentier(void) /* lecture d'un nombre entier au clavier (pour cacher le &) */ int x; scanf("%d",&x); return x; /* appel */ age = lireentier(); Remarques : Il n'y a pas d'interférence entre le nom des paramètres et le nom des déclarées en dehors des fonctions. Ainsi dans les exemples précédents, la variable x dans la fonction lireentier et le paramètre x de la procédure afficheentier ne désignent pas le même objet. En, un exemple de procédure qui n'a pas de paramètre, et se contente d'afficher un message constant : procédure affichemessagebienvenue() afficheln(" "); afficheln(" Bienvenue cher utilisateur "); afficheln(" "); void affichemessagebienvenue(void) /* affichage d'un message */ printf(" \n"); printf(" Bienvenue cher utilisateur \n"); printf(" \n"); return; /* facultatif */ /* appel */ affichemessagebienvenue(); Les paramètres ne sont jamais modifiés par une fonction, comme le montre l'exemple suivant : int a = 2; void lireentierpasbon(int x) /* lecture d'un nombre entier au clavier (pour cacher le &) : ne marche pas */ scanf("%d",&x); printf("%d",a); /* affiche 2 à l'écran */ lireentierpasbon(a); /* entrez 3 par exemple */ printf("%d",a); /* affiche encore 2 à l'écran! */

18 Algorithmique et programmation en C Page 18 Pierre Tellier Fonctions avec plusieurs résultats Résultat n-uplet Dans de nombreux cas, les fonctions informatiques ne peuvent se contenter de délivrer un seul résultat. Cela est facilement contourné en mathématique où une fonction peut délivrer un résultat qui peut être un n- uplet. En algorithmique nous allons procéder exactement de cette façon. Imaginons une fonction qui décompose un nombre réel en 2 parties : partie entière et partie décimale. Deux résultats doivent être délivrés. En fait, nous n'allons rendre qu'une seule valeur, le couple formé des deux nombres, un entier et un réel. La spécification de la fonction est : séparer : R R xa( e, d) avec e : = [x] et d : = x-[x] et son algorithme : fonction sépare(réel x) : (entier, réel) entier ent; réel dec; ent := entier(x); dec := x - réel(ent); sépare := (ent, dec); L'utilisation de fonctions à résultat n-uplet se fait de la manière suivante : entier e; réel r, nb; nb := lire(); (e,r) := sépare(nb); afficher(e); afficher(r); La traduction de cet exemple n'est pas immédiate en C, car le type n-uplet n'est pas prédéi. Nous allons pour cela avoir recours à la construction de types qui permettent la déclaration de contenant plusieurs informations. L'usage de telles structures (appelées aussi parfois enregistrements) sera vu plus en détail dans un chapitre ultérieur. Les structures en C Le type n-uplet n'existe pas naturellement en C, mais le langage permet de créer des nouveaux types de données constitués de plusieurs informations. Ainsi, pour déir un couple constitué d'un nombre entier, et d'un nombre réel, nous utiliserons la syntaxe suivante : typedef struct int e; float d; EntPlusDec; typedef est un mot-clé du langage C qui permet la déition de nouveaux types (pas uniquement des structures). EntPlusDec est alors le nom d'un nouveau type, qui va permettre de déclarer des de ce type. L'accès aux informations contenues dans de telles (on parle des champs d'une structure) se fait grâce au symbole ".". Chaque champ s'utilise exactement comme une variable traditionnelle. Voici donc la traduction de notre précédente fonction en langage C : EntPlusDec separe(float x) EntPlusDec res; res.e = (int)x; /* ou int(x) */ res.d = x - (int)res.e; /* ou float(res.e) */ return res; dont l'utilisation est : EntPlusDec ed; float x; scanf("%f",&x);

19 Algorithmique et programmation en C Page 19 Pierre Tellier ed = separe(x); printf("%d ",ed.e); printf("%f ",ed.d); Nous reviendrons bien plus en détail sur les structures, entre autres nous verrons qu'elles peuvent être imbriquées et contenir des informations pas forcément élémentaires. En attendant, nous donnons une autre syntaxe, dont l'utilité sera dévoilée plus tard : typedef struct t_entplusdec int e; float d; EntPlusDec; dans laquelle struct t_entplusdec est une autre façon de désigner le nouveau type. Paramètres modifiables (passage par adresse) en C Une autre façon de délivrer plusieurs résultats consiste à utiliser des paramètres modifiables. Ceci est possible dans d'autres langages que le C, mais dans le contexte d'une initiation à la programmation, je déconseille cette pratique car elle est franchement éloignée du formalisme de spécification proche des mathématiques que nous avons adopté. Notons qu'il ne s'agit toutefois pas d'un pis-aller, de nombreux programmeurs ont l'habitude de passer les résultats sous forme de paramètres, et réservent la valeur délivrée par la fonction comme code d'échec ou de succès de la fonction. Toutefois ces paramètres modifiables n'existent pas non plus réellement en langage C. Il faut avoir recours à une astuce qui consiste à utiliser l'adresse des (rappelez vous de scanf). Nous reviendrons sur le mécanisme des pointeurs dans un chapitre dédié à cela. Pour l'instant encore, considérons l'introduction des paramètres modifiables comme une histoire de syntaxe. Soit la fonction sommefois, qui calcule la somme et le produit de 2 nombres entiers. Sa spécification est : sommefois: R R R R ( a, b) a ( a+ b, a* b) et peut s'écrire ainsi : void sommefois(int a, int b, int *s, int *p) *s = a+b; *p = a*b; Dans cette fonction, a et b sont des entiers, ainsi que *s et *p. En fait les paramètres ne sont pas *s et *p, mais s et p, chacun du type (int *), c'est-à-dire que s et p sont des adresses de de type int. On dit que s et p sont des pointeurs sur des entiers. Le symbole * permet d'obtenir (dé-référencer) la variable à partir de son adresse. L'appel de la fonction se fait en utilisant les adresses des paramètres modifiables, obtenues en précédant les du symbole & : int nb1 = 1,nb2 = 3,somme,produit; sommefois(nb1,nb2,&somme,&produit); printf("%d+%d = %d, %d*%d = %d\n",nb1,nb2,somme,nb1,nb2,produit); Important : lorsqu'on travaille déjà sur l'adresse d'une variable et qu'on doit à nouveau l'utiliser comme paramètre modifiable, il ne faut pas remettre le symbole & : void lireentier(int *x) scanf("%d",x); /* et non pas scanf("%d",&x) car x est déjà une adresse */ /* équivalent à scanf(&*x);!!! */ int a; lireentier(&a); /* n'apporte pas grand chose de plus que scanf! */ Variables et portée des Variables locales, globales Pour l'instant nous avons vu qu'il est possible de déclarer des à l'intérieur de chaque fonction et du programme principal. On appelle ces des locales, car elles sont inaccessibles en dehors des fonctions où elles ont été déclarées. Les fonctions communiquent entre elles (s'échangent des valeurs) grâce au passage des paramètres. Il existe d'autres façons de déclarer des, parmi lesquelles la

20 Algorithmique et programmation en C Page 20 Pierre Tellier déclaration de globales : il s'agit de déclarées en dehors des fonctions, au du programme En C les déclarations de globales sont en général après les directives d'inclusion. Ces appelées globales peuvent être désignées dans n'importe quelle fonction, elles sont accessibles partout. Si un paramètre ou une variable locale porte le même nom qu'une variable globale, il masque la variable globale, c'est-à-dire qu'il n'y a pas d'ambiguïté, on utilise le paramètre ou la variable locale, sans aucun risque d'interférence avec la variable globale. En revanche, il est interdit de déclarer dans une fonction une variable locale qui porte le nom d'un paramètre. L'usage des globales est extrêmement dangereux, car il est difficile de localiser où leur valeur est modifiée. Il est donc très important de limiter leur usage, de concevoir des fonctions qui ne manipulent pas de telles. Si cela s'avère impossible (on n'a pas toujours le droit de modifier le prototype des fonctions), on doit signaler à l'aide de commentaires les globales utilisées et surtout modifiées dans les fonctions. Ci suit un exemple de commentaires de fonctions, mentionnant l'accès à des globales. Comme cela est fastidieux, et gourmand en place, ce genre de commentaire sera le plus souvent omis dans ce polycopié. /* fonction f : float f(float) Évaluation de la fonction mathématique f(x) = 2x+3 Fixes : float x = abscisse Modifiables : néant Résultat : réel = valeur de la fonction au point d'abscisse x Globales utilisées : néant Globales modifiées : néant */ float f(float x) return 2.0*x+3.0; Normalement les locales sont créées au de l'exécution des fonctions, puis détruites à la. Donc entre 2 appels successifs la valeur de ces est perdue, il faut les réinitialiser à chaque fois. Variables statiques et automatiques en C Il est possible d'imposer une rémanence à des (elles conservent leur valeur) grâce au mot-clé static : int compteur(void) static int i = 0; i = i+1; return i; printf("%d ",compteur()); /* affiche 1 */ printf("%d ",compteur()); /* affiche 2 */ Le mot-clé static, devant une variable globale, indique qu'elle ne peut pas être partagée avec d'autres modules. En effet, pour réaliser de gros programmes, on utilise plusieurs modules (un module = un fichier contenant des fonctions). Une variable globale static est accessible dans tout le module, mais pas dans les autres. De manière symétrique, pour utiliser une variable déclarée globale dans un autre module, il suffit de la re-déclarer mais précédée du mot-clé extern (mais sans initialisation) qui signifie que la variable a déjà été déclarée à l'extérieur du module. En citons les automatiques du langage C, qui sont des encore plus locales que les locales que nous avons vues. En effet, déclarées au d'un bloc d'instructions, leur portée est restreinte à ce bloc. Un bloc d'instructions est une séquence délimitée par et. Pour l'instant nous n'avons créé qu'un seul bloc par fonction, mais il est possible de les imbriquer, bien que cela soit rare de procéder ainsi, s'il n'y a pas de bonne raison : conditionnelle ou itération. Le petit exemple suivant montre quelques unes des dont nous venons de parler : /* globales */ int a = 2, b = 1, c; int sommefoisdeux(int x, int y)

21 Algorithmique et programmation en C Page 21 Pierre Tellier int a,c; /* a et c sont des locales */ a = x+y; int b; /* b est une variable automatique */ b = 2*a; c = b; return c; c = sommefoisdeux(a,b); printf("%d %d",a,b); /* affiche 2 1 */ Fonctions en paramètre de fonctions Une fonction peut être passée en paramètre d'une fonction, comme n'importe quel autre objet. La syntaxe est juste un peu plus compliquée, comme le montre la fonction dérivée, qui prend en paramètre une fonction f (fonction réelle à une variable réelle) et une variable x, et qui calcule f'(x) en utilisant la formule de la dérivée en un point d abscisse x, quand h tend vers 0 : fonction f1(réel x) : réel f1 := 3.0*x + 2.0; fonction f2(réel x) : réel f2 := 2.0*x*x + 5.0*x; f( x) ' = limh 0 fonction dérivée((réel):(réel) f; réel x; réel h) : réel dérivée:= (f(x+h)-f(x))/h; f( x+ h) f( x) h réel yprime; yprime := dérivée (f1, 5.0, 0.001); /* (dérivée(3x+2)=3) */ yprime := dérivée (f2, 3.0, ); /* (dérivée(2x^2+5x)=4x+5)*/ Une fois traduit en C : float f1(float x) return 3.0*x + 2.0; float f2(float x) return 2.0*x*x + 5.0*x; float derivee(float (*f)(float), float x, float h) return (f(x+h)-f(x))/h; main()