Module : Informatique 1

Module : Informatique 1: Algorithme & programmation

Spécialité : Licence d’éducations en MATH-S1

Année universitaire : 2025/2026

Programmation C
 PLAN

➢ Introduction
➢ Types de base, variables, constantes
➢ Opérateurs et expressions
➢ Les entrées sorties en C
➢ Les structures de contrôle
➢ Les tableaux
Introduction:
Aperçu historique

✓ Le C a été conçu en 1972 par Dennis Richie et Ken Thompson;

✓ En 1978, Brian Kernighan et Dennis Richie publient la définition classique
du C dans le livre The C Programming language;
✓ Le C devenant de plus en plus populaire dans les années 80;
✓ En 1983, l’ANSI (American National Standards Institute) décida de
normaliser le langage ;
✓ Ce travail s’acheva en 1989 par la définition de la norme ANSI C;
✓ C’est ce standard, ANSI C, qui est décrit dans ce cours.
Notion de programme
 Un algorithme n'est donc exécutable directement par aucune machine.
 Mais il a l'avantage d'être traduit facilement dans tous les langages de programmation.

 L'algorithmique, l'art d'écrire des algorithmes, permet de se focaliser sur la procédure de

résolution du problème sans avoir à se soucier des spécificités d'un langage particulier.
 Pour résoudre un problème, il est vivement conseillé de réfléchir d'abord à l'algorithme avant
de programmer proprement dit, c'est à dire d'écrire le programme en langage de
5
programmation.
La compilation
Le C est un langage compilé:
➢ Un programme C est décrit par un fichier texte, appelé fichier
source.
➢ Ce fichier est traduit en langage machine.
➢ Cette opération est effectuée par un programme appelé
compilateur.
La compilation se décompose en 4 phases :
1. Le traitement par le préprocesseur;
2. La compilation ;
3. L’assemblage ;
4. L’édition de liens.
La compilation
La compilation
La compilation
1. Le traitement par le préprocesseur;
Le préprocesseur effectue des transformations purement textuelles (
inclusion d’autres fichiers source . . . ).
2. La compilation ;
Elle traduit le fichier généré par le préprocesseur en assembleur.
3. L’assemblage ;
Il transforme le code assembleur en un fichier binaire compréhensibles par le
processeur. Le fichier produit par l’assemblage est appelé fichier objet.
4. L’édition de liens.
Elle consiste à rassembler dans un seul fichier binaire tout le code binaire
nécessaire à l’exécution du programme. Cette opération produit alors un
fichier dit exécutable.
Les composants élémentaires du C
Un programme en langage C est constitué des six groupes de composants
élémentaires suivants :
✓ les identificateurs,
✓ les mots-clefs,
✓ les constantes,
✓ les chaînes de caractères,
✓ les opérateurs,
✓ les signes de ponctuation.
Les composants élémentaires du C
Les identificateurs :
Le rôle d'un identificateur est de donner un nom à une entité du
programme, un identificateur peut désigner :
• un nom de variable ou de fonction,
• un type défini par typedef, struct, union ou enum,
• une étiquette.
Les composants élémentaires du C
Les mots-clefs:
Les mots-clefs sont des mots réservés pour le langage et ne peuvent pas être utilisés comme
identificateurs. L'ANSI C compte 32 mots clefs 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
divers :
return sizeof
Les composants élémentaires du C
Les commentaires

Un commentaire débute par /* et se termine par */.

exemple: /* Ceci est un commentaire */
Remarque:
• On ne peut pas imbriquer des commentaires.

Quand on met en commentaire un morceau de programme, il faut donc veiller à ce que celui-ci ne contienne pas de
commentaire.

Exemple:
/* Un commentaire
/* Un autre commentaire */ */

// cette ligne est en commentaire

• Ajouter de nombreux commentaires dans le code source de votre programme, surtout s’il contient des
instructions ou fonctions qui pourraient être difficile à comprendre. Vous gagner un temps précieux quand vous
aurez à le modifier.
Structure d’un programme C
Expression
Une expression est une suite de composants élémentaires syntaxiquement correcte, par
exemple
x=0
Une instruction est une expression suivie d’un point-virgule.

Le point-virgule signifie en quelque sorte “évaluer cette expression”.

Plusieurs instructions peuvent être rassemblées par des accolades { et } pour former une
instruction composée . Par exemple,
if (x != 0)
{
z = y / x;
t = y % x;
}
Structure d’un programme C
Déclaration:

Une instruction composée d’un spécificateur de type et d’une liste

d’identificateurs séparés par une virgule est une déclaration.
Par exemple,
int a;
int b = 1, c;
double x = 2.38e4;

En C, toute variable doit faire l’objet d’une déclaration avant d’être utilisée.
Structure d’un programme C
Un programme C se présente de la façon suivante :

[ directives au préprocesseur]
[ déclarations de variables externes]
[ fonctions secondaires]
main()
{
déclarations de variables internes,
instructions
}
Les directives du préprocesseur (précompilation)

Elles commencent toutes par un #.

Commande Signification
#include <stdio.h> permet d’utiliser les fonctions printf() et scanf()
#include <math.h>
permet d’utiliser les fonctions mathématiques
#include <conio.h>
permet d’utiliser la fonction getch()
#define PI 3.14159 définit la constante PI
#undef PI à partir de cet endroit, la constante PI n’est plus définie
#ifdef PI si la constante PI est définie, on compile les instructions 1,
instructions 1 ... sinon, les instructions 2
#else
instructions 2 ...
#endif
 Les variables

Les variables servent à stocker les valeurs des données utilisées pendant
l’exécution d’un programme.
Le C est un langage typé. Cela signifie en particulier que toute variable,
constante est d'un type précis.
Le type d'un objet définit la façon dont il est représenté en mémoire.
 Les variables
Les types de base en C sont:
▪ les caractères;
▪ les entiers;
▪ les flottants (nombres réels).
Dont la valeur peut être modifiée au cours de l'exécution du programme.
Pour déclarer une variable, on fait précéder son nom par son type.
Ils sont désignés par les mots-clefs suivants : char int float double short long unsigned
Les types de base
Le type caractère:
Le mot-clé désignant les caractères est char.

Une variable de ce type doit pouvoir contenir le code de n’importe quel

caractère de l’ensemble des caractères utilisés par la machine.

Exemple:

type

identificateur

valeur
char var1 = ‘a’;
Les types de base
Le jeu de caractères utilisé correspond généralement au codage ASCII (sur 7 bits).
Les types de base
Le type entier:
le mot-clé désignant les entiers est int. Les entiers peuvent être affectés de
deux types d’attributs: (précision et représentation).

Les attributs de précision sont short et long. On peut avoir donc trois entiers:
Short int, int et long int

L’attribut de représentation est unsigned . On peut avoir donc trois entiers:

Unsigned short int, unsigned int et unsigned long int
Les types entiers
LES TYPES DE BASE

Les types float, double et long double servent à représenter des

nombres en virgule flottante. Ils correspondent aux différentes
précisions possibles.
Les constantes
Une constante conserve sa valeur pendant toute l’exécution d’un programme.
Les constantes peuvent être de types :
• entier,
• flottant (nombre réel),
• caractère.
Exemple:
 Constantes entières 1, 2, 3, ...
 Constantes caractères ’a’, ’A’, ...
 Constantes chaînes de caractères "Bonjour"
 Pas de constantes logiques
 Pour faire des tests, on utilise un entier. 0 est équivalent à faux
et tout ce qui est ≠ 0 est vrai.
Les constantes entières
Une constante entière peut être représentée de 3 manières différentes suivant la
base dans laquelle elle est écrite :
décimale : par exemple, 0 et 12 sont des constantes entières décimales.

octale : Les constantes octales doivent commencer par un zéro. Par

exemple, 00 et 03.

hexadécimale : Les constantes hexadécimales doivent commencer par

0x. Par exemple, les représentations hexadécimales de 4 et 15 sont
respectivement 0x4 et 0xf.
Les constantes réelles

Les constantes réelles sont représentées par la notation classique par mantisse et
exposant. L'exposant est introduit par la lettre e ;

Par défaut, une constante réelle est représentée avec le format du type double.
mais, on peut forcer le type en utilisant F ou L, par exemple:
Les constantes caractères
Pour désigner un caractère imprimable, il suffit de:
• mettre le caractère entre apostrophes (par ex. 'A')
• Ou la précéder par antislash pour les caractères: l'antislash, l'apostrophe, Le point
d'interrogation et les guillemets(par ex. \\, \’, \? et \")
Pour désigner un caractère non-imprimable, on utilise son code en hexadécimal.

les caractères non-imprimables les plus fréquents disposent aussi d'une notation plus simple :
Le type void

• Void indique un ensemble vide de valeur;

• Une fonction de type void ne renvoie pas de valeur;

• Un pointeur sur un type void pointe sur une zone sans type ;

• Une liste de paramètres formels égale à void indique une liste

vide;
Les opérateurs
Les opérateurs:
1. L'affectation;
2. Les opérateurs arithmétiques;
3. Les opérateurs relationnels;
4. Les opérateurs logiques booléens;
5. Les opérateurs logiques bit à bit;
6. Les opérateurs d'affectation composée;
7. Les opérateurs d'incrémentation / décrémentation ;
8. L'opérateur virgule;
9. L'opérateur conditionnel ternaire ;
10.L'opérateur de conversion de type ;
11.L'opérateur adresse,
Les opérateurs
L'affectation
L'affectation est symbolisée par le signe =, sa syntaxe est la suivante :
variable = expression

L'affectation effectue une conversion de type implicite : la valeur de l'expression est

convertie dans le type du terme de gauche.
exemple:
int x, y = 1;
float z= 1.5;
x = y+ z;
z= z + x;
printf("\n %f \n", z);

La fonction printf affiche pour z la valeur 3,5 (et non 4), car dans l’instruction x= y+ z; ,
l’expression y+z a été convertie en entier,
 Les opérateurs
Les opérateurs arithmétiques
➢ + addition
➢ - soustraction
➢ - changement de signe
➢ * multiplication
➢ / division
➢ % reste de la division (modulo)
L'opérateur % ne s'applique qu'à des opérandes de type entier.
la notation / désigne à la fois la division entière et la division entre flottants:
➢ Si les deux opérandes sont de type entier, l'opérateur / produira une division entière ,
➢Si l'un des opérandes est un flottant, l'opérateur / délivrera une valeur flottante.
Exemple:
float x;
x = 3 / 2; //affecte à x la valeur 1.
Par contre : x = 3 / 2.0; // affecte à x la valeur 1.5.
 Les opérateurs
Les opérateurs relationnels:
❖ > supérieur
❖ >= supérieur ou égal
❖ < strictement inférieur
❖ <= inférieur ou égal
❖ == égal
❖ != différent

Syntaxe :
expression1 op expression2
Les deux expressions sont évaluées puis comparées. La valeur rendue est de
type int ; elle vaut 1 si la condition est vraie, et 0 sinon.
Les opérateurs
Les opérateurs logiques booléens
❖ && et logique
❖ || ou logique
❖ ! négation logique
La valeur retournée par ces opérateurs est un int qui vaut 1 si la condition est
vraie et 0 sinon.
Syntaxe
expression1 op1 expression2 op2 ...expressionN
l'évaluation se fait de gauche à droite et s'arrête dès que le résultat final est
déterminé.
Exemples
▪(10 < 5) && (4 > 2) retourne 0
▪(6 < 50) || (4 > 2) retourne 1
▪! (9 > 20) retourne 1
Les opérateurs
Les opérateurs logiques bit à bit
Les six opérateurs suivants permettent de manipuler des entiers
au niveau du bit.

❖ & et bit à bit

❖ | ou inclusif
❖ ^ ou exclusif
❖ ~ complément à 1
❖ << décalage à gauche
❖ >> décalage à droite
Les opérateurs

Les opérateurs logiques bit à bit

& 0 1 | 0 1 ^ 0 1

0 0 0 0 0 1 0 0 1

1 0 1 1 1 1 1 1 0

Exemple:
int j=8,i=4; // j = 8, en binaire : 1000 ; i=4 en binaire 100

printf("\n j<<1 = %d",j<<1); //Décalage d’un bit à gauche → 10000 . affichera 16

printf("\n i>>1 = %d",i>>1); // Décalage d’un bit à droite → 10 . affichera 2
Les opérateurs
Les opérateurs d'affectation composée
Les opérateurs d'affectation composée sont :
• +=
• -=
• *=
• /=
• %=
• &=
• ^=
• |=
• <<=
• >>=
- Syntaxe: expression1 o p = expression2
est équivalente à : expression1 = expression1 op expression2
Toutefois, avec l'affection composée, expression1 n'est évaluée qu'une seule fois.
Opérateurs unaires d’incrémentation et décrémentation

Les opérateurs ++ -- :
•Ce type d'opérateur permet de facilement augmenter ou diminuer d'une unité une variable.
•Ces opérateurs sont très utiles pour des structures telles que des boucles, qui ont besoin d'un
compteur (variable qui augmente de un en un).
•i = i + 1; devient i++ ou ++i;
Incrémentation post-fixée
X = I++ passe d'abord la valeur de I à X et incrémente après.
Incrémentation pré-fixée
X = ++I incrémente d'abord et passe la valeur incrémentée à X.
•i = i - 1; devient i-- ou --i;
Décrémentation post-fixée
X = I-- passe d'abord la valeur de I à X et décrémente après.
Décrémentation pré-fixée
X = --I décrémente d'abord et passe la valeur décrémentée à X.
Les opérateurs
Les opérateurs ++ -- :

Les opérateurs d'incrémentation ++ et de décrémentation --

s'utilisent aussi bien en suffixe (i++) qu'en préfixe (++i).

Exemple :
Supposons que la valeur de N est égal à 5:
Incrémentation postfixe: X = N++; Résultat: N=6 et X=5 .
Incrémentation préfixe: X = ++N; Résultat: N=6 et X=6.
Décrémentation postfixe: X = N--; Résultat: N=4 et X=5 .
Décrémentation préfixe: X = --N; Résultat: N=4 et X=4.
Les opérateurs
L'opérateur virgule

Une expression peut être constituée d'une suite d'expressions séparées par des
virgules :
expression1, expression2, ... , expressionN

Cette expression est évaluée de gauche à droite.

Sa valeur sera la valeur de l'expression de droite.

Exemple
int a, b;
b = ((a = 3), (a + 2));

L’instruction printf("\n b = %d \n",b); //affichera b=5,

Les opérateurs
L'opérateur conditionnel ternaire
syntaxe :
condition ? expression1 : expression2

cette expression est égale à expression1 si condition est satisfaite, et à expression2 sinon.

Exemples:
l'expression
x >= 0 ? x : -x
correspond à la valeur absolue d'un nombre.

l'instruction
max = ((a > b) ? a : b);

affecte à max le maximum de a et de b.

Les opérateurs
L'opérateur adresse

L'opérateur d'adresse & appliqué à une variable retourne l'adresse mémoire de cette
variable.
La syntaxe est
&objet
L'opérateur de conversion de type (opérateur de cast)
L'opérateur de conversion de type permet de modifier explicitement le type d'un objet.
syntaxe :
(type) objet
exemple:
int i = 3, j = 2 ;
float k=(float)i/j ;

l’instruction printf("%f \n", k); affichera la valeur 1.5.

Règles de conversion automatique
Conversions automatiques lors d'une opération avec,
(1) deux entiers :
D'abord, les types char et short sont convertis en int. Ensuite, l'ordinateur
choisit le plus large des deux types dans l'échelle suivante :
int, unsigned int, long, unsigned long
(2) un entier et un rationnel :
Le type entier est converti dans le type du rationnel.
(3) deux rationnels :
L'ordinateur choisit le plus large des deux types selon l'échelle suivante :
float, double, long double
(4) affectations et opérateurs d'affectation :
Lors d'une affectation, le résultat est toujours converti dans le type de la destination.
Si ce type est plus faible, il peut y avoir une perte de précision.
Les opérateurs
Opérateurs de manipulation des pointeurs
Lors du travail avec des pointeurs, nous utilisons :
un opérateur 'adresse de': & pour obtenir l'adresse d'une variable
un opérateur 'contenu de': * pour accéder au contenu d'une
adresse
Les opérateurs
Règles de priorité des opérateurs
Ordre Opérateurs
1 () [] -> . →
2 ! ~ ++ -- -(unaire) (type) *(indirection) &(adresse) sizeof 
3 * / % →
4 + -(binaire) →
5 << >> →
6 < <= > >= →
7 == != →
8 &( et bit-à-bit ) →
9 ^ →
10 | →
11 && →
12 || →
13 ?: 
14 = += -= *= /= %= &= ^= != <<= >>= 
15 , →
Les opérateurs
Règles de priorité des opérateurs

Classes de priorités
Priorité 1 (la plus forte): ()
Priorité 2: ! ++ --
Priorité 3: * / %
Priorité 4: + -
Priorité 5: < <= > >=
Priorité 6: == !=
Priorité 7: &&
Priorité 8: ||
Priorité 9 (la plus faible): = += -= *= /= %=
Règles de priorité des opérateurs

Evaluation d'opérateurs de la même classe :

--> Dans chaque classe de priorité, les opérateurs ont la même
priorité. Si nous avons une suite d'opérateurs binaires de la même
classe, l'évaluation se fait en passant de la gauche vers la droite
dans l'expression.

<-- Pour les opérateurs unaires (!,++,--) et pour les opérateurs

d'affectation (=,+=,-=,*=,/=,%=), l'évaluation se fait de droite à
gauche dans l'expression.
Les entrées sorties
Il s'agit des fonctions de la librairie standard stdio.h utilisées avec le clavier et l'écran.
Sur certains compilateurs, l'appel à la librairie stdio.h n'est pas nécessaire pour utiliser printf et
scanf.
La fonction d'écriture « printf »
La fonction printf est une fonction d'impression formatée, ce qui signifie que les données
sont converties selon le format particulier choisi.
syntaxe:
printf("chaîne de contrôle ", expression1, ..., expressionN);
La fonction d'écriture « printf »
La chaîne de contrôle contient le texte à afficher et les spécifications de format
correspondant à chaque expression de la liste.

Les format sont introduites par le caractère %, suivi d'un caractère désignant le format
d'impression.

.
Les entrées sorties
Les formats d'impression en C sont donnés dans la table suivante:
Format Conversion en Écriture
%d Int décimale signée
%ld long int décimale signée
%u unsigned int décimale non signée
%lu unsigned long int décimale non signée
%o unsigned int octale non signée
%lo unsigned long int octale non signée
%x unsigned int hexadécimale non signée
%lx unsigned long int hexadécimale non signée
%f double décimale virgule fixe
%lf long double décimale virgule fixe
%e double décimale notation exponentielle
%le long double décimale notation exponentielle
%g double décimale, représentation la plus courte parmi %f et %e
%lg long double décimale, représentation la plus courte parmi %lf et %le
%c unsigned char caractère
%s char* chaîne de caractères
Les entrées sorties
La fonction de saisie « scanf »:
Formats de saisie pour la fonction scanf
La fonction scanf permet de saisir des
données au clavier et de les stocker aux
adresses spécifiées par les arguments
de la fonctions.

scanf("chaîne de contrôle", argument1,

...,argumentN)
Les entrées sorties
Écriture formatée de données
Largeur minimale pour les entiers :
Pour les entiers, nous pouvons indiquer la largeur minimale de la valeur à
afficher. Dans le champ ainsi réservé, les nombres sont justifiés à droite.

Exemples : ( _ <=> position libre)

printf ("%4d", 123); ==> _123
printf ("%4d", 1234); ==> 1234
printf ("%4d", 12345); ==> 12345
printf ("%4u", 0); ==> ___0
printf ("%4X", 123); ==> __7B
printf ("%4x", 123); ==> __7b
Les entrées sorties
Écriture formatée de données
Largeur minimale et précision pour les rationnels :
Pour les rationnels, nous pouvons indiquer la largeur minimale de la valeur à afficher et la
précision du nombre à afficher. La précision par défaut est fixée à six décimales. Les positions
décimales sont arrondies à la valeur la plus proche.

Exemples :
printf ("%f", 100.123); ==> 100.123000
printf ("%12f", 100.123); ==> __100.123000
printf ("%.2f", 100.123); ==> 100.12
printf ("%5.0f", 100.123); ==> __100
printf ("%10.3f", 100.123); ==> ___100.123
printf ("%.4f", 1.23456); ==> 1.2346
Les entrées sorties
Lecture formatée de données
Indication de la largeur maximale :
Pour tous les spécificateurs, nous pouvons indiquer la largeur maximale du champ à évaluer
pour une donnée. Les chiffres qui passent au-delà du champ défini sont attribués à la prochaine
variable qui sera lue !

Exemple :
Soient les instructions :
int A,B;
scanf("%4d %2d", &A, &B);
Si nous entrons le nombre 1234567, nous obtiendrons les affectations suivantes :
A=1234
B=56
le chiffre 7 sera gardé pour la prochaine instruction de lecture.
Les entrées sorties
Lecture formatée de données
Les signes d'espacement :
Lors de l'entrée des données, une suite de signes d'espacement (espaces, tabulateurs, interlignes)
est évaluée comme un seul espace. Dans la chaîne de format, les symboles \t, \n, \r ont le même
effet qu'un simple espace.
Exemple :
Pour la suite d'instructions
int JOUR, MOIS, ANNEE;
scanf("%i %i %i", &JOUR, &MOIS, &ANNEE);
les entrées suivantes sont correctes et équivalentes :
12 4 1980
ou
12 004 1980
ou
12
4
1980
Les entrées sorties
Impression et lecture de caractères

Les fonctions getchar et putchar permettent respectivement de lire et

d'imprimer des caractères.

La fonction getchar retourne un int correspondant au caractère lu. Pour

mettre le caractère lu dans une variable caractere, on écrit
caractere = getchar();

La fonction putchar écrit caractere sur la sortie standard:

putchar(caractere);
Les instructions de contrôle
 Le langage C dispose d’instructions de contrôle permettant de réaliser :
 des choix :
 L’instruction conditionnelle if…else…
 L’instruction d’aiguillage ou de choix switch…case…default…
 des boucles les instruction répétitives :
 while…do…
 do…while…
 for…
 des branchementsLes instructions de branchement inconditionnel
 goto
 break ( associé aux boucles)
 continue ( associé aux boucles)
 return
Les instructions de branchement conditionnel
Branchement conditionnel « if---else »
 L’instruction conditionnelle if -- else permet de tester une condition
puis d'exécuter une action parmi deux actions possibles.
 La forme la plus générale est celle-ci:
 avec un nombre quelconque de:
else if (... ).
 Le dernier else est toujours facultatif.
 La forme la plus simple est :

 Chaque instruction peut être un bloc d'instructions

Les instructions de branchement conditionnel
Branchement multiple « switch »
 L’instruction switch est une instruction de choix multiple. Elle permet d’évaluer
une expression puis d'exécuter une action parmi plusieurs actions étiquetées.
 Si la valeur de l’expression correspond à une des étiquettes, l’action
correspondante est exécutée .
 Sa forme la plus générale est :
 Les instructions de branchement conditionnel
Branchement multiple « switch »

 « expression » doit être une expression entière

 « la constante » doit être une constante entière( de type : int, char, short, long,
unsigned).
 Par contre « default » est facultatif.
 L’expression est comparée successivement ( de haut en bas) aux constantes spécifiées après chaque
“case”.
 S’il y a égalité, alors les instructions correspondantes à ce
« case » sont exécutées.
 Dans le cas où aucune égalité n’est vérifiée, les instructions spécifiées après “ default” sont
exécutées.
 Pour sortir de l’instruction switch délimitée par { et } et continuer en séquence, on doit utiliser
l’instruction break .
 Les instructions de branchement conditionnel
Branchement multiple « switch »
 Exemple:
Les boucles
Les boucles permettent de répéter une série d'instructions tant qu'une certaine condition
n'est pas vérifiée.
 L’instruction while
 L’instruction do...While...
 L’instruction for
 Boucle while
 Tant qu’une condition spécifiée n’est pas vérifiée, elle permet de répéter une ou plusieurs actions.
 La syntaxe de while est la suivante :

 Si expression est nulle au départ, instruction ne sera jamais exécutée.

 instruction peut évidemment être une instruction composée.

Exemple:
le programme suivant imprime les entiers de 1 à 9.
 Boucle do -- while
Il peut arriver que l'on ne veuille effectuer le test de continuation qu'après avoir
exécuté l'instruction. Dans ce cas, on utilise la boucle do -- while.

syntaxe : do {
instruction
Exemple: }while (expression );
Ecrire un bout de code qui permet de saisir au clavier un entier entre 1 et 10 :
int a;
do
{
printf("\n Entrez un entier entre 1 et 10 : ");
scanf("%d",&a);
}
while ((a <= 0) || (a > 10));
La boucle for
 L’instruction for est une instruction de boucle faisant intervenir l’initialisation, le test de limite et
l’incrémentation en une seule action.
 La syntaxe de for est :

 Une version équivalente plus intuitive est :

 Par exemple, pour imprimer tous les entiers de 0 à 9, on écrit :

 A la fin de cette boucle, i vaudra 10.

Branchement non conditionnel
break  Permet d'interrompre le déroulement de la boucle, et passe à la première
instruction qui suit la boucle.
 En cas de boucles imbriquées, break fait sortir de la boucle la plus interne.

i=0
i=1
i=2
i=3
valeur de i a la sortie de la boucle = 3
Branchement non conditionnel
Continue
L'instruction continue permet de passer directement au tour de boucle suivant, sans
exécuter les autres instructions de la boucle.
Exemple:

 Le programme imprime
i=0
i=1
i=2
i=4
valeur de i a la sortie de la boucle = 5
Branchement non conditionnel
goto:
L’instruction goto permet d’effectuer un saut jusqu’`a l’instruction étiquette correspondant.
Exemple: Main(){
int i = 0, j = 2 ;
debit:
printf("\n %d\n",i);
i++;
if(i>3)
goto fin;
else
goto debit;
fin:
printf("\n fin \n"); Ce code imprime
}
0
1
2
3
fin
Les tableaux
Un tableau est une variable structurée composée d’un nombre de variables simples
de même type désignées par un seul identificateur

Ces variables simples sont appelées éléments ou composantes du tableau, elles

sont stockées en mémoire à des emplacements contigus (l’un après l’autre)

Le type des éléments du tableau peut être :

char, int, float, double, …

On peut définir des tableaux :

à une dimension (tableau unidimensionnel ou vecteur)
à plusieurs dimensions (tableau multidimensionnel )
Les tableaux
Déclaration des tableaux
La déclaration d'un tableau à une dimension s'effectue en précisant le
type de ses éléments et sa dimension :
Syntaxe : Type identificateur[dimension];
Exemple : float notes[30];

La déclaration d’un tableau permet de lui réserver un espace mémoire

dont la taille (en octets) est égal à : dimension * taille du type
Exemple :
short A[100]; // on réserve 200 octets (100* 2 octets)
char mot[10]; // on réserve 10 octets (10* 1 octet)
Les tableaux

En C, le nom d'un tableau est le représentant de l'adresse du

premier élément du tableau. Les adresses des autres composantes
sont calculées (automatiquement) relativement à cette adresse.

Exemple:
short A[5] = {1200, 2300, 3400, 4500, 5600};
Les tableaux
Initialisation à la déclaration:
On peut initialiser les éléments d’un tableau lors de la déclaration, en indiquant la liste des
valeurs respectives entre accolades.
Ex: int A[5] = {1, 2, 3, 4, 5};

Si la liste ne contient pas assez de valeurs pour toutes les composantes, les composantes restantes
sont initialisées par zéro.
Ex: short T[10] = {1, 2, 3, 4, 5};

La liste ne doit pas contenir plus de valeurs que la dimension du tableau.

Ex: int C[3] = {1, 2, 3, 4, 5}; → Erreur

Il est possible de ne pas indiquer la dimension explicitement lors de l'initialisation. Dans ce cas
elle est égale au nombre de valeurs de la liste.
Ex: short T[ ] = {1, 2, 3, 4, 5}; → tableau de 5 éléments
Les tableaux
Accès aux composantes d’un tableau

L'accès à un élément du tableau se fait au moyen de son indice.

Par exemple, T[i] donne la valeur de l'élément i du tableau T.

L’indice du premier élément du tableau est 0. L’indice du dernier élément est

égal à la dimension-1
Ex: int T[ 5] = {9, 8, 7, 6, 5}; → T[0]=9, T[1]=8, T[2]=7, T[3]=6, T[4]=5

On traite les tableaux élément par élément de façon répétitive en utilisant des
boucles.
Les tableaux
Saisie et affichage d’un tableau:

Saisie des éléments d’un tableau T d’entiers de taille n :

for(i=0; i<n; i++)
{
printf("Entrez l'élément %d \n ",i + 1);
scanf("%d", &T[i]);
}

Affichage des éléments d’un tableau T de taille n:

for(i=0; i<n; i++)
printf("%d\t", T[i]);
Les tableaux
Exercice:
Écrire un programme permettant de calculer le nombre d'étudiants ayant une note supérieure
à 10 :
#include<stdio.h>
main ( )
{ float notes[20];
int nbre,i;
for(i=0; i<20; i++) {
printf("Entrez notes[ %d] \n ", i);
scanf("%d", &notes[i]); }
nbre=0;
for (i=0; i<20; i++)
if (notes[i]>10) nbre+=1;
printf(" le nombre d'étudiants ayant une note > à 10 est égal à %d: ", nbre);
}
Les tableaux à deux dimensions

En C, un tableau multidimensionnel est considéré comme un tableau dont les

éléments sont eux même des tableaux.
Un tableau à deux dimensions se déclare donc de la manière suivante :
int mat[10][20];
En le rapprochement avec les mathématiques, on peut dire que mat est une
matrice de 10 lignes et de 20 colonnes.
Les tableaux à deux dimensions

▪ Un tableau à deux dimensions A[n][m] est à interpréter comme un tableau

unidimensionnel de dimension n dont chaque composante A[i] est un tableau
unidimensionnel de dimension m.
▪ Un tableau à deux dimensions A[n][m] contient n* m composantes. Ainsi lors de la
déclaration, on lui réserve un espace mémoire dont la taille (en octets) est égal à : n*m*
taille du type.
▪ Les éléments d’un tableau sont stockées en mémoire à des emplacements contigus ligne
après ligne.
▪ Comme pour les tableaux unidimensionnels, le nom d'un tableau A à deux dimensions est
le représentant de l'adresse du premier élément A=&A[0][0]
Saisie et affichage d’un tableau a 2 dimmensions:

#include <stdio.h> // Affichage du tableau

int main() { printf("\n--- Affichage du tableau ---\n");
int i, j, lignes, colonnes; for(i = 0; i < lignes; i++) {
int tab[lignes][colonnes]; // Déclaration du tableau à 2 for(j = 0; j < colonnes; j++) {
dimensions printf("%5d", tab[i][j]); // %5d pour bien
// Saisie du nombre de lignes et de colonnes aligner
printf("Entrez le nombre de lignes : "); }
scanf("%d", &lignes); printf("\n");
printf("Entrez le nombre de colonnes : "); }
scanf("%d", &colonnes); return 0;
}
// Saisie des éléments du tableau
printf("\n--- Saisie du tableau ---\n");
for(i = 0; i < lignes; i++) {
for(j = 0; j < colonnes; j++) {
printf("tab[%d][%d] = ", i, j);
scanf("%d", &tab[i][j]);
}
}