Algorithmes
Accueil

du site

Les ordinateurs actuels sont bêtes mais besogneux !

Si vous attendez d'eux la moindre intelligence : laissez tomber,
la seule intelligence que montreront vos programmes
est celle que vous y aurez apportée vous-même.

En revanche, vous pouvez compter sur ces bonnes bêtes
pour réaliser inlassablement et très rapidement
des actions répétitives, qui, franchement, nous barbent prodigieusement, nous, les humains !

Ces actions répétitives sont réalisées à l'aide des instructions algorithmiques que nous alons voir dans cette page.

Ces instructions sont au nombre de trois :

for( ... , ... , ... ) {... ; ... ; ...}
while( ... ) {... ; ... ; ...}
do {... ; ... ; ...}while( ... ) ;


Au travail !

Comme Monsieurs Jourdain, tout le monde passe sa vie à faire des algorithmes, mais rares sont ceux qui savent que cela s'appelle comme çà !

Le boucher s'adresse à son apprenti :
Prends ces carcasses, découpe des côtelettes et je ne veux pas te voir lever le nez tant qu'il n'y en aura pas soixante !
Ouste !

Que fait le garçon boucher ?

  1. Il prépare son travail : couteau, table à découper, carcasses, repère les côtelettes.
  2. Il fait appel à sa mémoire pour repéreer le nombre de côtelettes coupées ( zéro au départ )
  3. Il compare ce nombre au maximum 60, mis en mémoire lui-aussi.
  4. Si le nombre actuel de côtelettes est inférieur : il exécute l'action : couper une côtelette.
    Il ajoute 1 au nombre de côtelettes coupées qu'il retient dans sa mémoire.
    Il revient à l'étape 2
  5. Si le nombre actuel est égal à 60 il s'arrête de couper.

Et il relève le nez !
Et le partron lui commande de faire autre chose !
Et le garçon ne trouve pas ça bien amusant.
Mais ainsi va la vie !

Comme Mozart, l'ordinateur, lui, n'est ni heureux ni malheureux ... à méditer.

La plus importante des instructions de C
for( ... ; ... ; ... ) { ... ; ... ; etc. }
for ( préparation ; condition de maintien ; faire après chaque action répétitive )
action répétitive ;

Pour reprendre le sanglant exempe précédent :

for (
Préparer travail, nombre de côtelettes coupées = zéro ;
nombre de côtelettes coupées inférieure à 60 ? ;
ajouter 1 au nombre de côtelettes coupées )
couper une côtelette ;

Dès que l'assertion nombre de côtelettes coupées inférieure à 60 est fausse le programme cesse de boucler et passe à la suite.


L'action répétitive peut parfois se décomposer en une suite d'actions :

for (
Préparer travail, nombre de côtelettes coupées = zéro ;
nombre de côtelettes coupées inférieure 60 ? ;
ajouter 1 au nombre de côtelettes coupées )
{
pousser la carcasse d'un cran vers le centre du billot ;
donner un coup de fusil à aiguiser au couteau ;
couper la côtelette ;
}

Les actions partielles constituant l'action répétitive doivent alors être mises entre accolades { }.

Résumons- nous ;

for ( préparation ; condition de maintien; faire après chage tour)
{
instruction ;
instruction ;
instruction ;
etc ...
}

Exemple

Souvenez-vous du programme fait précédemment pour illustrer les contenus des tableaux :

//essai.c
#include <stdio.h>

int main()
{
int n;
char TableauAMoi[7]; //Attention ce n'est plus 5 !

//Initialisation du tableau (affectation de chaque élément)
TableauAMoi[0] = 'S';
TableauAMoi[1] = 'a';
TableauAMoi[2] = 'l';
TableauAMoi[3] = 'u';
TableauAMoi[4] = 't';
TableauAMoi[5] = ' ';
TableauAMoi[6] = '!';

n = 0;
printf("Elément %i : valeur : %c\n",n,TableauAMoi[n]);
n = 1;
printf("Elément %i : valeur : %c\n",n,TableauAMoi[n]);
n = 2;
printf("Elément %i : valeur : %c\n",n,TableauAMoi[n]);
n = 3;
printf("Elément %i : valeur : %c\n",n,TableauAMoi[n]);
n = 4;
printf("Elément %i : valeur : %c\n",n,TableauAMoi[n]);
n = 5;
printf("Elément %i : valeur : %c\n",n,TableauAMoi[n]);
n= 6;
printf("Elément %i : valeur : %c\n",n,TableauAMoi[n]);

return 0;
}

On peut simplifier cosidérablement ce programme par utilisation de la boucle for( ...

//essai.c

#include <stdio.h>
#define MAX_TABLE 7

int main()
{

char TableauAMoi[MAX_TABLE] = {'S','a','l','u','t',' ','!'};
int n;

for(n = 0; n < MAX_TABLE; n = n+1)
printf("Elément %i : valeur : %c\n",n,TableauAMoi[n]);

return 0;
}
Exécution :
Elément 0 : valeur : S
Elément 1 : valeur : a
Elément 2 : valeur : l
Elément 3 : valeur : u
Elément 4 : valeur : t
Elément 5 : valeur :
Elément 6 : valeur : !

Quelques remarques de style de programmation :

L'étendue du tableau (nombre d'éléments) est ici symbolisée par la constante macro MAX_TABLE, plutôt que par le nombre 7.
C'est un bon principe de programmation : si on se ravise plus tard, il suffira de remplacer une seule fois :
#define MAX_TABLE 7 par #define MAX_TABLE 345 , par exemple, au lieu d'avoir à remplacer tous les 7 du programme par 345, ce qui risque d'être très dangereux car il y a peut être des nombres 7 qui n'ont rien à voir avec la taille de ce tableau.

L'initialisation du tableau se fait lors de la déclaration : c'est plus rapide.

La seule condition de préparation de la boucle "for" est ici n = 0;
La condition de maintien de la boucle est " n < 7 " : tant que n est inférieur à 7 il faut continuer à afficher
Après chaque affichage, il faut ajouter 1 à n, ce qui se fait par l'instruction : n = n + 1;

Observez attentivement le rôle du signe "égal" "=" en C.
Il permet d'affecter à la variable de gauche "n" la valeur de ce qui se trouve à droite du signe égal,
à savoir n + 1;
En C, et dans la plupart des langages, le signe égal n'a rien à voir avec l'égalité mais avec l'afféctation.


Boucle while( ...) { ...; ... ; ... }

Cette boucle a exactement les mêmes propriétés que la boucle for (... , mais elle s'écrit autrement.
Le but de faciliter l'écriture dans certains cas, mais on pourrait totalement s'en passer et la replacer par la structure for(... que nous avons déjà vue.

while ( condition de maintien)
{
instruction;
instruction.
etc.
}

Exemple :

//essai.c
#include <stdio.h>
#define MAX_TABLE 7

int main()
{
char TableauAMoi[MAX_TABLE] = {'S','a','l','u','t',' ','!'};
int n = 0;

while( n < MAX_TABLE)
{
printf("Elément %i : valeur : %c\n",n,TableauAMoi[n]);
n = n + 1;
}

return 0;
}

 


Boucle do { ... ; ... ; ... } while (condition de maintien) ;

Cette boucle a exactement les mêmes propriétés que la boucle for (... , ou la boucle while( ...mais elle s'écrit autrement.
Le but de faciliter l'écriture dans certains cas, mais on pourrait totalement s'en passer et la replacer par la structure for(... que nous avons déjà vue ou la boucle while (...

do
{
instruction;
instruction;
etc...
} while ( condition de maintien ) ;

Exemple :

//essai.c
#include <stdio.h>
#define MAX_TABLE 7

int main()
{
char TableauAMoi[MAX_TABLE] =
{'S','a','l','u','t',' ','!'};

int n = 0;

do
{
printf("Elément %i : valeur : %c\n",n,TableauAMoi[n]);
n = n + 1;
}while( n < MAX_TABLE) ;

return 0;
}

 

Instructions "break" et "continue"


Lorsqu'une boucle "for", "while", ou "do while" est engagée, il est possible :

  • de l'arrêter avec l'instruction "break"
  • de lui faire sauter un tour avec l'instruction "continue"

Exemples :

//essai.c
#include <stdio.h>
#define MAX_TABLE 7

int main()
{
char TableauAMoi[MAX_TABLE] =
{'S','a','l','u','t',' ','!'};

int n = 0;

do
{
if (n == 3) continue; // Voir explication ci-dessous
printf("Elément %i : valeur : %c\n",n,TableauAMoi[n]);
n = n + 1;
}while( n < MAX_TABLE) ;

return 0;
}
Exécution : la ligne "Element 3 : valeur : u" ne sera pas affichée
Elément 0 : valeur : S
Elément 1 : valeur : a
Elément 2 : valeur : l
Elément 4 : valeur : t
Elément 5 : valeur :
Elément 6 : valeur : !

Autre exemple avec break :

//essai.c
#include <stdio.h>
#define MAX_TABLE 7

int main()
{
char TableauAMoi[MAX_TABLE] =
{'S','a','l','u','t',' ','!'};

int n = 0;

while( n < MAX_TABLE )
{
if (n == 3) break;
printf("Elément %i : valeur : %c\n",n,TableauAMoi[n]);
n = n + 1;
}

return 0;
}

Exécution ::
Elément 0 : valeur : S
Elément 1 : valeur : a
Elément 2 : valeur : l

L'affichage s'arrêtera avant la ligne "Element 3 : valeur : u"


La suite : fonctions & procédures
Sommaire Langage C
Page d'accueil
Accueil

du site