Programmation en langage C

1
 Langage informatique

▪ Un langage informatique est un outil permettant de donner des

ordres (instructions) à la machine
• A chaque instruction correspond une action du processeur

▪ Intérêt : écrire des programmes (suite consécutive d’instructions)

déstinés à effectuer une tache donnée

Exemple: un programme de gestion de comptes bancaires

▪ Contrainte: être compréhensible par la machine

2
 Langage machine
▪ Langage binaire: l’information est exprimée et manipulée sous
forme d’une suite de bits

▪ Un bit (binary digit) = 0 ou 1 (2 états électriques)

▪ Une combinaison de 8 bits= 1 Octet →28 = 256 possibilités qui

permettent de coder tous les caractères alphabétiques, numériques,
et symboles tels que ?,*,&, …

• Le code ASCII (American Standard Code for Information

Interchange) donne les correspondances entre les caractères
alphanumériques et leurs représentation binaire
Ex A= 01000001
▪ Les opérations logiques et arithmétiques de base (addition,
multiplication, … ) sont effectuées en binaire
3
Langage bas niveau : l'assembleur

▪ Problème: le langage machine est difficile à

comprendre par l'humain

▪ Idée: trouver un langage compréhensible par l'homme

qui sera ensuite converti en langage machine
▪ Assembleur : exprimer les instructions élémentaires
de façon symbolique
ADD A, 4
LOAD B traducteur langage
MOV A, OUT machine

• + : déjà plus accessible que le langage machine

• - : dépend du type de la machine (n’est pas portable)
• - : pas assez efficace pour développer des applications
complexes  Apparition des langages évolués 4
 Langage haut niveau
▪ Intérêts multiples pour le haut niveau:
- proche du langage humain (compréhensible)
- permet une plus grande portabilité (indépendant du matériel)
- Manipulation de données et d’expressions complexes (réels, objets,
…)
▪ Nécessité d’un traducteur (compilateur/interpréteur), exécution plus ou
moins lente selon le traducteur

Code source Compilateur ou

Langage
en langage interpréteur machine
évolué

5
 Compilateur/interpréteur
▪ Compilateur: traduire le programme entier une fois pour toutes
Compilation
exécution
exemple.c exemple
fichier source fichier objet fichier exécutable

• + : plus rapide à l’exécution

• + : sécurité du code source
• - : il faut recompiler à chaque modification

▪ Interpréteur: traduire au fur et à mesure les instructions du programme

à chaque exécution
Interprétation+exécution
exemple.bas
fichier
source

• + : exécution instantanée appréciable pour les débutants

• - : exécution lente par rapport à la compilation
6
Langages de programmation

▪ Deux types de langages:

• Langages procéduraux
• Langages orientés objets

▪ Exemples de langages:
• Fortran, Cobol, Pascal, C, …
• C++, Java, …

7
 Historique du C
▪ Le langage C a été conçu en 1972 dans «Bell Laboratories » par
Dennis Ritchie avec l’objectif d’écrire un système d'exploitation
(UNIX).

▪ En 1978, une première définition rigoureuse du langage C (standard

K&R-C) a été réalisée par Kernighan et Ritchie en publiant le livre
«The C Programming Language ».

▪ Le succès du C et l’apparition de compilateurs avec des extensions

particulières ont conduit à sa normalisation.

▪ En 1983, l’organisme ANSI (American National Standards Institute)

chargeait une commission de mettre au point une définition explicite
8
et portable pour le langage C. Le résultat est le standard ANSI-C.
 Caractéristiques du C

▪ Universel : n'est pas orienté vers un domaine d'application particulier

(applications scientifiques, de gestion, …)

▪ Près de la machine : offre des opérateurs qui sont proches de ceux du

langage machine (manipulations de bits, d’adresses, …) → efficace

▪ Modulaire: peut être découpé en modules qui peuvent être compilés

séparément

▪ Portable: en respectant le standard ANSI-C, il est possible d'utiliser le

même programme sur plusieurs systèmes (hardware, système
d'exploitation )

9
Programme source, objet et
exécutable
▪ Un programme écrit en langage C forme un texte qu’on nomme
programme ou code source, qui peut être formé de plusieurs fichiers
sources

▪ Chaque fichier source est traduit par le compilateur pour obtenir un

fichier ou module objet (formé d’instructions machine)

▪ Ce fichier objet n’est pas exécutable tel quel car il lui manque les
instructions exécutables des fonctions standards appelées dans le
fichier source (printf, scanf, …) et éventuellement d’autres fichiers
objets

▪ L’éditeur de liens réunit les différents modules objets et les

fonctions de la bibliothèque standard afin de former un programme
exécutable
10
 Compilateurs C
▪ Pour pouvoir écrire des programmes en C, vous avez besoin d’un
compilateur C sur votre machine

▪ Il existe plusieurs compilateurs respectant le standard ANSI-C.

Une bonne liste est disponible sur :
c.developpez.com/compilateurs/

▪ Nous allons utiliser l'environnement de développement Dev-C++

avec le système d’exploitation Windows

▪ Vous pouvez télécharger Dev-C++ librement, par exemple sur le

site www.bloodshed.net

11
Exemple d’une fenêtre Dev-C++

12
 Objectifs
◼ Être capable de bien programmer

◼ Comprendre les différentes constructions de

la programmation en C

◼ Savoir programmer de manière modulaire

13
Qualités attendues d'un
programme

◼ Clarté
◼ Simplicité
◼ Efficacité
◼ Modularité
◼ Extensibilité

14
 Structure d'un programme C
#include <stdio.h>
#define DEBUT -10 Directives du préprocesseur :
#define FIN 10 accès avant la compilation
#define MSG "Programme de démonstration\n"
int fonc1(int x);
int fonc2(int x); Déclaration de prototypes de
fonctions
void main()
{ /* début du bloc de la fonction main*/
int i; /* définition des variables locales */
Programme
i=2; principal
printf(“%d\n”, fonc1(i)) ;
printf(“%d\n”,fonc2(i)) ;
} /* fin du bloc de la fonction main */
int fonc1(int x) {
return x; Définition de
}
fonctions
int fonc2(int x) {
return (x * x);
}
15
 TYPE de la valeur de retour

"main" : Cela signifie "principale",

ses instructions sont exécutées.

int main(void)
{
void main(void): La fonction main ne prend
/* corps du programme*/
begin aucun paramètre et ne retourne pas de valeur.
declaration des Cstes et Var ;
instruction1 ; int main(void): La fonction main retourne une
valeur entière à l'aide de l'instruction return (0
instruction2 ; si pas d’erreur).
….
int main(int argc, char *argv[]): On obtient
}
alors des programmes auxquels on peut
end adresser des arguments au moment où on lance
le programme.
Entre accolades "{" et "}" on
mettra la succession d'actions à
réaliser.(Bloc)

16
Types de base
4 types de base, les autres types seront dérivés de ceux-ci.

Type Exemples de valeur Codage en Peut être

Signification
mémoire
'a' 'A' 'z' 'Z' '\n' 'a' 'A'
1 octet signed,
char Caractère unique 'z' 'Z' '\n'
unsigned
Varie de –128 à 127
Short, long,
0 1 -1 4589 32000
int Nombre entier 2 ou 4 octets signed,
-231 à 231 +1
unsigned
Nombre réel 0.0 1.0 3.14 5.32
float 4 octets
simple -1.23

Nombre réel 0.0 1.0E–10 1.0 -

double 8 octets long
double précision 1.34567896

17
 Préprocesseur
Le préprocesseur effectue un prétraitement du programme source avant qu'il soit compilé.
Ce préprocesseur exécute des instructions particulières appelées directives.
Ces directives sont identifiées par le caractère # en tête.

Inclusion de fichiers
#include <nom_de_fichier> /* répertoire standard */
#include "nom_de_fichier" /* répertoire courant */

La gestion des fichiers (stdio.h) /* Entrees_sorties standard */

Les fonctions mathématiques (math.h)
Taille des type entiers (limits.h)
Limites des type réels (float.h)
Traitement de chaînes de caractères (string.h)
Le traitement de caractères (ctype.h)
Utilitaires généraux (stdlib.h)
Date et heure (time.h)

18
 1er Programme
#include <stdio.h>
#include <conio.h>
int main(void)
{

printf(" Bonjour "); Bonjour

getch() ; /* Attente d'une saisie clavier */

return 0; /* En principe un code d'erreur nul signifie "pas d'erreur". */

19
La fonction printf() :
Librairie : stdio.h. #include <stdio.h>

Syntaxe : int printf(" format ", arg_1, arg_2, …., arg_n) ;

Description : Permet l'écriture formatée (l'écran par défaut).

Exemple :
printf("Qu'il est agreable d’utiliser printf "
" en\t C,\nlorsqu'on l'utilise \"proprement\".\n");

Résultat sur la sortie :

Qu'il est agreable d’utiliser printf en C,
lorsqu'on l'utilise "proprement".

Les caractères précédés de \ sont interprétés comme suit :

\\ : caractère \
\n : retour à la ligne
\t : tabulateur.
\" : caractère "
\r : retour chariot
20
Les constantes de type caractère ont une valeur entiére dans la table ASCII
char c1 = 'A',
c2 = '\x41'; /* représentation hexadécimale */

caractères nom symbole code hexa décimal

\n newline LF 10
\t tabulation HT 9
\b backspace BS 8
\r return CR 13
\f form feed FF 12
\\ backslash 5C 92
\' single quote 27 39
\" double quote 22 34

21
La fonction scanf() :
Librairie : stdio.h. #include <stdio.h>

Syntaxe : int scanf("format ", arg_1, arg_2, …., arg_n);

Description : Lit à partir de stdin (clavier en principe), les différents

arguments en appliquant le format spécifié.
Exemple : scanf(" %d", &age); /* lecture de l'âge, on donne l'adresse de age */
!
Format des paramètres passés en lecture et écriture.

"%c" : lecture d'un caractère.

"%d" ou "%i" : entier signé.
"%e" : réel avec un exposant.
"%f" : réel sans exposant.
"%g" : réel avec ou sans exposant suivant les besoins.
"%G" : identique à g sauf un E à la place de e.
"%o" : le nombre est écrit en base 8.
"%s" : chaîne de caractère.
"%u" : entier non signé.
"%x" ou "%X" : entier base 16 avec respect majuscule/minuscule.
22
 Affichages et saisies
Librairie : stdio.h
Fonction Syntaxe Description

printf printf("format ", arg_1, arg_2, …, arg_n); Écriture formatée

: sortie standard

scanf scanf("format ", arg_1, arg_2, …., arg_n); Lecture formatée

7 entrée standard

putchar putchar(int c); Écrire le caractère c

:

getchar getchar(); Lecture d'un caractère

getch(); <conio.h> 7
getch
puts puts(char *s); Ecriture/Lecture d'une
gets(char *s); chaîne de caractères,
gets terminée par \n
sprintf sprintf(char *s, char *format, arg ...); Ecrit dans la chaîne
d'adresse s.

sscanf sscanf(char *s, char *format, pointer Lit la chaîne d'adresse s.

...);

23
 2éme Programme
#include <stdio.h>
#include <conio.h>
int main(void)
{
int age; /*déclaration d’une variable*/
printf("Je te souhaite le bon"
L’utilisation de & est indispensable avec
"jour aux TP\nEt je t"
scanf (valeur lue et donc modifiée), pas avec
"e souhaite bon trav"
printf (valeur écrite et donc non modifiée).
"ail\n");
!
printf("Quel est ton âge? ");
scanf(" %d", &age); /* lecture de l'âge, on donne l'adresse de age */
printf("\nAlors ton age est de %d ans!\n",age);

getch() ; /* Attente d'une saisie clavier */

return 0; /* En principe un code d'erreur nul signifie "pas d'erreur". */
}
Quel est ton âge ? 18
Alors ton age est de 18 ans!
24
 Identificateurs
Les identificateurs nomment les objets C (fonctions, variables ... )

C'est une suite de lettres ou de chiffres.

Le premier caractère est obligatoirement une lettre.
Le caractère _ (souligné) est considéré comme une lettre.

Le C distingue les minuscules des majuscules.

Exemples :
abc, Abc, ABC sont des identificateurs valides et tous différents.

Identificateurs valides :
xx y1 somme_5 _position
Noms surface fin_de_fichier VECTEUR

Identificateurs invalides :
3eme commence par un chiffre
x#y caractère non autorisé (#)
no-commande caractère non autorisé (-)
taux change caractère non autorisé (espace)

25
Un identificateur ne peut pas être un mot réservé du langage :

auto double int struct

break else long switch
case enum register typedef
char extern return union
const float short unsigned
continue for signed void
default goto sizeof volatile
do if static while

RQ : Les mots réservés du langage C

doivent être écrits en minuscules.

26
 Variables : déclarations
Syntaxe : Type identificateur1, identificateur2, …,…. ;

Exemple: char c1, c2, c3;

int i, j, var_ent;

Variables : initialisations
Les variables doivent être déclarées avant leur utilisation dans un début de bloc (juste après{),
zone des déclarations:

void main(void) void main(void)

{ {
est équivalent à
char c; char c = 'A';
int i,j, k;
c = 'A'; int i=50,j, k;
i = 50; j=k=10;
j =10; = opérateur d’affectation
K=10;

Cette règle s'applique à tous : char, int, float ... 27

 ! scanf
Exemples entrées résultats

char c1, c2, c3;

abc
scanf(‘’%c%c%c‘’,&c1,&c2,&c3); c1=a c2=<espace> c3=b

scanf(‘’ %c %c %c‘’,&c1,&c2,&c3); c1=a c2=b c3=c

char c;
int i;
float x;

scanf(‘’%2d %5f %c‘’,&i,&x,&c); 12 123.567 r i=12 x=123.5 c=6

28
 LES DECLARATIONS DE CONSTANTES

1ere méthode: définition d'un symbole à l'aide de la directive de compilation #define.

Le compilateur ne réserve pas

Exemple: #define PI 3.14159 de place en mémoire
main()
{
float perimetre,rayon = 8.7;
perimetre = 2*rayon*PI;
....
}

Syntaxe : #define identificateur texte(valeur) !

Les identificateurs s'écrivent
#define TAILLE 100 traditionnellement en
#define MAXI (3 * TAILLE + 5) majuscules, mais ce n'est pas
#define nom_macro(identif_p1 , ... ) texte une obligation.
#define SOMME(X,Y) X+Y
#define MULTIP(A,B) (A)*(B)

29
 LES DECLARATIONS DE CONSTANTES

2eme méthode: déclaration d'une variable, dont la valeur sera constante pour tout le programme.

Exemple:
main() Le compilateur réserve de la
{ place en mémoire (ici 4 octets).
const float PI = 3.14159;
const int JOURS = 5;
float perimetre,rayon = 8.7;
perimetre = 2*rayon*PI;
.... /*ERREUR !*/ On ne peut
JOURS = 3; changer la valeur d’une const.
.... !
}

30
 Les opérateurs arithmétiques
◼ Le C propose les opérateurs suivants :

+ addition
- soustraction
* multiplication
/ division
% modulo (reste de la division entière )

% ne peut être utilisé qu'avec des entiers

7/2 3

7.0/2
7/2.0
7.0/2.0
 3.5

31
 Utiliser des opérateurs arithmétiques

Le compilateur considère le type des opérandes

pour savoir comment effectuer les opérations
k= 5/4 = 1 main()
{
int i = 5, j = 4, k;
h = 5.0/4.0 = 1.25 double f = 5.0, g = 4.0, h;

k = i / j;
h = f / g;
h = 5/4 = 1.0000 h = i / j;
}

32
Les opérateurs de comparaison
< plus petit Le type booléen
<= plus petit ou égal n'existe pas. Le
résultat d'une
> plus grand
expression logique
>= plus grand ou égal vaut 1 si elle est
! == égal vraie et 0 sinon.
!= différent
Réciproquement,
Les opérateurs logiques toute valeur non
nulle est considérée !
&& et comme vraie et la
|| ou (non exclusif) valeur nulle
comme fausse.
! non

33
 int i;
Exemple
float f;
char c;

i = 7; f = 5.5; c = 'w';

f>5 ====> vrai (1)

(i + f) <= 1 ====> faux (0)
c == 'w‘ ====> vrai (1)
c != 'w' ====> faux (0)
c >= 10*(i + f) ====> faux (0)
(i >= 6) && (c == 'w') ====> vrai (1)
(i >= 6) || (c == 119) ====> vrai (1)

!expr1 est vrai si expr1 est faux et faux si expr1 est vrai ;
expr1 && expr2 est vrai si les deux expressions expr1 et expr2 sont vraies
et faux sinon. L'expression expr2 n'est évaluée que dans le cas où l'expression
expr1 est vraie ;

expr1 || expr2 = (1) si expr1=(1) ou expr2=(1) et faux sinon.

L'expression expr2 n'est évaluée que dans le cas où l'expression expr1
est fausse.
34
 Contractions d'opérateurs
◼ Il y a une famille d’opérateurs
+= -= *= /= %=
&= |= ^=
<<= >>=
◼ Pour chacun d’entre eux
expression1 op= expression2
est équivalent à:
(expression1) = (expression1) op (expression2)
a += 32; f /= 9.2; i *= j + 5;
a = a + 32; f = f / 9.2; i = i * (j + 5);
35
 Incrément et décrement

◼ C a deux opérateurs spéciaux pour incrémenter (ajouter 1)

et décrémenter (retirer 1) des variables entières
++ increment : i++ ou ++i est équivalent à i += 1 ou i = i + 1
-- decrement
◼ Ces opérateurs peuvent être préfixés (avant la variable) ou
postfixés (après)
int i = 5, j = 4;
“i” vaudra 6
i++;
“j” vaudra 3 --j;
++i;
“i” vaudra 7
36
 Préfixe et Postfixe

#include <stdio.h>

int main(void)
{
équivalent à:
int i, j = 5;
1. j++;
i = ++j;
2. i = j; !
printf("i=%d, j=%d\n", i, j); 37

j = 5; équivalent à:
i = j++; 1. i = j;
printf("i=%d, j=%d\n", i, j); 2. j++; !
return 0;
} i=6, j=6
i=5, j=6
 Les Conversions de types
Le langage C permet d'effectuer des opérations de conversion de type.
On utilise pour cela l'opérateur de "cast" ().
#include <stdio.h>
main()
{ Conversion float -> int: 89.67 -> 89
int i=0x1234, j;
Conversion int -> float: 4660 -> 4660.00
char d,e;
float r=89.67,s; Conversion int -> char: 1234 -> 34
j = (int)r; Conversion float -> char: 89.67 -> 89
s = (float)i;
Pour sortir frapper une touche
d = (char)i;
e = (char)r;
printf("Conversion float -> int: %5.2f -> %d\n",r,j);
printf("Conversion int -> float: %d -> %5.2f\n",i,s);
printf("Conversion int -> char: %x -> %x\n",i,d);
printf("Conversion float -> char: %5.2f -> %d\n",r,e);
printf("Pour sortir frapper une touche ");

38
 Les structures de contrôle en C

Alternative: if-else
Choix Multiple: switch-case
Itérations: for, while, do-while
Rupture de Contrôle: break, continue, return
… goto

39
 Les structures de contrôle en C
Les décisions - if then else
if (expression booléenne vraie) if (a<b)
{ {
Pas de then en C BLOC 1 D'INSTRUCTIONS min=a;
} }
else else
Le bloc " else " { {
est optionnel. BLOC 2 D'INSTRUCTIONS min=b;
} }
* Tout ce qui est 0 ( ‘\0’ 0 0.0000 NULL ) est faux
* Tout ce qui est != de 0 ( 1 ‘0’ 0.0001 1.34 ) est vrai

if(32)
printf("ceci sera toujours affiche\n");
if(0)
printf("ceci ne sera jamais affiche\n");

40
Exemples :
if (i < 10) i++;
La variable i ne sera incrémentée que si elle a une valeur inférieure à 10.

if (i == 10) i++; == et pas =

La variable i ne sera incrémentée que si elle est égale à 10.

if (!recu) printf ("rien reçu\n");

Le message "rien reçu" est affiché si recu vaut zéro.

if ((!recu) && (i < 10)) i++;

i ne sera incrémentée que si recu vaut zéro et i<10.

Si plusieurs instructions, il faut les mettre entre accolades.

if ((!recu) && (i < 10) && (n!=0) ){

i++; if(delta != 0) = if(delta)
moy = som/n;
printf(" la valeur de i =%d et moy=%f\n", i,moy) ;
} if(delta == 0) = if(!delta)
else {
printf ("erreur \n");
i = i +2; // i +=2 ;
} !
41
 ! Attention!
◼ Ne pas confondre = = (opérateur logique d’égalité)
et = (opérateur d’affectation)
#include <stdio.h>

main()
{
int i = 0;

if(i = 0) /* ici affectation */

printf("i = zero\n");
else
printf(“Quand i != de zero\n");

}
Quand i != de zero

42
 if emboîtés
◼ else est associé avec le if le plus proche

int i = 100;

if(i > 0)
if(i > 1000)
printf("i > 1000\n");
else
printf("i is reasonable\n"); i is reasonable

int i = 100;

if(i > 0) {
if(i > 1000)
printf(" i > 1000 \n");
} else
printf("i is negative\n");

43
switch = AU CAS OU ... FAIRE ...
switch(variable de type char ou int) /* au cas où la variable vaut: */
{
case valeur1: ......; /* cette valeur1(étiquette): exécuter ce bloc d'instructions.*/
.......;
break; /* L'instruction d'échappement break;
permet de quitter la boucle ou l'aiguillage le plus proche.
*/

case valeur2:........; /* cette valeur2: exécuter ce bloc d'instructions.*/

........;
break;
.
. /* etc ...*/
.
default: .......; /* aucune des valeurs précédentes: exécuter ce bloc
........; d'instructions, pas de "break" ici.*/
}
Le bloc "default" n'est pas obligatoire. valeur1, valeur2, …. doivent être des expressions
constantes. L’instruction switch correspond à une cascade d’instructions if ...else

44
 Cette instruction est commode pour les "menus":

char choix; int choix;

printf("SAISIE TAPER 1\n");
printf("AFFICHAGE TAPER 2\n"); float f;
printf("POUR SORTIR TAPER S\n");
printf("\nVOTRE CHOIX: "); scanf(" %d ", &choix); switch(f) {
choix = getchar(); case 2:
switch(choix)
switch(choix) ....
{ {
case '1': .......; case 1: … switch(i) {
break; ! case 2 * j:
....
case '2': ......;
break;

case 'S': printf("\nFIN DU PROGRAMME ....");

break;

default :printf("\nCE CHOIX N'EST PAS PREVU "); /* pas de break ici */
}

45
 Les itérations – for
int i,j;
for( init ; test; increment) i=0
{ for (i = 0; i <3; i++) { i=1
/* corps de for */ printf ( "i = %d\n", i); i = 2
} j=5
} j=4
for(j = 5; j > 0; j- -)
printf("j = %d\n", j); j = 3
double angle; j=2
j=1
for(angle = 0.0; angle < 3.14159; angle += 0.2)
printf("sine of %.1lf is %.2lf\n",angle, sin(angle));

int i, j, k;
for( ; ; )
{ for(i = 0, j = 2, k = -1; (i < 20) &&(j==2); i++, k--)
............; /* bloc d'instructions */
............;
............;
}

est une boucle infinie (répétition infinie du bloc d'instructions).

46
 LA BOUCLE TANT QUE ... FAIRE ...
Boucle pré-testée
Il s'agit de l'instruction while : tant que, pas jusqu’à ce que!
tant que (expression vraie)
faire{BLOC D'INSTRUCTIONS}
Syntaxe en C:
Organigramme:
while (expression)
{
............; /* bloc d'instructions */
............;
............;
}

Le test se fait d'abord, le bloc d'instructions

n'est pas forcément exécuté.

Rq: les {} ne sont pas nécessaires lorsque le

bloc ne comporte qu'une seule instruction.

47
 Exemple
i=1; Intérieur 1
while(i<5) Intérieur 2
{ Intérieur 3
printf(“Intérieur %d\n",i); Intérieur 4
itération i++; Extérieur 5
}
printf("Extérieur %d\n",i);

int j = 5;
start
tant que, pas jusqu’à ce que! printf("start\n"); end
while(j == 0)
printf("j = %d\n", j--);
printf("end\n");
i=1;
while(i<5);
{ "tant que l'expression est vraie
printf(“Intérieur %d\n",i); attendre".
i++;
}

48
 do while = REPETER … tant que
(guarantit l’exécution au moins une fois)
bloc d' do
{
instructions ............; /* bloc d'instructions */
............;
}
while (expression);
non
condition
oui vraie

suite du programme i=1;

do
int j = 5; { i=1
do j=5 printf(“i=%d ",i);
j=4 stop
printf("j = %i\n", j--); i++;
while(j > 0); j=3 }while(i<0);
printf("stop\n"); j=2 printf("stop\n");
j=1
stop
49
 Instructions d'échappement
Pour rompre le déroulement séquentiel d'une suite d'instructions

Break;
# Continue; 8
int i, j=1; for (i = -10; i <= 10; i++)
char a; {
for (i = -10; i <= 10; i++){ if (i == 0)
continue;
while(j!=0) /* boucle infinie */ // pour éviter la division par zéro
{ printf(“ %d”, 1 / i);
a=getchar(); }
if(a= ='x')
break;
} return (expression);
} permet de sortir de la fonction qui la contient

exit (expression); La fonction est interrompu.

Si x est tapée au clavier expression : un entier indiquant le code de terminaison
du processus
50
goto étiquette
#include <stdio.h>
void main()
{
int i, j;
for (i=0; i < 10; i++)
for (j=0; j < 4; j++) {
if ( (i*j) == 10)
goto trouve;
printf("i*j != 10.\n");
}
trouve:
printf("i*j =%d * %d = %d== 10.\n",i,j,i*j);
}

51