Vous êtes sur la page 1sur 17

Chapitre II

LES INSTRUCTIONS ELEMENTAIRES ET LES


INSTRUCTIONS DE CONTRÔLES

I- Les instructions élémentaires

1. Description des unités lexicales

Le langage C comprend 6 types d'unités lexicales : les mots-clés, les identificateurs, les
constantes, les chaînes, les opérateurs et les caractères spéciaux (signes de ponctuation).

i- Les mots-clés
Le langage C est un langage à mots-clés, ce qui signifie qu'un certain nombre de mots sont
réservés pour le langage lui-même et ne peuvent donc pas être utilisés comme
identificateurs. La liste exhaustive des mots-clés est la suivante :

Auto const double float int short struct unsigned

Break continue else for long signed switch Void

Case default enum goto register sizeof typedef Volatile

Char do extern If return static union while

que l’on peut ranger en catégories


➢ les spécificateurs de stockage : auto, register, static, extern, typedef
➢ les spécificateurs de type : char, double, enum, float, int, long, short, signed, struct,
union, unsigned, void
➢ les qualificateurs de type : const, volatile
➢ les instructions de contrôle : break, case, continue, default, do, else, for, goto, if,
switch, while
➢ autres : return, sizeof

ii- Les identificateurs


Un identificateur est un nom donné à une variable pour la différencier de toutes les autres. Et
c’est au programmeur de choisir ce nom. Cependant, il y a quelques limitations à ce choix :
➢ Seuls les 26 lettres de l’alphabet latin (majuscules ou minuscules), le trait de
soulignement ‘‘_’’ ( underscore en anglais) et les chiffres sont acceptés. Pas d’accents,
pas de ponctuation, ni d’espaces ;
➢ Un identificateur ne peut pas commencer par un chiffre ;
➢ Les mots-clés ne peuvent pas servir à identifier une variable ;
➢ Deux variables ne peuvent avoir le même identificateur (le même nom). Il y a
cependant quelques exceptions, qui seront vues plutard ;
➢ Les identificateurs peuvent être aussi longs que l’on le désire, toutefois le compilateur
ne tiendra compte que des 63 premiers caractères.

NB : Le langage C fait la différence entre les majuscules et les minuscules (on dit qu’il
respecte la casse). Ainsi les trois identificateurs suivants sont différents.
1| dassy
2| Dassy
3| DaSsy

iii. Les Constantes


Nous avons :
➢ Les constantes entières

➢ Les constantes caractères


➢ Les constantes flottante

Exemple

iv. Les chaînes

v. Les opérateurs
Le langage C défini plusieurs types d’opérateurs : arithmétiques, relationnels ou de
comparaisons, logiques, d’affectation (affectation simple et affectation élargie), conditionnel
et les opérateurs d’incrémentation et de décrémentation.
Exemple:

vi. Les signes de ponctuation (les caractères spéciaux)

On note les caractères spéciaux (non imprimables) en commençant par \.

2. Les types de base du langage C


i. Le type entier
Le nombre d'octets utilisés pour coder un entier peut être un paramètre de compilation, selon
la plate-forme utilisée. Le mot clé int est utilisé pour caractériser des entiers. Il existe deux
types d’attributs pour le type entier: les attributs de précision et les attributs de
représentation.
Les attributs de précision sont : - short int ou short : entier codé sur 2 octets avec
pour format d'affichage : %d (ou %hd) ;- int: entier codé sur 2 ou 4 octets avec pour format
d'affichage : %d et - long int ou long : entier codé sur 4 octets avec pour format d'affichage :
%ld.
Les attributs de représentation encore appelés unsigned sont des entiers non
signés. Ce sont : unsigned short int codé sur 2 octets et de format d'affichage : %u ;
unsigned int codé sur 2 ou 4 octets et de format d'affichage : %u et unsigned long int ou
unsigned long : entier long positif avec pour format d'affichage : %lu. Le tableau
suivant détaille les informations pour chaque type entier.

ii. Le type flottant ou réel :

Les formats d'affichage sont respectivement : %f, %lf, %l. Les constantes numériques sont
par défaut de type double. Ci-dessous les informations pour chaque type flottant.

iii. Le type Caractère

Le format d'affichage est %c pour les caractères et %s pour les chaînes de caractères. Le
tableau suivant détaille les informations pour chaque type caractère.
3. Les variables
Une variable est un objet informatique qui associe un nom à une valeur qui peut
éventuellement varier au cours du temps.

Des données qui ne changent plus dans le programme, une fois initialisées sont appelées des
constantes.

4. Les constantes
i. Les #define

ii. Les énumérations


5. Principales fonctions d’entrées-sorties standard

Il s’agit des fonctions de la librairie standard stdio.h utilisées avec les unités classiques
d’entrées-sorties, qui sont respectivement le clavier et l’écran. Sur certains compilateurs,
l’appel à la librairie stdio.h par la directive au préprocesseur #include <stdio.h> n’est pas
nécessaire pour utiliser les fonctions présentées ici, notamment printf et scanf.

5.1. Les fonctions d’entrées


i. La fonction de saisie scanf

ii. La fonction getchar


5.2.La fonction de sortie
i. La fonction d’écriture formatée à l’écran printf()

ii. La function puts()

iii. La function putchar()


NB : Il existe d’autres fonctions d’entrées/sorties permettant notamment
la manipulation des fichiers qui seront abordées dans le chapitre sur les fichiers.

II- Les structures de contrôle

Les structures de contrôles (branchements conditionnels et boucles) permettent à un


programme de ne pas être purement séquentiel (chaine linéaire d’instruction).
La structure de contrôle SI…ALORS permet d’exécuter des instructions en fonction de la
valeur d’une condition (qui n’est rien d’autre que le résultat d’un test).

1. Structures conditionnelles

i. Structure IF if (condition) {
La syntaxe est la suivante : /* si la condition est vraie */

if (condition) instruction 1 ;
ou
/* si la condition est vraie */ ...
instruction n ;
instruction ; }

ii. Structure IF … ELSE


Il arrive assez souvent qu’en fonction de la valeur d’une condition, le programme doit
exécuter des instructions si elle est vraie et d’autres instructions si elle est fausse. Plutôt que
de tester une condition puis son contraire, il est possible d’utiliser la structure
SI…ALORS…SINON, donc la syntaxe et la suivante :
if (condition) {
if (condition) /* si la condition est vraie */
instruction1 1
/* si la condition est vraie */ ...
ou instruction1 n
instruction1 ; ou
} else {
else
/* si la condition est fausse */
/* si la condition est fausse */
instruction2 1
instruction2 ; ...
instruction2 n
}

iii. Structure SWITCH

2. Structures répétitives

i. Structure « while »
ou while (expression )
while(expression) {
instruction 1 ;
instruction;
...
instruction n ;
}
ii. Structure « do…while »

Do
{
Do instruction ; instruction 1 ;
ou ...
while (expression ); instruction n ;
}
while (expression );

iii. Structure « For »

for (expr 1 ;expr 2 ;expr 3)


for (expr 1 ;expr 2 ;expr 3) {
instruction 1 ;
ou
instruction ; ...
instruction n ;
}

Cette boucle comporte trois expressions : expr 1 ; expr 2 et expr 3. La première, expr 1 est
évaluée (une seule fois) avant d’entrer dans la boucle : c’est l’initialisation du compteur.
La deuxième, expr 2 conditionne la poursuite de la boucle. Elle est évaluée avant chaque
parcours. La troisième, expr 3 enfin, est évaluée à la fin de chaque parcours.

3. Les instructions de branchement non conditionnel


i. L’instruction break
L’instruction break au sein de la directive de branchement multiple switch a pour rôle de
terminer l’instruction. On peut l’utiliser plus généralement au sein de n’importe quelle
boucle (instructions for, while ou do...while) pour interrompre son déroulement et passer
directement à la première instruction qui suit la boucle. Sa syntaxe est la suivante :
break;
Exemple 1: L'instruction for ci-dessous est stoppée au premier i tel que t[i] est nul :
for (i = 0; i < N; i = i + 1) if (t[i] == 0) break;

Exemple 2: Le programme suivant :

ii. L’instruction continue


L’instruction continue ne peut être utilisée que dans le corps d’une boucle (for, while ou do).
L’utilisation de cette instruction provoque l'arrêt de l'itération courante, et le passage au début
de l'itération suivante. Sa syntaxe est la suivante: continue ;
Exemple : Le programme suivant :

iii. L’instruction goto


La directive goto permet de brancher directement à n’importe quel endroit de la fonction
courante identifiée par une étiquette. Une étiquette est un identificateur suivi du signe
”:”. L’instruction goto et la déclaration de l’étiquette doivent être contenu au sein de la
même fonction. Sa syntaxe est la suivante: goto etiquette ;
Exemple :

iv. L’instruction return


L'instruction return provoque la terminaison de l'exécution de la fonction dans laquelle elle se
trouve et le retour à la fonction appelante. Cette instruction peut être mise à tout moment dans
le corps d'une fonction ; son exécution provoque la fin de celle-ci. Cette instruction est
appelée de manière implicite à la fin d'une fonction. Le return permet de calculer une
valeur correspondant au type de sa fonction. Ce calcul se fait en évaluant
l'expression qui suit le return. L'expression est évaluée et la valeur calculée est retournée à
la fonction appelante. Lorsque la fonction est de type void, le return est utilisé sans
expression associée, dans le cas où la fonction est associée à un type qui n'est pas void, la
valeur calculée par le return est celle que retourne la fonction contenant le return. Les formes
possibles du return sont donc :
➢ return ;
➢ return expression ;

Il peut y avoir plusieurs return dans une fonction, le premier qui est exécuté dans le contexte
de la fonction provoque : le calcul de la valeur à retourner, la sortie de la fonction, la
continuation de l'exécution de la fonction appelante.