Une instruction élémentaire est une expression suivie d’un point-virgule, comme par exemple :
x++ ;
Premier = 1 ;
Plus précisément, la syntaxe d’ une instruction élémentaire est :
Instruction-élémentaire : expression ;
Il est également possible de former une instruction vide, consistant simplement en un point-virgule. Elle représente un intérêt lors de l’utilisation des structures de contrôle. Par exemple, le corps de la boucle suivante :
for(p = debut_mot ; *p != ‘\0’ ; p++)
;
est une instruction vide.
2- Blocs
Un bloc est un regroupement de déclarations et d’instructions. Il est délimité par une paire d’accolades. La liste des déclarations doit précéder la liste des instructions. Les deux listes peuvent être vides. La syntaxe d’un bloc est :
bloc :
{
| liste de declarations |
| liste d’instructions |
}
Une simple paire d accolade {} est un bloc vide.
3- Structures de contrôle
Les structures de contrôle du langage C sont très classiqeus : le test, l’aiguillage et diverses formes d’itérations.
• Test
La syntaxe du test est :
instruction-test : if (expression)
partie-alors
[ else
partie-sinon ]
La « partie alors » et la « partie sinon » du test peuvent être indifféremment une instruction ou un bloc. La « partie sinon » est optionnelle. Si la valeur de l’expression entre parenthèses est vrai alors on execute : « partie alors » ; si la valeur de l expression entre parenthèses est fausse alors on execute le test qui comporte « partie sinon ».
if (x > 0 )
ecrire(« positif ») ;
else
ecrire(« nul ou negatif)
On peut ameliorer cet exemple en imbriquant les test c'est-à-dire :
Une instruction d’aiguillage permet de tester la valeur d’une expression parmi un ensemble de constantes. La définition syntaxique que nous retiendrons pour l’aiguillage est la suivante :
On appelle champ de l’aiguillage une liste d’instructions entre deux étiquettes. L’expression de contrôle de l’aiguillage et les expressions constantes figurant après un case doivent être du type intégral. Toutes les expressions constantes doivent être différentes. Une liste d’instructions peut être vide.
• Iterations
Il existe trois formes d’itérations : les deux boucles « tant-que » et une boucle « pour »
Boucles tant-que. Les deux bouvles tant-que sont la boucle while et la boucle do-while. La syntaxe de ces instructions est :
instruction-tantque : while (expression)
corps-de-boucle
instruction-tantque : do
corps-de-boucle
while (expression) ;
La construction corps-de-boucle peut-être indifféremment une instruction ou un bloc. La sémantique de ces instructions est la sémantique habituelle :
while : tant que la valeur de l’expression de contrôle est non nulle, le corps de boucle est exécuté ;
do : le corps de boucle est éxécuté tant que la valeur de l’expression de contrôle est differente de 0 ( c'est-à-dire lorsque l’expression de contrôle est vrai).
Boucle pour. La syntaxe de la boucle pour est :
boucle-pour : for ([expr1] ;[expr2] ;[expr3]...)
corps-de-boucle
expr1 : C’est l’initialisation de la boucle for.
expr2 : C’est la « clause d’exécution » (tant que expr2 est vrai alors on continue..)
expr3 : En general c’est une incrémentation ou une décrementation.
Exemple :
for( i=0 ; i < 10 ; i++)
corps-de-boucle
Cette boucle for, s’initialise a 0, compare la valeur de i avec 10, et si i<10 alors on augmente i de 1 (i++).
En conclusion les trois expressions jouent le rôle respectivement d’expression d’initialisation, de test d’arrêt, et d’incrémentation.
• Echappements
La forme la plus générale de l’échappement est la sortie de n blocs imbriqués. Cet échappement est partiellement implémentée en C sous la forme de deux instructions :
continue : passage a l’itération suivante de la boucle englobante la plus proche ;
break : sortie de la boucle ou de l’aiguillage englobants le plus proche.
Une troisième façon d’effectuer un saut est d’exécuter l’instruction return dans une fonction. Cette instruction, qui permet de sortir du bloc principal d’une fonction, est de nature légèrement différente des deux précédentes. En effet, le retour de fonction est une opération dynamique : l’adresse de l’instruction suivante à exécuter, c'est-à-dire l’adresse de retour, est contenue dans la pile d’exécution du processus. Par contre, les sauts provoqués par les instructions break et continue sont statiques : les adresses de branchement sont déterminées à la compilation.
La syntaxe de ces trois instructions est :
instrcution-saut : continue ;
break ;
return [expression] ;
On remarquera que l’utilisation de l’instruction continue, ainsi que celle de l’instruction break , incite à construire le programme de façon à traiter d’abord les cas triviaux afin de les éliminer.
• Branchement
Le branchement est à utiliser avec la plus grande prudence. Cependant, il est parfois utile pour simuler des échappements non implementés en C.
Un branchement s’effectue sur une instruction étiquetée. La syntaxe du branchement est
instruction-branchement : goto étiquette ;
L’étiquette doit être situé dans la même fonction que le branchement.
Le branchement ne devrait être utilisé que lorsque les instructions break et continue sont insuffisantes. Par exemple, une utilisation classique du saut est la gestion d’erreurs, avec interruptions du traitement (goto erreur) ou reprise (goto debut).
------------------------------------------------------------------------------------
Source :
Méthodologie de la programmation en C : Jean-Pierre Braquelaire
Home
