Developpez.com - Linux
X

Choisissez d'abord la catégorieensuite la rubrique :


Organigrammes, boucles en C

Date de publication : 25/06/07 , Date de mise à jour : 25/06/07

Par Véronique Bondaz
 Pascal Bouron
 Troumad alias Bernard SIAUD (Page personnelle)
 

Les premiers organigrammes, les premières boucles en C

Avant-Propos
1. La norme
2. Les entrées-sorties
3. Structure d’aiguillage : condition logique if else
3.1. if (...) {...} else {...}
3.2. Les tests
4. Structure de choix multiples : switch...case
5. Les boucles while et do...while
5.1. La boucle " tant que ", en c while(...) {...}
5.2. La boucle " repeter tant que ", en c do {...} while(...) ;
6. L'instruction for
7. Petits exemples et contre exemples
8. Un exemple
9. Remerciements


Avant-Propos

Avant toute programmation, il est recommandé d'avoir une visualisation du programme qu'on va faire : il faut faire un algorithme ou un organigramme. Le premier a une structure linéaire comme un programme alors que le second permet de visualiser beaucoup mieux les différents blocs du programme, les boucles, les tests. C'est ce dernier point que je vais présenter ici : les organigrammes.

Faire un organigramme d'un programme est important car un programme ne se fait jamais un une seule fois, parfois il est modifié par d'autres personnes que celles qui l'ont conçu. Donc ce dessin pourra expliquer aux personnes qui arrivent après vous comment il a été conçu, ou même il pourra éclairer le concepteur même des idées qu'il avait eu. Il est presque tout aussi important de laisser une explication du programme que de mettre des commentaires dans le programme.

Les modes de programmation visuel qui se développent de plus en plus ressemblent plus à des organigrammes à un programme. Il est donc important de prendre connaissance dès que possible avec cette schématique.

Ceci est un résumé du cours donné en II1 au département GEii de l'IUT B de l'université Lyon 1.


1. La norme

Symbole Désignation Symbole Désignation
1)
SYMBOLES DE TRAITEMENT

Symbole général "traitement"
Opération ou groupe d'opérations sur des données, instructions, etc.., ou opération pour laquelle il n'existe aucun symbole normalisé.
6)
Mode synchrone ; mode parallèle
Ce symbole est utilisé lorsque plusieurs instructions doivent être exécutées simultanément.
2)
Fonction ou sous-programme
Portion de programme considérée comme une simple opération.
7)
SYMBOLES AUXILIAIRES

Renvoi
Symbole utilisé deux fois pour assurer la continuité lorsqu'une partie de ligne de liaison n'est pas représentée.
3)
Entrée - Sortie :
Mise à disposition d'une information à traiter ou enregistrement d'une information traitée.
8)
Début, fin, interruption
Début, fin ou interruption d'un organigramme, point de contrôle, etc..
4)
Préparation
Opération qui détermine partiellement ou complètement la voie à suivre dans un embranchement ou un sous-programme.
Symbole également utilisé pour préparer une décision ou mettre un aiguillage en position.
9)
Commentaire
Symbole utilisé pour donner des indications marginales.
3)
SYMBOLES LOGIQUES

Embranchement
Exploitation de conditions variables impliquant le choix d'une voie parmi plusieurs.
Symbole couramment utilisé pour représenter une décision ou un aiguillage.
Sens conventionnel des liaisons :
Le sens général des lignes doit être :
- de haut en bas
- de gauche à droite.
Lorsque le sens ainsi défini n'est pas respecté, des pointes de flèches, à cheval sur la ligne, indiquent le sens utilisé.


Exemple : Détermination de l’aire d’un disque à partir du rayon

Traduction du cahier des charges :
Entrée  : Saisie du rayon
Sortie : Affichage de l’aire du disque
Traitement à réaliser  : Surface=Pi* Rayon²


2. Les entrées-sorties

On indique avec des flèches si on a affaire à une entrée et une sortie : l'entrée est visible avec une flèche qui va vers la bulle et la sortie une flèche qui en sort. Pour plus de lisibilité, on choisit de mettre à gauche les entrées et à droite les sorties. La nature des entrées-sorties est aussi indiquée car elles peuvent être complètement différentes surtout en automatique.
Voir sur le schéma ci-dessus l'éntrée Clavier et la sortie Écran.


3. Structure d’aiguillage : condition logique if else


3.1. if (...) {...} else {...}

Il s'agit de l'instruction :
SI ( expression vraie ) ALORS
    BLOC 1 D'INSTRUCTIONS
SINON 
    BLOC 2 D'INSTRUCTIONS
FINSI
 
remarque : la sortie avec le rond est la sortie « non ». Ceci permet de la mettre n'importe où : en bas, à droite ou à gauche.
 
Syntaxe en C :
if (expression)
{
 .........; /*bloc 1 d'instructions*/
 .........;
 .........;
} 
else
{
 .........; /*bloc 2 d'instructions*/
 .........;
 .........;
}

3.2. Les tests

NB : a, b, expression1 et expression2 peuvent être des tests d’égalité, d’inégalité ou des retours de fonctions.

Remarques :

* ATTENTION : L’écriture if ( a = b ) est syntaxiquement correcte, mais ne correspond pas à un test d’égalité entre a et b.
Cela correspondra en réalité à :
a= b ; // affectation de la valeur de b dans a
if (b != 0 )...// ou plus exactement "if (b)"
* Le bloc : else n'est pas obligatoire


4. Structure de choix multiples : switch...case

La structure if (...) then {...} else {...} permet de réaliser un choix parmi deux possibilités. Il est possible d’imbriquer les if (...) then {...} else {...} les uns dans les autres pour tenir compte de choix plus nombreux. Mais la structure devient très lourde à écrire et à lire quand le nombre de cas augmente. On lui préférera alors la structure de tests multiples, qui permet de comparer une variable (de type entier en C) à toute une série de valeurs et d’exécuter, en fonction de la valeur effective de cette variable, différents blocs d’instructions.

Il s'agit de l'instruction :
AU CAS OU ( la variable ) VAUT
       C1 : BLOC 1 D'INSTRUCTIONS 
       C2 : BLOC 2 D'INSTRUCTIONS
       C3 : BLOC 3 D'INSTRUCTIONS 
       ….
       Cn : BLOC n D'INSTRUCTIONS 
SINON 
       BLOC n+1 D'INSTRUCTIONS
FIN DE CAS
Syntaxe en C :
switch(variable) /*au cas où la variable vaut:*/
{
 case valeur1 : /*valeur1: executer ce bloc d'instructions.*/
   .......;
   break;
 case valeur2 : /*valeur2: executer ce bloc d'instructions.*/
   ........;
   break;
.
. /*etc ...*/
.
 default: /*aucune des val.précédentes: executer ce bloc*/
   ........; /*d'instructions, pas de "break" ici.*/
}
Remarques :


5. Les boucles while et do...while


5.1. La boucle " tant que ", en c while(...) {...}

Il s'agit de l'instruction :
TANT QUE ( condition est vraie ) FAIRE
BLOC D'INSTRUCTIONS
Syntaxe en C :
while (expression)
{
 ............; /* bloc d'instructions */
 ............;
 ............;
}
Remarque : Le test se fait d'abord, le bloc d'instructions n'est pas forcément exécuté.

Attention : il faut que le résultat du test puisse être modifié d’une manière ou d’une autre si on ne veut pas faire une boucle sans fin.

On peut rencontrer la construction suivante: while (expression); terminée par un ; et sans la présence du bloc d'instructions. Cette construction signifie: "tant que l'expression est vraie attendre".


5.2. La boucle " repeter tant que ", en c do {...} while(...) ;

Il s'agit de l'instruction :
REPETER
        BLOC D'INSTRUCTIONS 
TANT QUE (condition est vraie)
Syntaxe en C :
do
{
 ............; /* bloc d'instructions */
 ............;
 ............;
}
while (expression);
Remarque : Le test se fait après, le bloc est exécuté au moins une fois.


6. L'instruction for

Il s'agit de l'instruction :
POUR ( initialisation ; condition de continuité vraie ; modification )
{
       BLOC D'INSTRUCTIONS
}
Syntaxe en C :
for(initialisation ; condition de continuité ; modification)
{
 ............; /* bloc d'instructions */
 ............;
 ............;
}
Remarques :


7. Petits exemples et contre exemples

Bien que tout soit possible avec des boîtes et aussi (ou presque) en C, il y a des structures à éviter pour que l'organigramme soit lisible : les renvois (boucles ou sauts) croisés sont proscrits. On peut mettre des renvois dans des renvois, mais si un renvoi commence à l'intérieur d'un renvoi, il doit se finir à l'intérieur de ce même renvoi. De même s'il commence à l'extérieur, il doit se finir à l'extérieur.
Il existe bien le goto label en C pour programmer des organigrammes ne respectant pas cette règle, mais tout bon programmeur vous dira à juste titre qu'il faut mieux éviter cette structure ! Et c'est toujours possible.

Le mauvais graphique

Ceci est un mauvais exemple car les trois renvois se mélangent.

  • La première flèche (test 1) part en dehors de tout renvoi et arrive au mileu des deux autres.
  • La seconde (test 2) sort du premier renvoi.
  • La troisième (test 3), qui part du bas en dehors de tout renvoi revient dans le premier renvoi.
Il est ice corrigé, mais mériterait des simplifications : certaines parties de l'organigramme sont écrites deux fois.

Grâce aux fonctions, j'ai simplifié la structure du programme principal en évitant de faire plusieurs fois les mêmes choses.


8. Un exemple

Je vais ici vous présenter sous forme d'organigramme mon programme de taquin disponible à...


9. Remerciements



Valid XHTML 1.1!Valid CSS!

Copyright (c) 2007 Bernard SIAUD. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License" : http://www.gnu.org/licenses/fdl.txt
Contacter le responsable de la rubrique Linux