Ecole supérieure d’ingénierie informatique Suptechnology Casablanca

Cours de langage de
programmation C

Première année – Semestre 1

Année universitaire 2019-2020

Pr. Nadia BOUHRIZ
Généralités sur le

langage C

2
 1 Généralités dur le langage C

1.1 Rôle de Langage de programmation

Pour traiter automatiquement de l’information, la machine doit disposer d’un ou de plusieurs

programmes :

 Un programme est une suite d’instructions (opérations) que la machine peut exécuter
pour effectuer des traitements.

L'exécution d'un programme par l'ordinateur passe, en général, par les étapes suivantes :

 Le processeur extrait les données à traiter à partir de la source indiquée dans le

programme (soit auprès de l'utilisateur qui devrait les introduire au moyen du clavier,
soit en mémoire secondaire ou centrale).

 Il exécute, ensuite, la série d'opérations élémentaires de manière séquentielle (dans

l'ordre prévu par le programme) et mémorise tous les résultats intermédiaires.

 Il renvoie enfin le ou les résultats attendus à la destination (périphérique de sortie)

indiquée dans le programme.

Pour pouvoir effectuer un traitement donné, la machine doit donc disposer du programme
exécutable correspondant.

Ce programme doit se trouver en mémoire et doit être codé en binaire (langage machine).

Un langage de programmation est par définition différent du langage machine. Il faut donc le
traduire pour le rendre intelligible du point de vue du processeur

Les langages de programmation sont majoritairement de deux types : les langages interprétés
et les langages compilés.

1.2 Les langages interprétés et les langages compilés

Un programme écrit dans un langage interprété a besoin d'un programme auxiliaire

(l'interpréteur) pour traduire au fur et à mesure les instructions du programme.
Exemples de langages interprétés : Le langage HTML, le langage JAVA, etc.

Un programme écrit dans un langage dit compilé va être traduit une fois pour toutes par un
programme annexe : le compilateur, afin de générer un nouveau fichier qui sera autonome,

3
 c'est-à-dire qui n'aura plus besoin d'un programme autre que lui pour s'exécuter (on dit
d'ailleurs que ce fichier est exécutable).
Exemples de langages compilés : Le langage C, le langage C++, le Cobol, etc.

1.3 La langage de programmation C

Le langage C a été créé en 1972 par Denis Ritchie avec un objectif relativement limité : écrire
un système d’exploitation (UNIX).

Ses qualités opérationnelles l’ont très vite fait adopter par une large communauté de
programmeurs.

Le C est un langage compilé. Cela signifie qu’un programme C est décrit par un fichier texte,
appelé fichier source. Ce fichier n’étant évidemment pas exécutable par le processeur, il faut
donc le traduire en langage machine. Cette opération est effectuée par un programme appelé
compilateur.

1.4 Le processus de compilation

Le C est un langage compilé (par opposition aux langages interprétés). il faut donc le traduire
en langage machine par un programme appelé compilateur. La compilation se décompose en
fait en 4 phases successives :

 Edition du programme source (ou code source) à l’aide d’un éditeur (traitement de
textes). Le nom du fichier contenant le programme source a l’extension «.C » ou « .CPP
».

 Compilation du programme source : Le compilateur est un programme qui lit le texte

du fichier source et traduit ce texte en un fichier appelé fichier objet qui a l’extension
«.obj ». Pendant ce processus de traduction, le compilateur recherche les erreurs
courantes, les éléments manquants et d'autres problèmes. Si quelque chose ne va pas, le
compilateur affiche une liste d'erreurs. Pour corriger les erreurs, vous rééditez le code
source et essayez à nouveau de compiler.

 Editions de liens: c’est un outil qui crée le programme final (le fichier exécutable
d’extension « .exe »). Pour ce faire, il lie le fichier objet aux bibliothèques de langage C.
Les bibliothèques contiennent les instructions qui indiquent à l’ordinateur ce qu’il faut
faire. Ces instructions sont sélectionnées et exécutées en fonction des instructions
abrégées trouvées dans le code du fichier objet.

4
  Exécution du programme : après l’étape de l’édition de liens vient l’étape d'exécution
du résultat. L’exécution vise principalement à démontrer que le programme fait ce que
vous voulez et de la manière que vous désirez. Lorsque le programme ne fonctionne pas,
vous devez revenir en arrière et corriger le code. Il est tout à fait possible de créer un
programme sans aucune erreur, puis de constater que le programme ne fonctionne pas (ne
donne pas le résultat désiré).

1.5 L’environnement de développement intégré : DEV C++

Pour réaliser un programme C, deux méthodes peuvent être utilisées :
 La première méthode dont un programme en langage C est exécuté c’est d’utiliser les
outils cités dans le processus de compilation d’une façon distincte sur une ligne de
commande.

5
  La deuxième méthode consiste à utiliser un environnement de développement intégré
(integrated development environment) abrévié en IDE. Il regroupe tous les outils dont
avez besoin pour programmer dans une unité compacte, terrifiante et intimidante.

L’IDE est utilisé pour écrire du code, le compiler, et ensuite l’exécuter.

L’utilisation d'un IDE résout également la multitude de problèmes liés à la configuration d'un
compilateur, à la configuration de l'éditeur de texte et à la mise en synergie de tous ces
éléments.

Dans ce cours, l’IDE utilisé sera Dev-C++ dont l’interface se présente ainsi :

1.6 Eléments de base du langage C

Un programme en langage C est constitué de composants élémentaires suivants :
 Les identificateurs,
 Les mots-clefs,
 Les constantes,
 Les opérateurs, délimiteurs et séparateurs
On peut ajouter à ces six groupes les commentaires, qui sont enlevés par le préprocesseur.

1.6.1 Les identificateurs

Les identificateurs servent à désigner les différents « objets » manipulés par le programme :
variables, fonctions, etc.

Comme dans la plupart des langages, ils sont formés d’une suite de caractères choisis parmi
les lettres ou les chiffres, le premier d’entre eux étant nécessairement une lettre.

L'emploi des identificateurs doit répondre à un certain nombre d'exigences :

6
  Un identificateur doit être composé indifféremment de lettres et chiffres ainsi que du
caractère de soulignement ( _ ) qui peut remplacer des espaces.

 Un identificateur doit commencer par une lettre

 Seuls les 32 premiers caractères (parfois, uniquement les 8 premiers) sont significatifs
(pris en compte par le compilateur).

 Majuscules et minuscules donnent lieu à des identificateurs différents.

 Un identificateur ne doit pas être un mot réservé (utilisé dans le langage C comme int,
char, …).

Exemples
 « solution1 » est un identificateur valide (constitué de lettres et de 1)
 « 1solution » n'est pas un identificateur valide.
 « prix unitaire » n'est pas un identificateur valide (il contient un espace).
 « prix_unitaire » est un identificateur valide.
 « jour », « Jour »et « JOUR » sont 3 identificateurs différents
 int n'est pas un identificateur valide. C'est un mot utilisé (mot clé) en C

1.6.2 Les mots clés

Certains « mots-clés » sont réservés par le langage à un usage bien défini et ne peuvent pas
être utilisés comme identificateurs. En voici la liste, classée par ordre alphabétique.

1.6.3 Les constantes

Les constantes entières
La façon la plus naturelle d’introduire une constante entière dans un programme est de
l’écrire simplement sous forme décimale, avec ou sans signe, comme dans ces exemples :
+533 48 -273

Il est également possible d’utiliser une notation octale ou hexadécimale.

Les constantes flottantes

Comme dans la plupart des langages, les constantes flottantes peuvent s’écrire
indifféremment suivant l’une des deux notations :

7
  décimale,
 exponentielle.
La notation décimale doit comporter obligatoirement un point (correspondant à notre
virgule).

La partie entière ou la partie décimale peut être omise (mais, bien sûr, pas toutes les deux en
même temps !).

En voici quelques exemples corrects :

12.43 -0.38 -.38 4. .27

 La notation exponentielle utilise la lettre e (ou E) pour introduire un exposant entier

(puissance de 10), avec ou sans signe, par exemple : 8.077e+12 ⇔ 8.077 ×
1012
 La mantisse (8.077 dans l’exemple précédent) peut être n’importe quel nombre
décimal ou entier
o le point peut être absent dès que l’on utilise un exposant

Voici quelques exemples corrects :

o les exemples d’une même ligne étant équivalents :

4.25E4 4.25e+4 42.5E3

54.27E-32 542.7E-33 5427e-34
48e13 48.e13 48.0E13

Les constantes de type caractère

Les constantes de type « caractère », lorsqu’elles correspondent à des caractères imprimables,

se notent de façon classique, en écrivant entre apostrophes (ou quotes) le caractère voulu,
comme dans ces exemples :

 'a', 'Y', '+', '$',

Certains caractères non imprimables possèdent une représentation conventionnelle utilisant le

caractère « \ », Dans cette catégorie, on trouve également quelques caractères (\, ’, " et ?)
qui, bien que disposant d’un graphisme, jouent un rôle particulier de délimiteur qui les
empêche d’être notés de manière classique entre deux apostrophes. Voici la liste de ces
caractères.

8
 De plus, il est possible d’utiliser directement le code du caractère en l’exprimant, toujours à
la suite du caractère « antislash \ » :
 soit sous forme octale,
 soit sous forme hexadécimale précédée de x.
Voici quelques exemples de notations équivalentes, dans le code ASCII :

Remarque
Les constantes chaînes de caractères doivent être entourées de guillemets, par exemple
"bonjour"

1.6.4 Opérateurs, délimiteurs, et séparateurs

Les opérateurs, délimiteurs et séparateurs en C sont formés à partir des divers caractères qui
ne sont pas utilisés par les identificateurs. La table ci-dessous indique toutes les séquences
utilisées :

9
 On trouve, dans la table :

 des opérateurs classiques comme : + (addition) , / (division), etc. (ligne 1),

 des opérateurs de comparaisons (ligne 4) avec en particulier != (différent de) et ==

(égal à).

 Certains symboles combinent un opérateur et une affectation (lignes 2 et 3).

 Enfin, # et ## sont des opérateurs qui s’adressent au préprocesseur (le compilateur)

 Etc.

1.7 Structure minimale d’un programme C

Un programme simple se compose de plusieurs parties:

 Des directives de précompilation.
 Une ou plusieurs fonctions dont l’une s’appelle obligatoirement main(), celle-ci
constitue le programme principal et comporte 2 parties : la déclaration de toutes les
variables et les instructions.
 Les commentaires: débutent par “ /* ” et finissent par “ */ “

[directives au préprocesseur]

[déclarations de variables externes]

[fonctions secondaires]

main()

{
<déclarations de variables>

<Instructions à exécuter>

main () indique qu'il s'agit du programme principal.

{ et } jouent le rôle de début et fin de programme.
Printf est l'instruction d'affichage à l'écran, le message étant entre guillemets.
; indique la fin d'une instruction

10
 Chapitre 1

Les variables et les instructions

d’entrées/sorties

Dans ce chapitre, nous présentons :

 Les variables, leur déclaration, et leur type
 Les opérateurs
 Les instructions d’entrées-sorties

11
Chapitre 1 : Les variables, valeurs et opérateurs

1 Les variables
Les variables sont les données que manipulera le programme lors de son exécution. Ces
variables sont rangées dans la mémoire vive de l’ordinateur. Les variables doivent être
déclarées au début du programme.

1.1 Déclaration des variables

Pour déclarer une variable, on fait précéder son nom par son type.
Syntaxe

<Type> <NomVar1>, <NomVar2>, ..., <NomVarN>;

1.2 Les types des variables

Un type est un ensemble de valeurs que peut prendre une variable. Il y a des types prédéfinis
et des types qui peuvent être définis par le programmeur.
La table qui suit permet de trouver le domaine des valeurs selon le type, en combinant
l’information sur la taille-mémoire :

Type signification Taille Domaine de valeurs

mémoire
int Entier 2 octets -32 767 à 32 767
short Entier 2 octets -32768 à 32767
long Entier en double longueur 4 octets -2 147 483 647 à 2 147 483 647
float Réel 4 octets ± 10-37 à ± 1038
double Réel en grande précision 8 octets ± 10-307 à ± 10308
Long double Réel en très grande précision 10 octets ± 10-4932 à ± 104932

 Tous les types cités auparavant peuvent être précédé par le qualificatif dits unsigned
(non signés) qui signifie qu’on peut stocker que des nombres positifs : unsigned int,
unsigned short, unsigned long, unsigned float, unsigned double, unsigned long double

 Les unsigned sont des types qui ont le défaut de ne pas pouvoir stocker de nombres
négatifs, mais l'avantage de pouvoir stocker des nombres deux fois plus grands (int
peut représenter de -32 767 à 32 767, tandis qu’unsigned int va de 0 à 65 535).

 char: est le type de données le plus fondamental en C. Il stocke un seul caractère et

nécessite un seul octet de mémoire dans presque tous les compilateurs.

12
Exemples
Les trois instructions suivantes sont des déclarations des variables :

int j, j, k;
int al, a2;
float x;
double xl, x2;
char a;

1.3 L’opérateur sizeof

L’opérateur sizeof() renvoie le nombre d’octets réservés en mémoire pour chaque type
d’objet sur la plateforme utilisée.

Syntaxe

Taille_objet = sizeof(Type);

Exemple

n = sizeof(char);
Résultat : n=1

1.4 Définir un nouveau type

typedef: Transforme la déclaration d’une variable en déclaration d’un nouveau type.

Syntaxe

typedef déclaration;

Exemple

Typedef int Entier;

Typedef float moyenne;

1.5 Déclaration des constantes

En utilisant l’attribut const, nous pouvons indiquer que la valeur d’une variable ne change
pas au cours d’un programme

Syntaxe

Const type nom_variable ;

13
 Exemple

Const int x=200 ;

Const double e = 4.715 ;

Const char a =’t’ ;

2 Les opérateurs

2.1 Les opérateurs arithmétiques

+ Addition
- Soustraction
* Multiplication
/ Division
% Reste de la division

Remarque
Le résultat d’une opération entre types différents se fait dans le type le plus haut. Les types
sont classés ainsi : char < int <long < float <double

Exemple

int pl, p2, p3;

float X;

p1 * p2 + p3 * x

int int int float

*
*

int + float

float

En C comme dans les autres langages, lorsque plusieurs opérateurs apparaissent dans une
même expression, les règles sont naturelles et rejoignent celles de l’algèbre traditionnelle.
a + b * c a + (b * c)
a * b + c % d (a * b) + (c % d)
-c % d (-c) % d
-a + c % d (- a) + (c % d)
-a / - b + c ((-a)/(-b))+c
-a / - (b + c) (-a)/(-(b+c))
14
 2.2 Les opérateurs de conversion de type

II est possible de convertir explicitement une valeur en un type quelconque en forçant la

transformation à l’aide de la syntaxe suivante :

Syntaxe

(<Type>) <Expression>;

Exemple

int A=3;
int B=4;
float C, D;
C = (float)A/B;
D = (float)(A/B+A);

2.3 Les opérateurs relationnels

Les opérateurs de comparaison sont :

x == y x est égal à y
x != y x est différent de y
x > y x est plus grand que y
x < y x est plus petit que y
x >= y x est plus grand que, ou égal à y
x <= y x est plus petit que, ou égal à y

Remarque

Le résultat de la comparaison est, non pas une valeur ”booléenne” prenant l’une des deux
valeurs vrai ou faux, mais un entier valant :
 0 si le résultat de la comparaison est faux.
 1 si le résultat de la comparaison est vrai.

2.4 Les opérateurs logiques

Les trois opérateurs logiques classiques :

&& ET
││ OU
`! NON

15
 Exemple

(a<b) && (c<d)

(a<b)││(c<d)
!(a<b)

2.5 Les opérateurs d’incrémentation

++ incrémente la variable d’une unité.

-- décrémente la variable d’une unité.

Exemple

i++ ⇒ i = i + 1
i-- ⇒ i = i - 1

Remarque

Ces 2 opérateurs ne s’utilisent pas avec de réels.

2.6 Les opérateurs d’incrémentation élargie

X = I++ passe d’abord la valeur de I à X et incrémente après

X = I-- passe d’abord la valeur de I à X et décrémente après
X = ++I incrémente d’abord et passe la valeur incrémentée à X
X = ++I décrémente d’abord et passe la valeur décrémenté à X

Exemple

j=i++; ⇒ j=i et ensuite i=i+1

j=++i; ⇒ i= i+1 ensuite j = i
i+=5; ⇒ i= i+5
i-=3 ; ⇒ i=i-3
i*=4 ; ⇒ i=i*4
i/=2 ; ⇒ i=i/2
i*=a ; ⇒ i=i*a

16
3 Les instructions d’entrées-sorties

3.1 La fonction de sortie : printf()

L’instruction printf() (de la bibliothèque stdio.h) permet d’afficher des informations à l’écran

Syntaxe

printf(”chaîne de caractères”, variables);

La chaîne de caractères peut contenir des caractères spéciaux:

 \n pour le retour à la ligne

 \t pour les tabulations

Exemples

printf(”liste des variables: \n”);

printf(”variable 1: ”);

Si des variables suivent la chaîne de caractères, on doit spécifier comment présenter ces
variables, autrement dit, on doit spécifier la chaine de formatage de ces variables
Forma Types signification
ts
%c Char Caractère
%s Char Chaîne de caractères
%d Int Entier signé
%u Unsigned int Entier non signé (positif)
%hd Short Entier court
%hu Unsigned short Entier court non signé
%ld Long int Entier long signé
%lu Unsigned long int Entier long non signé
%f Float Réel, notation avec le point décimal (ex:13.15)
%e Float Réel, notation exponentiel (ex : 0.123E+03)
%lf Double Réel en double précision avec le point décimal
%le Double Réel en double précision, notation exponentielle

17
Exemple

int i=l;
int j=2;
printf (“la somme de i et j est:\n”);
printf (“i = %d \t j= %d \n”,i,j);

printf (“i+j %d “,i+j);

Affichage sur l’écran

la somme de i et j est:
ì = l j = 2
i+j = 3

Remarque

Le caractère % indique la chaine de formatage c’est-à-dire le format d’écriture à l’écran. Dès

qu’un format est rencontré dans la chaîne de caractère entre " ", le programme affiche la
valeur de l’argument correspondant.

3.2 La fonction d’entrée : scanf()

La fonction scanf() (de la bibliothèque stdio.h) permet de lire la valeur que l’utilisateur saisi
au clavier et de la stocker dans la variable donnée en argument.

Syntaxe

scanf(”chaîne de formatage”, &variable1, &variable2,…… );

 La chaîne de formatage spécifie le type des données attendues

 Pour éviter tout risque d’erreur, on lit et on écrit une même variable avec le même
format
 Le & est indispensable pour le bon fonctionnement de la fonction. Il indique l’adresse
de la variable.

Exemple

char a;
int j;
float r;
scanf(”%c”,&a); /* saisie d’un caractère */
scanf(”%d”,&i); /* saisie d’un nombre entier en décimal */
scanf(”%f”,&r); /* saisie d’un nombre réel */

18
Exercice:

Compiler et exécuter le programme suivant :

#include <stdio.h> /* bibliothèque d’entrées-sorties standard */

#include <math.h>
main()
{
int a, b, som ; /* déclaration de 3 variables */
a = 10 ;
b = 50 ;
som = a + b ; /* affectation et opérateurs */
printf( ” Voici le résultat : %d”, som); /*affichage du résultat sur l’écran*/
}

19
 Chapitre 2

Les instructions de

contrôle

Dans ce chapitre, nous présentons les instructions de contrôle en langage C qui se

distinguent en deux catégories :
 Les instructions sélectives (de test)
→ if
→ switch
 Et les instructions répétitives (de boucle)
→ while
→ do…while
→ for

20
 Chapitre 2 : Les instructions de contrôle
Les instructions de contrôle sont des instructions qui permettent de faire des tests et des
boucles dans un programme.
1. L’instruction if
2. L’instruction switch
3. L’instruction while
4. L’instruction do-while
5. L’instruction for

1 Les instructions sélectives

1.1 L’instruction if

if est une instruction qui permet d’effectuer un traitement selon la condition ou l’expression
logique.

Syntaxe

if (expression_logique)
{
bloc d’instructions_1;
}
else
{
bloc d’instructions_2;
}

 Si <l’expression_logique> fournit une valeur 1 (condition vraie), alors le bloc

d’instructions_1 est éxécuté
 Si <l’expression _logique> fournit la valeur zéro, alors le <bloc d’instruction_2> est
exécuté

Exemple

if (note_module <10)
printf(”Attention vous avez un rattrapage”);
else
printf(”vous avez validé le module”);

21
1.2 L’instruction if imbriquée

Syntaxe

if(expression_logique 1)

instruction 1;

else if (expression_logique 2)

instructions 2;

else
instruction 3;

Exercice

Ecrire un algorithme qui permet de résoudre l’équation du second degré ax2+bx+c, les trois
coefficients a, b, et c seront saisis au clavier avant le traitement.

1.3 L’instruction switch

Syntaxe

Switch(n)
{
Case constant_1: [suite_d’instructions_1]
Break;
Case constante_2: [suite_d’instructions_2]
Break;
…………………………………………………………………………………………………
case constante_n: [suite_d’instructions_n]
break;
Default: [suite_d’instructions]
}

Principe

1. Evaluer l’expression figurant après le mot switch

2. Rechercher dans le bloc qui suit une étiquette « case x » correspondante à la valeur ainsi
obtenue :
a. Si c’est le cas, on se branche à l’instruction qui suit l’étiquette
b. Dans le cas contraire, on se branche au traitement qui suit l’étiquette default

22
 Exemple

main()
{
int n ;
printf (“donnez un entier : “) ;
scanf (“%d”, &n) ;
switch (n)
{
case 0 : printf (“nul\n”) ;
break ;
case 1 : printf (“un\n”) ;
break ;
case 2 : printf (“deux\n”) ;
break ;
default : printf (“grand\n”) ;
}
printf (“ fin”) ;
}

Résultat 1

donnez un entier: 2
deux

fin

Résultat 2

donnez un entier : 25
grand
Fin

2 Les instructions répétitives

2.1 L’instruction while

La structure while correspond tout à fait à la structure tant que du langage algorithmique.

Syntaxe

while (expression_logique)
{
bloc d’instructions
}

23
 Principe

 Tant que l’expression fournit la valeur 1, le bloc d’instructions est exécuté.

 Si l’expression fournit la valeur zéro, on sort de la boucle

Exemple

int j = 1;
while (j < 10)
{
printf(”\n i = %d”, i);
i++;
}

2.2 L’instruction do - while

La structure do - while est semblable à la structure while, avec la différence suivante:

 while évalue la condition avant d’exécuter le bloc d’instructions,
 do - while évalue la condition après avoir exécuté le bloc d’instructions. Ainsi le bloc
d’instructions est exécuté au moins une fois.

Syntaxe

Do
{
bloc instructions
}

while (expression_logique);

Exemple (demander un nombre entre 1 et 10 jusqu’à ce que la réponse convienne)

int N;
do
{
printf(”Introduisez un nombre entre 1 et 10 :“);
scanf(” %d”, &N);
}
while (N < l ││ N > 10);

24
2.3 Instruction for

Syntaxe

for(initialisation; condition de
continuité; modification)
{
Bloc instructions
}

Exemples

for(i=l; i<10; i++)

printf(“\n i = %d”, i);

for(a=10; a>1; a—-)

printf(”\n a = %d, i);

Remarque
L’expression

for (expression_1 ; expression_2 ; expression_3)

instructions;

Est équivalent à

Expression_1 ;
while (expression_2)
{
instructions ;
expression_3;
}

25
 Exemple

La boucle suivante :

for(i=1; i<10; i++)

printf(”\n j = %d “, i);

est équivalent à :

int j = 1;
while (j < 10)
{
printf(”\n i = %d “, i);
j++;
}

Exercice
Ecrire un programme qui calcul a n

2.4 Comparaison entre les boucles

3 Les instructions de branchement inconditionnel

Les trois instructions de branchement inconditionnel sont :
1. break
2. continue
3. goto

Les deux premières s’emploient principalement au sein de boucles tandis que la dernière est
d’un usage libre

26
3.1 L’instruction break

L’instruction break sert à interrompre le déroulement de la boucle, en passant à l’instruction

qui suit cette boucle, cette instruction n’a d’intérêt que si son exécution est conditionnée par
un choix. En cas de boucles imbriquées, break fait sortir de la boucle la plus interne.

Exemple

main()
{
int j;
for (j = 0; j < 5; i++)
{
printf(”i = %d \n”, i);
if (j == 3)
break;
}
printf(”valeur de j a la sortie de la boucle est : %d\n”, j) ;
}

Résultat

i = 0
i = 1
i = 3
valeur de i a la sortie de la boucle est : 3

3.2 L’instruction continue

L’instruction continue permet de passer brusquement à l’itération de la boucle suivante sans

exécuter les autres instructions de la boucle.

Exemple

main()
{
int i;
for (i=0; i<5; i++)
{
if (j == 3)
continue;
printf(”i = %d \n”, i);
}
printf(”valeur de i a la sortie de la boucle est : %d \n”, i) ;}

27
 Résultat

i = 0
i = 1
i = 2
ì = 4
valeur de i a la sortie de la boucle est : 5

3.3 L’instruction goto

L’instruction goto permet le branchement en un emplacement quelconque du programme.

Celle-ci doit avoir été étiquetée (précédée d'une étiquette constituée d'un identificateur suivi
de :)

Exemple

main ()
{
int j ;
for ( i=l ; i<=10 ; i++ )
{
printf(“debut iteration %d\n”, j);
printf(“bonjour\n”);
if ( i==3 ) goto sortie;
printf (“fin iteration %d\n”, i);
}
sortie : printf(“apres la boucle”) ;
}

Résultat

debut iteration 1
bonjour
fin iteration 1
debut iteration 2
bonjour
fin iteration 2
debut iteration 3
bonjour
apres la boucle

28