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)
 

Avant-Propos

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é.

2. Les entrées-sorties

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

• test if ( a ) /* si a est non nul */
• test d'égalité : if ( a == b ) /* si a égal b*/
• test de non égalité : if ( a != b ) /* si a différent de b*/
• tests de relation d'ordre :
  • if ( a < b )
  • if ( a <= b )
  • if ( a > b )
  • if ( a >= b )
• test de ET : if ((expression1) && (expression2)) /* si l'expression1 ET l'expr.2 sont vraies */
• test de OU : if ((expression1) || (expression2)) /* si l'expression1 OU l'expr.2 est vraie */
• test de NON LOGIQUE : if ( !(expression1) ) /* si l'expression1 est fausse */

a= b ; // affectation de la valeur de b dans a
if (b != 0 )...// ou plus exactement "if (b)"

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

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.*/ }

• L’instruction switch correspond à une cascade d’instructions if ... else ...
• L’'instruction switch en C permet des choix multiples uniquement sur des types entiers (y compris caractères). D’autres langage de programmation sont moins contraignants.
• Le programme exécute toutes les instructions jusqu’au premier break qu’il rencontre en passant dans les « case » suivants.
• Le bloc "default" n'est pas obligatoire.
• Le "break" n’est pas obligatoire, parfois son absence peut être intéressante, mais elle nuit à la lisibilité du programme.
• Il existe d'autres dessins pour schématiser cette instruction de choix, mais celle-ci est la seule à pouvoir prendre en compte l'absence du "break".

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 */ ............; ............; }

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);

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 */ ............; ............; }

• Les 3 instructions du for ne portent pas forcément sur la même variable. Une instruction peut contenir l'opérateur séquentiel, ceci peut permettre de mettre deux instructions à la place de l'initialisation, la condition de continuité ou la modification. Attention, ceci affecte gravement la lisibilité du code.
• Une ou plusieurs des 3 instructions peuvent être omises, mais pas les ;

  for(;;) { ............; /* bloc d'instructions */ ............; ............; }

  est une boucle infinie (répétition infinie du bloc d'instructions).
  
  
• L'organigramme de l'instruction for explique mieux qu'un texte quelconqie son fonctionnement.

7. Petits exemples et contre exemples

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

9. Remerciements