Retour à l'index

Conception globale d'un programme

Dans les chapitres précédents, nous nous sommes initiés à la programmation, plus particulièrement à la programmation structurée, à travers du langage C. Le jeu d'instructions que nous avons introduit est suffisant pour programmer tout ce qui est programmable.
Toute nouvelle instruction que nous ajouterons désormais peut être émulée dans le mini langage C tel que nous l'avons défini jusqu'ici ; il suffit de le vérifier au cas par cas, ce que nous ferons de temps en temps. Il est donc temps de faire une pause. Nous allons commencer par réfléchir à la meilleure façon de concevoir les programmes.

Pragmatique

Jusqu'ici nous avons présenté la syntaxe et la sémantique des instructions que nous avons in­troduites, et ceci au fur et à mesure. Nous allons ici nous intéresser à un troisième aspect, dit pragmatique (ou méthodologie de la programmation, ou style de programmation). Cet aspect pratique de la programmation a pour but d'indiquer comment écrire des programmes lisibles par le programmeur et ceux qui lisent le programme. Les mauvaises langues disent qu'on place en pragmatique tout ce que l'on ne peut pas placer en syntaxe ou en sémantique, c'est­-à-dire tous les aspects de la Programmation qui ne peuvent pas être décrits dans un cadre logique bien défini.
Présentons l'aspect pragmatique de ce que nous avons vu jusqu'à maintenant. Nous le continuerons au fur et à mesure de l'introduction de nouvelles notions de langage C, en particulier par ce que l'on appelle le raffinement successif de la conception d'un programme.

Présentation d'un programme


Passage à la ligne
Introduction. D'un point de vue purement syntaxique un programme peut être écrit sur une seule ligne. En fait on a la possibilité d'aller à la ligne quand on veut (ou presque : l'exception étant qu'on ne peut pas couper les identificateurs et les constantes de type chaîne de caractàres, même au niveau d'un espace) et de faire suivre tout espace par autant d'éspaces que l'on veut (sauf, toujours, pour les constantes de type chaîne de caractàres). Ces possibilités ont évidemment pour but de permettre d'écrire des programmes lisibles.
Exemple 1. Comparer le programme suivant :
				#include <stdio.h> void main(void) { printf("Bonjour"); printf("007");} 
			
et le même réécrit de la façon suivante :
				#include <stdio.h>
				
				int main(void)
				{
					printf("Bonjour"); 
					printf("007");
				}
			


Indentation
Introduction.­ Une des erreurs de syntaxe les plus fréquentes est de ne pas mettre autant d'accolades fermantes '}' que d'accolades ouvrantes '{' ou bien de mal les apparier. Pour éviter ceci on a intérêt à indenter les programmes (c'est-à-dire à ne pas commencer chaque ligne en début de ligne) et à placer l'accolade '}' correspondant à l'accolade '{' en-dessous de celle-ci, pour obtenir une structure de la forme suivante :
				{
				
					{ 
					} 
				}
			

Exemple 2. Comparer le programme suivant :
				#include <stdio.h> 
				int main(void) {
				float X,Y;
				printf("x = ");
				scanf("%f",&X);
				while (X != 1000)
				{
				Y = (sin(X) + log(X)) / (exp(X) + 2);
				printf("f(%f) = %f",X,Y);
				printf("x = ");
				scanf("%f", &X);
				}
				}
			
et le même réécrit de la façon suivante :
				#include <stdio.h> 
				
				int main(void) 
				{
					float X,Y;

					printf("x = ");
					scanf("%f",&X);
		
					while (X != 1000)
					{
						Y = (sin(X) + log(X)) / (exp(X) + 2);
						printf("f(%f) = %f",X,Y);
						
						printf("x = ");
						scanf("%f", &X);
					}
				}
			
Le code relatif à la boucle ressort mieu. Il en va de même avec la structure conditionnelle.

Utilisation des commentaires

Notion Lorsqu'on écrit un petit programme, et surtout au moment où on l'a écrit, ce qu'il fait est clair pour nous, ainsi que le rôle de chacune des instructions et de chacune des variables auxiliaires. Ceci devient nettement moins clair lorsqu'on le relit six mois plus tard. Cela peut ne pas être clair du tout lorsqu'il est lu par quelqu'un d'autre. On a donc intérêt à insérer des commentaires, c'est­-à-dire des petits textes servant à expliquer ce que l'on fait qui ne seront pas pris en compte par le compilateur.
Syntaxe en langage C Les deux groupes de symboles `/*' et `*/' sont réservés en C pour indiquer respective­ment le début et la fin d'un commentaire, c'est-à-dire que tout ce qui se trouve entre ces deux symboles (ces symboles y compris) est ignoré par le compilateur. L'exception est bien sûr leur occurrence dans une constante de type chaîne de caractàres. On peut mettre n'importe quel signe entre les délimiteurs, à l'exception du délimiteur de fin de commentaire (`*/'). Les commentaires peuvent s'étaler sur plusieurs lignes.
Exemple.
 
				/******
					Calcul de f(x) = (sin(x)+ln(x))/(exp(x)+2), pour plusieurs valeurs de x, differentes de 1000, introduites au clavier. 
					On termine en proposant la valeur 1000.
				******/
				
				#include <stdio.h> /* bibliothèque d'entré-sortie standard */
				#include <math.h>/* bibliothèque utilisée pour les fonctions sin,log et exp */
				
				int main(void) 
				{ 
				float X, Y; 
				printf("x = "); /* prompteur de x */
				scanf("%f",&X); /* lecteur de x */
				while (X != 1000.0) /* tant que 'x' est différent de 1000 ... */
				{
				Y = (sin(X) + log(X))/(exp(X) + 2); /* ... on calcul f(X) ... */ 
				printf("f(%f) = %f", X, Y); /* ... on affiche f('X') = 'Y' ... */ 
				printf("\nx = "); /* ... on affiche le prompteur de 'X' ... */
				scanf("%f",&X); /* ... on re-lit 'X'*/
				}
				} 
			
Le nombre de commenntaire n'est pas limité, et ne rallentiront ou alourdirons pas le programme. En effet, lors de la compilation, les commentaires sont purement oubliés.

Etapes de conception d'un programme

Introduction. Concevoir un programme n'est pas en général une tâche facile. Il n'existe pas de procédé mécanique pour cela. La conception d'un programme est un véritable acte de créativité.
Il existe cependant un plan à suivre.
Phases de conception d'un programme. Le processus de conception d'un programme peut être divisé en deux phases : la phase de conception de l'algorithme et la phase d'implémen­tation. L'algorithme est un programme dans un pseudo­langage écrit en français dont on définit soi-même le jeu des ordres élémentaires et le jeu de combinaisons de tels ordres. Pour produire un programme dans un langage de programmation tel que le langage C, il faut traduire cet algorithme dans ce langage, ce qui s'appelle l'implémentation ou codage.
Définition du problème.­ La premiàre étape, à la fois de la phase de résolution et de la conception d'un programme, est d'être certain que la tâche à accomplir est spécifiée de façon complàte et précise. Il ne faut pas considérer cette étape à la légère. On doit en particulier spécifier le nom et la nature des données et des résultats. C'est l'étape de l'établissement du cahier des charges.
Phase de résolution. Beaucoup de programmeurs néophytes ne comprennent pas la nécessité de concevoir un algorithme avant d'écrire un programme. Ils essaient de court-circuiter la phase de résolution, ou tout au moins de la réduire à la seule définition du problème. Ceci semble raisonnable a priori puisqu'on a l'impression de faire deux fois la même chose et de gagner ainsi du temps. Le problème est que l'on ne gagne pas de temps en procédant ainsi. L'expérience a montré que la conception en deux phases produit beaucoup plus vite un programme qui fonctionne. La conception en deux phases simplifie la phase de conception de l'algorithme en n'ayant pas à prendre soin des détails inhérents à chaque langage.
Phase d'implémentation. Cette phase n'est pas totalement triviale. Il faut être soigneux. Il faut quelquefois émuler des ordres qui nous plairaient bien mais qui n'existent pas dans ce langage de programmation. Mais en fait plus on devient familier avec un langage plus cette étape devient une routine.
Tests. Les tests existent dans chacune des deux phases. Si des défauts sont trouvés, il faut revoir la conception (partielle ou globale) du programme. La première phase de test se fait mentalement en exécutant les étapes de tête. Pour de grands algorithmes on peut se servir de papier et de crayon. Le programme en langage C, lui, est testé en le compilant et en le faisant tourner sur des données. Le compilateur donnera des messages d'erreurs pour certaines sortes d'erreurs, appelées en général erreurs de syntaxe : il manque des points-virgules, les accolades ouvrantes et fermantes sont mal appariées, on essaie d'attribuer une valeur réelle à une variable déclarée de type entier... Lorsqu'on fait tourner le programme pour un jeu de données, il faut comparer les résultats donnés par l'ordinateur et ceux que vous connaissez pour vous apercevoir que le programme ne fait peut-être pas exactement ce qui est attendu.
Interaction de toutes les étapes entre elles. La façon de faire décrite ci-dessus est idéalisée. C'est la figure de base que vous devez avoir en mémoire, mais la réalité est un peu plus compliquée. En fait des erreurs sont découvertes à n'importe quel moment et vous devez revenir en arrière.
Par exemple le test d'un algorithme peut révéler que la définition du problème est incomplète.


Cours, éxercices ou graphismes libre de droit. Un mail est souhaitable | Webmestre : Aublet Bastien (bastien.aublet@hotmail.fr)