Présentation Cours C

Cours: Introduction Langage
C
LOYA Youssouf
youssouf.loya@u-auben.com
1
Objectifs
 Le cours vise à initier les étudiants à la programmation.
 A l’issue du cours, les étudiants devraient être capables

de :
 Maîtriser les notions de base du langage C
 Apprendre à traduire correctement en C les

algorithmes classiques
 Utiliser le langage C pour automatiser des traitements
simples.
2
Plan
 Généralités
 Entrées/sorties conversationnelles
 Opérateurs du langage C
 Instructions du langage C
3
Prérequis
 Cours d’introduction à l’algorithmique, 1ère année

 Savoir utiliser un éditeur de texte
4
Evaluations
 1 devoir sur table
 TPs à rendre
 Des évaluations à chaud
5
Outils logiciels-Bibliographie
 gcc
 Dev C++
 [1] Peter Aitken, Bradley L. Jones: Le langage C
Apprenez rapidement et simplement les bases du
langage C
2009 Pearson Education France
 [2] Claude Delannoy: Programmer en langage C-
Cours et exercices corrigés
2009 Ereyrolles
[3] Rémy Malgouyres, Rita Zrour, Fabien Feschet:
Initiation à l’algorithmique et à la programmation en C
Cours avec 129 exercices corrigés.
2011 Dunod 6
1 – Généralités
Etapes de réalisation de programmes

Présentation de C
Définition d’objets
7
Etapes de réalisation de programmes
Problème à résoudre Faire faire Ordinateur
Exécutable
Spécification (Quoi faire?)
(Comment traduire?) Traduction

Cahier de charges
Code source
Analyse (Comment faire?)

(Comment dire?) Codification
(Comment faire faire ?)
Stratégies Conception Algorithme
8
Présentation de C
Historique de C
 C a trois ancêtres : les langages CPL, BCPL et B.
 CPL (Combined Programming Language) a été conçu
au début des années 1960 - universités de Cambridge
et de Londres. Fortement typé mais trop complexe.
Disparition dans les années 70.
 BCPL (Basic CPL) mis au point à Cambridge en 1966
par Martin Richards. Version simplifiée de CPL. A
permis l’écriture d’un premier compilateur et de divers
systèmes d’exploitation.
 B par Ken Thompson vers 1970 dans les laboratoires
Bell. Version simplifiée du BCPL 9
Présentation de C
Historique de C
 Le langage C est développé par un collègue de Ken
Thompson, Dennis Ritchie qui ajouta les tableaux, les
pointeurs, les nombres à virgule flottante, les structures...
1972 fut l'année de développement la plus productive et
sans doute l'année de baptême de C.
 En 1973, C fut suffisamment au point pour que 90% de
UNIX puisse être récrit avec.
 Une première définition du langage est apparue en 1978
avec l’ouvrage de Ritchie et Kernighan «The C
programming language ».
10
Présentation de C
Historique de C
 Son succès international a contribué à sa normalisation:
 ANSI (American National Standard Institute) 1989
 ISO (International Standadization Organisation) 1999
 CEN (Comité Européen de Normalisation) en 1993
11
Présentation de C
Caractéristiques de C
 Langage polyvalent permettant le développement de
systèmes d'exploitation, de programmes applicatifs
scientifiques et de gestion.
 Langage compilé.
 Langage structuré. Le programme est divisé en blocs qui
peuvent contenir leurs propres variables ainsi que d ’autres
blocs.
 Langage évolué qui permet néanmoins d'effectuer des
opérations de bas niveau.
 Langage portable grâce à l'emploi d’un grand nombre de
bibliothèques dans lesquelles sont reléguées les
fonctionnalités liées à la machine.
 Langage efficace et puissant.
 Langage fortement typé 12
Présentation de C
Structure générale d’un programme en C
 Un programme écrit en C se compose généralement
de plusieurs fichiers.
 Il y a deux sortes de fichiers:
‒ Les fichiers source ou de définition ou d’implémentation
qui contiennent effectivement des instructions qui

réalisent les traitements. Leurs noms ont l’extension
.c
‒ Les fichiers d’entête ou de déclaration ou de
spécification, d’extension .h, qui regroupent des
déclarations d’objets pouvant être utilisés dans
plusieurs fichiers source.
 On organise généralement les fichiers sources de
façon 13
modulaire, en assemblant des éléments communs
Présentation de C
 Un fichier source comporte plusieurs parties:

14
Présentation de C
15
Présentation de C
Directives de précompilation
Elles permettent d'effectuer des manipulations sur le texte
du programme source avant la compilation.
Une directive du préprocesseur est une ligne de
programme source commençant par le caractère dièse
(#).
Inclusion de fichiers
 Syntaxe: #include < nom_fichier > ou
#include ″ nom_fichier ″
Insère le fichier nom_fichier à l'endroit où la directive est
placée. Si le nom du fichier est encadré par des doubles
quotes, la recherche de ce fichier se fait dans le dossier
courant. Si ce nom est encadré par des chevrons <> la
recherche est faite dans le dossier système.
16
Présentation de C
Définition de constantes symboliques
 Syntaxe: #define nom_constante valeur_constante
A chaque fois que le nom de la constante sera rencontré,
sa valeur lui sera substituée dans le code source.
Définition de macros
Syntaxe: #define nom_macro(liste_arg) expression
L'expression est substituée à la macro dans le code
source, en remplaçant les arguments en lieu et place
dans l'expression par ceux passés à l'identifiant.
Exemple: #define max( a, b) ((a) > (b))?(a) : (b)
17
Présentation de C
Compilation conditionnelle
Syntaxe: #if expression bloc1 #else bloc2 #endif
#if expression1 bloc1 #elif expression2 bloc2 #else bloc3
#endif
Permet de compiler bloc1 si expression est vraie, bloc2
si expression est fausse.
 Syntaxe: #ifdef symbole bloc1 #else bloc2 #endif
#if defined(symbole) bloc1 #else bloc2 #endif
Permet de compiler bloc1 si symbole est défini, bloc2
sinon.
Syntaxe : #ifndef symbole bloc1 #else bloc2 #endif
#if!defined(symbole) bloc1 #else bloc2 #endif
Permet de compiler bloc1 si symbole n’est pas défini,
bloc2 sinon. 18
Présentation de C
Déclarations globales
Description des objets (déclaration de types, de variables,
de fonctions, ….) utilisables par toute instruction qui suit
dans le fichier.
Fonctions
Ce sont des sous-programmes dont les instructions vont
définir un traitement sur des variables.
Tout programme doit comporter la fonction principale main
qui constitue le point d’entrée du programme lors de
l’exécution.
Commentaires
Les commentaires multi-lignes /* */
19
Présentation de C
#include <stdio.h> /*demande au préprocesseur d’inclure le fichier stdio.h*/
#define DEBUT -10 /*demande au préprocesseur de remplacer par la suite DEBUT par -10*/
#define FIN 10
#define MSG "Programme de démonstration\n″
int carre(int x); /* déclaration des fonctions carre et cube*/
int cube(int x);
int main(void ) /* programme principal */
{ /* début du bloc de la fonction main */
int i; /*définition des variables locales */
printf(″%s″, MSG);
for ( i = DEBUT; i <= FIN ; i++ )
{
printf(" %d carré: %d cube: %d\n″, i, carre(i), cube(i));
} /* fin du bloc for */
return 0;
} /* fin du bloc de la fonction main */
int cube(int x) { /* définition de la fonction cube */

return x * carre(x);
}
int carre(int x) { /* définition de la fonction carre */
return x * x;
}
20
Présentation de C
Création d’un exécutable en C
 La création d’un exécutable comprend 4 phases :
21
Présentation de C
Edition du code source
 Consiste à saisir, à enregistrer et à modifier, à partir d’un
clavier, tout ou partie des instructions, exprimées en C,
du programme. Les textes saisis sont enregistrés dans
des fichiers .c ou .h.
Précompilation des fichiers source
 Les fichiers .c sont soumis au préprocesseur.
 Le préprocesseur fabrique de nouveaux fichiers sources
C, avec les macros remplacées, les commentaires
supprimés, les fichiers d’entête inclus…
22
Présentation de C
Compilation séparée des fichiers source
 c’est à dire la traduction en langage machine par le
compilateur du texte en langage C fourni par le
préprocesseur.
 Le résultat est le code objet, sauvegardé un fichier objet
d’extension .o ou .obj
Edition de liens
 Regroupement par l’éditeur de lien de tous les codes des
fichiers objets (sources et bibliothèque) et résolution des
références inter-fichier.
 Le produit est un fichier exécutable par la machine.
23
Présentation de C
 Exemple:
24
Présentation de C
Mots réservés du langage C
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
25
Définition d’objets
Types de données simples
Catégorie Type Signification Taille (en octets) Etendue
vide void Absence de type
char Caractère 1 -128 à 127

Caractères
unsigned char Caractère non signé 1 0 à 255
short int ou short Entier court 2 -32768 à 32767
unsigned short int Entier court non signé 2 0 à 65535
2 (processeur 16 bits)
-32768 à 32767
int Entier
-2147483648 à 2147483647
Entiers
0 à 65535
unsigned int Entier non signé
0 à 4294967295
long int ou long Entier long 4 -2147483648 à 2147483 47
unsigned long int Entier long non signé 2 0 à 4 294 967 295 Précision
float flottant (réel) 4 3.4*10-38 à 3.4*1038 6chiffres (10-6)
Réels double flottant double 8 1.7*10-308 à 1.7*10308 15chiffres (10-15)
long double flottant double long 10 3.4*10-4932 à 3.4*104932 17chiffres (10-17)
26
Littéraux caractères
 Un caractère se note en mettant entre quotes simples le
caractère ou son code octal précédé de \ ou son code
hexadécimal précédé de \x.
Exemple: notation de a: 'a', '\141', '\x61'
 Table des codes ASCII étendus
27
28
 Il existe des séquences d'échappement particulières qui
permettent de noter certains caractères spéciaux:
séquence Signification séquence Signification
\a Bip sonore \v Tabulation verticale
\b Backspace \\ \
\f Saut de page \' '
\n Saut de ligne \" "
\r Retour chariot \? ?
\t Tabulation horizontale
 Un caractère peut être considéré comme un entier, la

valeur du code qui le représente.
29
Littéraux entiers
 Un entier peut se noter en base décimale(10), sous forme
de séquence de chiffres de 0 à 9 précédée
éventuellement des signes – ou +. Exemple: 430
 Un entier peut se noter en base hexadécimale(16), sous
forme de séquence de chiffres de 0 à 9 et de lettres de A
à F ou de a à f commençant par 0x ou 0X et précédée
éventuellement des signes – ou +. Exemple: 0x1AE→430
 Un entier positif peut se noter en base octale(8), sous
forme de séquence de chiffres de 0 à 7commençant 0 et
précédée éventuellement des signes – ou +.
Exemple:0656→430
 Chaque notation peut être suivie par U ou L en
minuscules ou majuscules pour préciser si l’entier est
non signé ou s’il est long. 30
Littéraux réels
 Syntaxe:
[signe] chiffres [.[chiffres]][e|E [signe] exposant][F|L|f|l]
 F permet de préciser si le réel est de type float et L
permet de préciser si le réel est de type long double. En
cas d’absence de F et L, le réel est de type double.
 En notation décimale, le point décimal est obligatoire.
Alias de type
 Syntaxe: typedef <type> <alias> ;
 Exemple: typedef double Monetaire;
31
Déclaration et initialisation de variables
Déclaration
 syntaxe:
<type> <nomvar1> ,..., <nomvarn>;
 Exemple: int n; float prixttc, tva, montant;
Initialisation
 Syntaxe:
<type> <nomvar1> = <val1>,..., <nomvarn>=<valn>;
 Exemple: int n=10; float prixttc, tva=0.02,montant;
32
Définition de constantes
 syntaxe:
#define <symbole> <val>
ou
const <type><cst1> =<val1>,...,<cstn> =<valn>;
 Exemple:
#define PI 3.1415
const float PI = 3.1415;
33
2– Entrées/sorties
conversationnelles
Affichage de données
Lecture de données
34
Affichage de données
Un programme informatique réalise en général trois
fonctions:
 Acquisition des données;
Transformation automatique des données (traitement);
Restitution de résultats.
Les instructions d’entrée/sortie donc permettent au
programme d’obtenir des données de l’utilisateur et de lui
communiquer les résultats
Utilisateur
Ordinateur
35
Fonction printf de stdio.h
 Syntaxe: printf(chaîne de format, p1, p2, ..., pn);
La fonction printf a comme premier argument une chaîne
de caractères (suite caractères placée entre double quotes) qui
spécifie:
Des caractères à afficher tels quels;
Des caractères de contrôle (\n, \t,…);
des formateurs de la forme : %-m.pt où
• - (facultatif) : précise un cadrage à gauche (par défaut
le cadrage est à droite) c’est à dire les éventuels espaces
supplémentaires sont placés à droite de l’information affichée.
• m (facultatif) : définit le gabarit c’est à dire le nombre total minimum
de colonnes réservées à l’affichage de l’information.
• p(facultatif) : précision ie nombre de chiffres après le point décimal.
36
spécifie:
• : précise le type de l’expression à afficher.  peut
être :
d nombre entier signé en décimal (int)
u ou i nombre entier non signé en décimal(unsigned int)
o nombre entier non signé en octal (int )
x nombre entier non signé en hexadécimal(int)
c caractère (char)
e nombre flottant en notation exponentielle (double, les float sont
convertis en double)
f nombre flottant en notation décimal(double, les float sont
convertis en double)
37
spécifie:
• : précise le type de l’expression à afficher.  peut
être :
s chaîne de caractères (char*)
p pointeur
• t(facultatif): précise la taille du type. t peut être :
h devant d ou x ou o ou u pour les entiers courts
( short int ou unsigned short int)
l devant d ou x ou o ou u pour les entiers longs
(long int ou unsigned long)
l devant e ou f pour les nombres flottants longs (long double)
38
 p1, p2, ..., pn: sont des paramètres (valeurs) à afficher.
chaîne de format doit contenir autant de formateurs que de
paramètres pi.
 Gabarit et précision variables
 printf("%*d",n, i) n donne le nombre de caractères pour i
 printf("%*.3f,n,x) n donne le nombre total de caractères pour x
 printf("%*.*f,n,m,x) n donne le nombre de total caractères
m donne le nombre de caractères pour la partie décimale
 Valeur de retour
 La fonction printf fournit une valeur qui est le nombre de
caractères qu’elle a effectivement affichés (-1 en cas d’erreur). 39
 Exemple
Exemple 1: Affichage d’un texte simple
printf("bienvenue dans le programme"); bienvenue dans le programme
Exemple 2: Affichage d’un entier en base 10, base 16 et base 8

printf(%d ,25);
printf(%x ,25); 25 19 31
printf(%o ,25);
Exemple 3: Affichage de textes et d’entiers
printf("Affichage du nombre 1 : %d. Affichage du nombre 2 : %d",12,34);
Affichage du nombre 1 : 12. Affichage du nombre 2 : 34
Exemple 4: Affichage de la valeur d’une expression

int a=5;
printf("%d plus %d egale %d",10,a,10+a); 10 plus 5 egale 15
Exemple 5: Affichage de %
87%
printf("Resultat des ventes : %d %%",87);
40
 Exemple
Exemple 6: Affichage d’un entier et d’un réel avec gabarit
printf("Entier:%4d Reel:%9f",12,1.23456); Entier: 12 Reel: 1.234560
Exemple 7: Affichage avec gabarit avec le vide rempli par des zéros
printf("entier:%04d reel:%09f",12,1.23456);
Entier:0012 Reel:01.234560
Exemple 8: Affichage de réels avec précision

printf("%.8f %.2f",1.23456,1.23456);
1.23456000 1.23
41
 Exemple
42
 Erreurs avec printf
 Code de format en désaccord avec le type de l’expression à afficher
Conséquence : mauvaise interprétation si même taille (int en %u),
sinon, conséquences plus désastreuses.
 Nombre de code de format différents du nombre d’expressions de la
liste
Conséquence 1 : si des expressions de la liste n’ont pas de format,
elles ne seront pas affichées.
printf("%d" , n, p ); /*valeur de p ne sera pas affichée */
Conséquence 2 : s’il y a trop de code de format, printf cherchera à
afficher n’importe quoi.
printf("%d %d" , n ); n=8 8 2
43
Fonction putchar et puts de stdio.h
putchar(caractère) permet d’afficher un caractère
En effet putchar permet d’afficher le caractère dont le code
ASCII est donné entre parenthèse et renvoie -1 en cas
d’erreur sinon renvoie le code ASCII du caractère affiché,
Exemple 1
char c; Exemple 2
putchar(‘65’); A
c='a'; a
putchar ( c ); b
putchar ('\n');
putchar('b');
puts(chaîne) permet d’afficher une chaîne de caractère s.

44
Lecture de données
Fonction scanf de stdio.h
 Syntaxe: scanf(chaîne de format, arg1, arg2, ..., argn);
arg1,...,argn doivent être des adresses d’emplacements mémoire.
La chaîne de format indique le format dans lequel les données lues
sont converties (représentées) c’est-à-dire précise leurs
représentations en interne. Elle ne contient que des formateurs.
Comme pour printf, les formateurs sont spécifiés par un caractère
précédé du signe %. Les formats valides pour la fonction scanf
diffèrent légèrement de ceux de la fonction printf :
45
Lecture de données
 Syntaxe: scanf(chaîne de format, arg1, arg2, ..., argn);
Les formats valides pour la fonction scanf diffèrent légèrement de
ceux de la fonction printf : char t[20];
Format Type d'objet pointé Représentation de la donnée saisie int i ; float x;
%d int décimale signée
%hd short int décimale signée
scanf ("%s %d %f", t,&i,&x);
%ld long int décimale signée Réponses :
%u unsigned int décimale non signée 1/ abcde 123 0.05
%hu unsigned short int décimale non signée 2/ abcde 123 
%lu unsigned long int décimale non signée
%o Int octale
0.05
%ho short int octale 3/ abcde
%lo long int octale 123 
%x Int hexadécimale 0.05
%hx short int hexadécimale
%lx long int hexadécimale
%f float flottante notation décimale  Valeur de retour
%lf double flottante notation décimale
%Lf
%e
long double
float
flottante notation décimale
flottante notation exponentielle
 La fonction scanf fournit une
%le double flottante notation exponentielle
%Le long double flottante notation exponentielle valeur de retour qui est le
%c char caractère
%s char* chaîne de caractères
nombre de valeurs
46
Lecture de données
 Gabarit
Le gabarit indique le nombre maximal de caractères pouvant être lus.
Il est défini en insérant une valeur entière avant le code de formatage
Exemple 1:saisir un entier de 5 chiffres maximum
int i;
rep : 325789  i = 32578
scanf("%5d",&i);
Exemple 2
int i; float x;char c;

rep : 10234.567t i=10
scanf("%3d%5f%c,&i,&x,&c);
x=234.5 c='6
47
Lecture de données
 Rôle des caractères d’espacement
Dans les réponses
, , tabulation servent de délimiteurs pour les valeurs numériques
et les chaînes de caractères (mais pas pour les caractères)
Exemple 1
scanf ("%d%f",&i,&x); rep1 : 123    456  i = 123 , x = 456.0
rep2 : 123456  i = 123456 , x : pas encore lu (en
attente)
Exemple 2
rep : abc 12 ch =
scanf("%s%d",ch,&i); "abc" , i=12
Exemple 3
rep1 : ab c1= 'a'
scanf ("%c%c",&c1,&c2); , c2 = 'b'
rep2 : ab c1=
'a' , c2 = 
Exemple 4 rep1 : ab c1= 'a' , c2 =
scanf ("%c%c%c",&c1,&c2,&c3); 'b', c3= 
rep2 : ab c1= 'a' , c2 =
'b'
c c3 48
=
Lecture de données
 Rôle des caractères d’espacement
Dans les chaînes de format
Dans la lecture de valeurs numériques, , tabulation ne jouent
aucun
rôle: scanf ("%d%f",&i,&x)  scanf ("%d%f",&i,&x)
Dans la lecture de caractères, , tabulation indiquent de sauter les
Exemple
, 1
rep1 : abc c1= 'a' , c2 = 'b', c3= 'c'
scanf ("%c%c%c",&c1,&c2,&c3);
rep2 : abc c1= 'a' , c2 = '', c3= 'b'
tabulations et 
Exemple 2
rep1 : abc c1= 'a' , c2
scanf ("%c%c%c",&c1,&c2,&c3); = 'b', c3= 'c'
rep2 : abc c1= 'a' , c2 = 'b',
c3= 'c'
rep2 : ab 
49
c c1= 'a' , c2
Lecture de données
 Définition de caractères de délimiteurs des valeurs lues
Nous avons vu que, par défaut, ce sont les caractères
d’espacement qui délimitent les valeurs entrées.
Il est possible de préciser les caractères de séparation que
l’on veut.
Il suffit de placer ces caractères entre les formateurs.
Exemple: lecture de 3 valeurs séparées par des points-virgules
int i,j,k;
scanf("%d;%d;%d",&i,&j,&k);
rep : 15;17;8 i= 15 , j= 17,
50
k=8
Lecture de données
 Erreurs avec scanf
 Code de format en désaccord avec le type de l’expression
Si même taille introduction d’une mauvaise valeur
Si la variable a une taille inférieure écrasement d’un
emplacement mémoire consécutif à cette variable
 Nombre de codes de format différent du nombre
d’éléments de la liste:
Scanf("%d",&n, &p); seule la valeur de n est lue
Scanf("%d%d",&n); on affecte une valeur à un
emplacement aléatoire de la mémoire
51
Lecture de données
Fonction getchar de stdio.h
 Syntaxe: getchar()
getchar() sert à la lecture de caractères isolés.
getchar() renvoie le code ascii du caractère lu et -1 en cas d’erreur.
Exemple 1
char c;
c = getchar();
Exemple 2
char c1,c2;
c1 = getchar(); /* acquiert le 1er
caractère*/
getchar (); /* filtre le <cr>*/
c2 = getchar () ; /* acquiert le 2ème caractère*/
52
Lecture de données
Accès bufférisé
scanf et getchar utilisent un accès bufférisé au clavier pour les
caractères et les chaînes de caractères.
C’est-à-dire que les données issues du clavier sont stockées dans
une zone de mémoire appelé tampon, et attendent que le programme
ait besoin d’elles.
Ces deux fonctions prennent un caractère dans le tampon et le

suppriment du tampon. Si le tampon est vide, le programme se
bloque jusqu’à ce qu’un char soit placé dans le tampon, c'est-à-dire :
jusqu’à ce qu’une valeur soit saisie au clavier.
Pour synchroniser la lecture, il faut vider le tampon par l’instruction
53
fflush(stdin) ;
3– Opérateurs du langage C
Expression
Opérateurs arithmétiques
Opérateurs binaires
Opérateurs relationnels
Opérateurs booléens
Opérateurs d’affectation
Opérateurs d’incrémentation et de décrémentation
Opérateur conditionnel
Opérateur virgule ou séquentiel
Opérateurs adresse, de taille et de transtypage
Priorité des opérateurs
54
Expression
Une expression est une suite bien ordonnée de noms de

variables et de constantes, de littéraux, d’appels de
fonctions, d’opérateurs et de parenthèses ayant une
valeur. En fait, en C, on appelle expression tout ce qui a
une valeur.
Les opérateurs interviennent donc dans la formation des
expressions et C possède un grand nombre
d’opérateurs.
55
Opérateurs arithmétiques
 Les opérateurs arithmétiques s’appliquent sur des

nombres.
 Ils ont les mêmes priorités qu’en mathématiques.
 Ils induisent une conversion dans le sens:
char→ short → int →long →float →double →long double
et signed → unsigned
56
(cf. Exo6 exo7 TPn°2)
Opérateurs binaires
Exemple
57
Opérateurs relationnels
Le résultat de la comparaison entre deux expressions

est un entier non nul (généralement 1) si la
comparaison est vraie et zéro (0) si elle est fausse.
(cf. Exo8 TPn°2)
58
Opérateurs booléens
Le résultat d’un opérateur booléen est un entier non

nul (généralement 1) si l’expression est vraie et nul(0)
si elle est fausse.
(cf. Exo8 TPn°2)

59
Opérateurs d’affectation
 Affectation =
 Affectations composées
(cf. Exo8
TPn°2)
60
Opérateurs d’affectation
 Les opérandes de gauche des opérateurs d’affectation
doivent être des lvalues.
 Les opérateurs d’affectation modifient la valeur de leurs
opérandes de gauche.
 Les opérateurs d’affection induisent des conversions
implicites: la valeur de l’opérande de droite est convertie
dans le type de l’opérande de gauche. Ces conversions
peuvent être dégradantes.
 Les opérateurs d’affectation ont une associativité de
droite vers la gauche.
61
Opérateurs d’incrémentation et de
décrémentation
 Les opérateurs d'incrémentation (++) et de
décrémentation (--) sont des opérateurs unaires.
 L'opérateur ++ ajoute 1 à son opérande.
 De même l'opérateur -- retranche 1 à son opérande.
 On peut les utiliser soit devant leurs opérandes(préfixé :
mise à jour des opérandes avant leurs utilisations dans
l'expression courante), soit derrière leurs opérandes
(postfixé : mise à jour après leurs utilisations dans
l'expression courante). (cf. Exo9 Exo10 Exo11 TPn°2)
 Les expressions obtenues avec ces opérateurs ont pour
valeur la valeur qu’ont leurs opérandes au moment où on
les rencontrent dans les expressions. 62
Opérateur conditionnel
 L’opérateur conditionnel ?: est un opérateur ternaire (trois

opérandes) qui retourne la valeur de son deuxième
opérande si son premier opérande est vrai et la valeur de
son troisième opérande si son premier opérande est faux.
 Syntaxe:
<expression1> ? <expression2 >: <expression3>
(cf. Exo5 TPn°2)
63
Opérateur virgule ou séquentiel
 L’opérateur séquentiel (ou virgule) permet d’évaluer de

gauche à droite une série d’expressions séparées par des
virgules et de renvoyer la valeur de la dernière expression
évaluée.
 Syntaxe:
<expression_1>, <expression_2>, ... , <expression_n>
64
Opérateurs d’adresse, de taille et de
transtypage
Opérateur adresse &
 L’opérateur adresse & appliqué à une variable permet
d’obtenir l’adresse de celle-ci.
&<nom_variable>
Opérateur taille sizeof

 L’opérateur taille sizeof est utilisé pour déterminer la taille
(en octets) d'une expression ou d'un type. Sizeof retourne
une valeur de type size_t.
 Syntaxes:
sizeof <var> fournit la taille de la variable <var>
sizeof <const> fournit la taille de la constante <const>
sizeof (<expr>) fournit la taille de l’expression <expr>
sizeof (<type>) fournit la taille d’une expression de type <type>65
Opérateurs d’adresse, de taille et de
transtypage
Opérateurs de transtypage
 Il est possible à l’utilisateur de modifier explicitement le
type d'une expression grâce à l’opérateur de transtypage:
 Sa syntaxe:
( type ) expression
 Exemple:
int i=1;
float x=3.14;
i = (int) x;
x = (float) i;
(cf. Exo8 TPn°2) 66

Priorité des opérateurs
67
4– Instructions du langage C
Instructions simples
Bloc d’instructions
Structures de contrôle
68
Instructions simples
Une instruction simple est terminée obligatoirement par
un point virgule. Une instruction simple peut être :
L’instruction vide
L’instruction vide se compose uniquement d'un point
virgule (;).
Syntaxe : ;
Une instruction expression
Une instruction expression est une expression terminée
par point virgule.
Syntaxe : <expression> ;
L’expression <expression> est évaluée, et sa valeur est
ignorée.
Les instructions expressions n’ont d’utilité que lorsque les
expressions réalisent des effets de bord (affectations,
appel de fonctions, ….)
69
Bloc d’instructions
Un bloc d’instructions ou instruction est une suite de
déclarations/définitions et d’instructions délimitée par des
accolades {} vue comme une instruction unique.
Les instructions figurant dans un bloc peuvent être
quelconques : instructions simples, blocs ou structures de
contrôle.
Les variables déclarées dans un bloc ne sont accessibles
qu’à l’intérieur de ce bloc et disparaissent à la sortie du
bloc.
Exemple : {
int i = 3, j;
double x = 2.2, y = 3.3;
y = 0.5 * (x + y);
int k = 1 - (j = i);
} 70
Structures de contrôle
Les structures de contrôle permettent de gérer l’exécution
des autres instructions du programme.
Les structures de choix
La sélection simple et l’alternative:
if ( <expression> )
<bloc1>
[else
<bloc2>]
Le choix multiple: switch ( <expression> )
{
case <e1> :
[<bloc1> ]
[break;]
case <e2> :
[<bloc2>]
[break;]
..............................
.... 71
case <en> :
Les structures répétitives
La boucle while:
while ( <expression> )
<bloc>
La boucle do while:

do
<bloc>
while ( <expression>) ;
La boucle for:

for(<expression1>; < expressin2>;<expression3>)
<bloc>
72
Les instructions de branchement non conditionnel
Ces instructions permettent de poursuivre l'exécution du
programme en un autre point de celui-ci.
L’instruction break
L’instruction break provoque la sortie immédiate de la
boucle ou switch en cours. En cas de boucles imbriquées,
break fait sortir de la boucle la plus interne.
Syntaxe: break;
73
L’instruction continue
L'instruction continue provoque l’abandon de l’itération
courante d’une boucle et le passage à la prochaine
itération ; les instructions qui se trouvent entre l’instruction
continue et la fin du corps de la boucle sont ignorées pour
l’itération courante. En cas de boucles imbriquées,
continue permet uniquement de continuer la boucle la plus
interne.
Syntaxe: continue; 74
L’instruction goto
L'instruction goto permet d'effectuer un saut jusqu'à
l'instruction préfixée par l’étiquette correspondante.
Syntaxe: goto <etiquette>;
où <etiquette> est une étiquette marquant la ligne
destination dans le programme. Les étiquettes sont
simplement déclarées avec la syntaxe suivante :
<etiquette>:
75
5– Fonctions
Généralités
Mode de passage des paramètres
Fonctions récursives
Classes de stockages
(cf support de cours P. 58) 76
Généralités
Une fonction est un ensemble d'instructions nommé
réalisant une tâche précise, auquel on peut passer
des données et qui peut retourner une valeur.
Définition de fonction
Définir une fonction, c’est associer un nom unique à une
suite d’instructions. La définition d’une fonction se fait
selon la syntaxe:
<type> <nom>([<type1> <par1>, ... , <typen> <parn>])
{
[<déclarations de variables locales> ]
<liste d'instructions>
}
<type> représente le type de la valeur renvoyée; si la fonction ne
renvoie pas de valeur, on met void à la place de <type>
<nom> est le nom de la fonction
77
Généralités
 Syntaxe
La définition d’une fonction se fait selon la syntaxe:
{
}
<type1> <par1>, …, <typen> <par2> représentent les éventuelles
informations avec leurs types dont les instructions de la fonction ont
besoin pour s’exécuter. <par1>, …,<par2> sont des paramètres
formels
<déclarations de variables locales> représentent les données
intermédiaires dont la fonction peut avoir besoin. Ces variables
disparaissent dès que l’on quitte la fonction.
<liste d'instructions> décrivent ce que fait la fonction. Si la fonction
doit renvoyer une valeur, elle doit contenir au moins une instruction
de retour à la fonction appelante, return <expression>; 78
Généralités
La définition d’une fonction se fait selon la syntaxe:
{
}
<type> <nom>([<type1> <par1>, ... , <typen> <parn>]) est l’en-tête
ou le prototype de la fonction.
<nom>([<type1> <par1>, ... , <typen> <parn>]) est la signature de
la fonction.
{
est le corps de la fonction
}
79
Généralités
/* Fonction prenant un entier et renvoyant un entier
 Exemples long non signé */
/* Fonction prenant deux entiers unsigned long factorielle( int n )
et renvoyant un entier */ { int i;
int pgcd(int a, int b) unsigned long fact = 1;
{
while (a != b) for (i= 2; i<= n; i++)
{ {
if (a > b) fact*=i;
a = a -b; }
/*modifie a*/
return fact;
else
}
b = b - a;
/*modifie b*/ /* Fonction ne prenant pas de valeur et renvoyant un réel */
} double salaireBase( void)
return b; { double montant;
} printf( Entrer le salaire de base de l’employ\x82:);
scanf(%f, &montant);
return montant;
}
80
Généralités
 Exemples
/* Fonction prenant deux réels et ne renvoyant pas de valeur */
void equaion(float a, float b)
{
if(a == 0)
{
if(b == 0)
printf( S=IR\n);
else
printf( S={}\n);
}
else
printf( S={%.2f}\n, -b/a);
}
/* Fonction ne prenant pas de valeur et ne renvoyant pas de valeur */

void message( void)
{ printf( Bonjour\n);
}
81
Généralités
 Remarque
Lors de la définition d’une fonction, le compilateur
enregistre les instructions de la fonction mais n’exécute
aucune instruction.
La définition d’une fonction est généralement placée dans
un fichier source .c
82
Généralités
Déclaration de fonction
Comme tout objet en C, une fonction doit être déclarée
avant son utilisation. Cette déclaration consiste à donner le
prototype de la fonction suivie d’un point virgule :
<type> <nom>([<type1> <par1>, ... , <typen> <parn>]);
La déclaration d’une fonction fournit au compilateur la
description de la fonction qui est définie plus loin dans le
programme.
La déclaration d’une fonction se fait de préférence dans un
fichier d’en-tête .h
83
Généralités
Appel de fonction
L’appel d’une fonction est une demande d’exécution des
instructions de la fonction sur un ensemble de données
réelles appelées paramètres effectifs. La syntaxe:
<nom_fonction>([<arg1>, <arg2>, ..., <argn>])
L’appel d’une fonction est une instruction élémentaire et
l’appel d’une fonction renvoyant est une expression qui
peut
apparaître dans toute expression.
Une fonction peut être appelée soit dans la fonction
84
Généralités
Appel de fonction
Exemple:
#include <stdio.h> /*demande au préprocesseur d’inclure le fichier stdio.h*/
#define DEBUT -10 /*demande au préprocesseur de remplacer par la suite DEBUT par -10*/
#define FIN 10
#define MSG "Programme de démonstration\n″
int carre(int x); /* déclaration des fonctions carre et cube*/
int cube(int x);
int main(void ) /* programme principal */
{ /* début du bloc de la fonction main */
int i; /*définition des variables locales */
printf(″%s″, MSG);
for ( i = DEBUT; i <= FIN ; i++ )
{
printf(" %d carré: %d cube: %d\n″, i, carre(i), cube(i)); /* appels de carre et cube */
} /* fin du bloc for */
return 0;
} /* fin du bloc de la fonction main */
int cube(int x) { /* définition de la fonction cube */
return x * carre(x); /* appel de carre */
}
int carre(int x) { /* définition de la fonction carre */
return x * x;
} 85
Généralités
Appel de fonction
Les étapes de l’appel d’une fonction :
Enregistrement du contexte de la fonction appelante ;
Débranchement vers la fonction appelée ;
exécution du corps de la fonction appelée ;
retour de la fonction appelée
Appelant Appelé
{ {
..................... ......................
..................... .....................
.. ......................
..................... .....................
..................... }
..
.....................
.
.....................
..................... 86
..
Mode de passage de paramètres
Le mode de passage (ou de transmission) de
paramètres, est la manière dont les paramètres effectifs
sont associés aux paramètres formels lors de l’appel
d’une fonction.
En C, Il ya deux manières de passer des paramètres
effectifs à une fonction pour qu’elle puisse les manipuler
au travers des paramètres formels
87
Mode de passage par valeur ou par copie
C’est le mode de passage par défaut
Il consiste à affecter au nom du paramètre formel la
valeur du résultat de l’évaluation du paramètre effectif;
le paramètre effectif sert donc à fournir une valeur
initiale au paramètre formel.
88
Lors de l’appel d’une fonction ayant un paramètre passé
par valeur :
il y a création d’un emplacement local à la fonction,
correspondant au paramètre formel;
il y a copie de la valeur du paramètre réel dans
l’emplacement local ;
les modifications subies par le paramètre formel dans
la fonction sont subies par l’emplacement local ;
au retour, l’emplacement local est détruit et le
paramètre réel conserve sa valeur.
89
Ce mode de passage a les propriétés suivantes :
Les paramètres effectifs peuvent être des variables,
des constantes ou des expressions ;
Les modifications du paramètre formel restent locales à
la fonction et n’affectent pas le paramètre réel ;
Le temps d’exécution est élevé par rapport aux autres
modes de passage à cause du temps de recopie du
paramètre réel ;
Le mode de passage par valeur consomme de l’espace
mémoire car pendant l’exécution de la fonction, le
paramètre réel existe en deux exemplaires.
Ce mode de passage est déconseillé pour de grandes
structures de données.
90
Exemple :
int pgcd(int a, int b)
{
while (a != b)
{
if (a > b)
a = a-b; /*modifie a */
else
b = b -a; /*modifie b */
}
return b;
}
... . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int a = 5, b = 10, p = pgcd(a, b);
Printf("pgcd( %d , %d ) = %d\n″,a, b) ;
> pgcd(5, 10) = 5;//Les valeurs de a et b ne sont pas modifiées
91
Mode de passage par pointeur
Le passage par pointeur est en fait un passage par valeur
dans lequel les valeurs passées sont des adresses.
Ce mode est utilisé pour simuler le mode de passage par
variable.
Lors de l’appel d’une fonction ayant un paramètre passé
par pointeur :
il y a création d’un emplacement local à la fonction,
correspondant au paramètre formel qui est un pointeur;
il y a copie de l’adresse du paramètre réel dans
l’emplacement local ;
Le paramètre formel est manipulé à travers l’opérateur
d’indirection *.
92
Ce mode a les propriétés suivantes :
pas de copie du paramètre réel, d’où rapidité
d’exécution et économie de mémoire ;
Possibilité de modifier le paramètre réel ;
les paramètres doivent être des lvalues.
/*définition de la fonction*/
void permuter( int *a, int *b)/*paramètres:adresse des variables à permuter*/
{ int tp;
tp = *a; /* *a permet d’accéder à la variable pointée par a */
*a = *b;
*b = tp;
} /* Appel de la fonction */
int x = 7, y = 3 ;
permuter(&x, &y) ;/* on attend les adresses de x et y.*/
Printf(″x = %d\n ″<<x<<std::endl<<″y = ″<<y<<std::endl;
/*on constate la permutation*/
93
Ce mode permet la modification du paramètre réel; si l’on
veut empêcher la transmission des modifications du
paramètre formel au paramètre réel, il faut utiliser un
passage par pointeur sur constante:
struct TDate
{
int jour, mois, annee;
};
void affiche_date(const TDate * d)

{
printf(″%d / %d / %d\n″, d→jour, d→mois, d→annee);
}
94
Si le passage par pointeur permet d'avoir le même effet
que le passage par variable des autres langages, il
comporte cependant des lourdeurs :
au niveau de la définition de la fonction avec l'utilisation
de l'opérateur d'indirection *
au niveau de l'appel de la fonction avec l'utilisation de
l'opérateur d'adresse &
95
Choix du mode de passage
Passage par pointeur
oui
Effet de bord Passage par valeur
souhaité?
oui
non
Type du paramètre Passage par pointeur sur

élémentaire? constant
non
96
Fonctions récursives
Une fonction est dite récursive si elle comporte, dans son
corps, au moins un appel à elle-même, directement ou
indirectement.
Exemple : Calcul des coefficients du triangle de Pascal
Ci, j = 1 si j = 1 ou j = i
Ci, j = Ci-1, j-1+ Ci-1, j si j ≠1 et j≠ I
unsigned long coef(unsigned int i, unsigned int j)
{
unsigned long k;
if(j = = 1or j = = i)
k = 1;
else
k = coef(i-1, j-1) + coef(i-1, j); /*appel récursif */
return k;
}
97
Fonctions récursives
Lors de la définition d’une fonction récursive, on doit
observer les points suivants:
La fonction doit être définie de manière conditionnelle:
quand elle est appelée, il doit y avoir une vérification de
conditions d'arrêt. Si elles sont satisfaites, la récursivité
doit s'arrêter.
Au moins l'un des cas de l'expression conditionnelle doit
mener à une expression évaluable sans appel récursif.
Chaque fois qu'elle est appelée de manière récursive, un
ou plusieurs des arguments qui lui sont transmis doivent
se rapprocher de la condition d'arrêt.
Le nombre d'appel récursif pour parvenir à un résultat doit
être fini.
Enfin, dans une fonction récursive, la complexité du
problème doit être réduite à chaque nouvel appel récursif
98
Classes de stockage
 Portée d’une variable
La portée d'une variable est la zone du programme dans
laquelle elle est accessible. La portée d’une variable
dépend de l’endroit où elle déclarée :
La portée d’une variable déclarée avant la définition de
toute fonction s’étend sur tout le programme ;
La portée d’une variable déclarée dans une fonction ou
dans un bloc se limite à cette fonction ou à ce bloc.
 Durée de vie d’une variable
La durée de vie d'une variable est le temps pendant lequel
elle existe. On distingue :
Les variables permanentes (ou statiques)
Une variable permanente occupe un emplacement en
mémoire qui reste le même durant toute l'exécution du
programme.
99
Classes de stockage
 Durée de vie d’une variable
La durée de vie d'une variable est le temps pendant lequel
elle existe. On distingue :
Les variables permanentes (ou statiques)
Cet emplacement est alloué une fois pour toute lors de la
compilation dans une zone mémoire appelée segment de
données
Par défaut les variables permanentes sont initialisées à
leur valeur nulle par le compilateur.
Les variables temporaires
Les variables temporaires se voient allouer un
emplacement en mémoire de façon dynamique lors de
l'exécution du programme.
Elles ne sont pas initialisées par défaut.
Leur emplacement en mémoire est libéré par exemple à la fin
de l'exécution d'une fonction secondaire
100

Classes de stockage
 Variables globales
Une variable globale est une variable déclarée en dehors de
toute fonction. Sa portée s’étend sur la portion de code qui suit
sa déclaration. Les variables globales ont une durée de vie
permanente.
Variables externes
 Il est parfois nécessaire d’utiliser une variable globale
commune à plusieurs fichiers sources.
Dans ce cas, il est indispensable que le compilateur comprenne
que deux variables portant le même nom mais déclarées dans
deux fichiers différents correspondent en fait à un seul objet.
Pour cela la variable doit être définie (déclarée avec réservation
de mémoire) une seule fois.
Dans les autres fichiers qui l’utilisent, il faut simplement faire
référence à cette variable, sous forme d’une déclaration
précédée par le mot clé extern.
101
Classes de stockage
Variables externes
Cette déclaration n’alloue pas d’espace mémoire; elle prévient
le compilateur de l’existence d’un objet défini ailleurs et le
renseigne sur le type de l’objet.
Exemple:
/* Fichier 1 */
unsigned long n ; /* définition de la variable n */
/* Fichier 2 */
extern unsigned long n /* fait référence à la variable n définie dans le fichier 1 */
Remarque
 Une déclaration extern ne doit pas comporter d’initialisation
puisqu’elle n’alloue pas la variable.
102
Classes de stockage
Variables globales cachées
Par défaut les variables globales peuvent être partagées entre
plusieurs fichiers
Cependant il est possible de rendre inaccessible une variable
globale à l’extérieur du fichier où elle a été définie, à l’aide du
mot clé static.
Avec cette définition, il est impossible de faire référence à la
variable depuis un autre fichier à l’aide de la déclaration extern.
Exemple:
/* fich1.c */ /* fich2.c */
int tab[10]; extern int tab[10]
static int i; static int i, j;
static char j;
103
Classes de stockage
Variables globales cachées
Remarque
 Dans l’ensemble des fichiers qui constituent un programme,
chaque variable globale non cachée
 doit avoir un nom unique
doit faire l’objet d’une et une seule définition
peut être déclarée externe (y compris dans le fichier où elle
est définie) un nombre quelconque de fois.
Fonction statique
Les fonctions en C sont naturellement globales; elles peuvent
donc être partagées entre plusieurs fichiers
Cependant il n’est pas nécessaire pour cela, comme c’est le
cas des variables, d’utiliser la déclaration extern.
104
Classes de stockage
Fonction statique
Comme pour les variables globales, il est possible de rendre
inaccessible une fonction à l’extérieur du fichier où elle a été
définie, en la définissant et en la déclarant avec le mot clé
static.
/* Déclaration de fonction statique */ /* Définition de fonction statique */
static int locale1(void); static int locale2(int i, float j)
{return i*i+j;
}
 Variables locales
On appelle variable locale une variable déclarée à l'intérieur
d'une fonction ou d'un bloc d'instructions du programme.
La portée d’une variable locale se limite à l’intérieur de la
fonction où elle est déclarée.
La durée de vie des variables locales dépend de leur
emplacement en mémoire
105
Classes de stockage
Variables locales critiques
Les variables critiques sont des variables locales allouées
dynamiquement dans un registre du processeur à l'exécution.
Une variable critique est déclarée à l’aide du mot-clé register.
Variables locales statiques (rémanentes)
 Les variables locales statiques sont allouées à la compilation
dans un segment de données.
Ce sont de variables permanentes.
Au cours des appels successifs de la fonction où elles sont
déclarées elles conservent leurs anciennes valeurs.
Elle est également initialisée à zéro à la compilation.
106
Classes de stockage
Variables locales statiques (rémanentes)
Les variables locales statiques sont déclarées avec le mot-clé
static.
Exemple :
int n = 10;
void fonction(){ static int n;
n++;
printf("appel numero %d ",n);
return;
}
int main(void) Ce programme affiche :
{ int i; appel numero 1 appel numero 2 appel numero 3 appel numero 4
for (i = 0; i < 5; i++)
fonction(); appel numero 5
return 0 ;
}
107
Classes de stockage
 Règles de portée des variables
 Les règles de portée de variable sont:
Les variables globales sont accessibles dans tout le
programme, y compris les fonctions.
Les variables locales ne sont accessibles que dans la
fonction qui les a déclarées
Les paramètres formels d’une fonction ne sont accessibles
que dans la fonction; ce sont donc des variables locales.
Lorsque le nom d’une variable locale est identique à une
variable globale, la variable globale est localement masquée ;
dans cette fonction, la variable globale devient inaccessible.
108
Classes de stockage
 Règles de portée des variables
Une fonction peut donc travailler :
sur des données du programme appelant (variables globales,
à éviter au maximum)
sur des données transmises par l'appelant (paramètres en
mode entrée)
sur des données lui sont propres (variables locales)
Ainsi on dispose de deux méthodes d’échange d’information
entre une fonction appelante et une fonction appelée :
Par les paramètres
Par les variables globales; mais cette méthode peut conduire
à des effets indésirables.
109
Classes de stockage
 Classes d’allocation d’une variable
La classe d’allocation d'une variable permet de spécifier son
accès, sa durée de vie et son emplacement en mémoire.
En C, il existe quatre classes d’allocation.
110
6 – Tableaux et chaînes de
caractères
Tableaux
Chaînes de caractères
(cf support de cours P. 27)
111
Tableaux
Introduction
Motivation
Imaginons que dans un algorithme, on ait besoin
simultanément des notes d’un étudiant dans 12 matières
afin de leur appliquer diverses manipulations (calculer leur
moyenne, rechercher leur maximum et leur minimum, etc.)
A l’état actuel de nos connaissances, la solution consisterait
à:
déclarer 12 variables représentant ces notes n1, n2, n3,
n4, n5, n6, n7, n8, n9, n10, n11, n12 car chaque note peut
participer à plusieurs calculs;
lire chacune des 12 variables ;
calculer la moyenne par la formule:
(n1+n2+n3+n4+n5+n6+n7+n8+n9+n10+n11+n12)/12
 . . .. 112
Tableaux
Introduction
 Motivation
 La solution est fastidieuse, et cela allait se compliquer
davantage si le nombre de matières était plus élevé ou
inconnu à l’avance.
 Une idée, en programmation, pour résoudre ce problème
est de rassembler toutes ces variables en une seule, au
sein de laquelle chaque variable sera repérée par un
numéro.
 Cela permettra de simplifier la déclaration de ces
variables 113
Tableaux
Introduction
 Définition
 Jusqu’ici, on a utilisé les variables pour les valeurs
individuelles de types de base;
 Les tableaux vont permettre de regrouper plusieurs
valeurs
de même type dans une seule variable.
 Un tableau est une variable formée d’un nombre fini de
variables contiguës de même type appelées
composantes ou éléments du tableau.
 Un tableau possède un nom, un type et un nombre
maximal d’éléments qui représente sa taille. La taille d’un
tableau est fixe c’est-à-dire une expression constante.
 On peut former des tableaux de réels, d’entiers, de 114
Tableaux
Tableaux à une dimension
 Généralités
Définition
Un tableau à une dimension ou vecteur ou encore liste est
un tableau dont les éléments ne sont pas des tableaux.
Le type commun des éléments d’un tableau est appelé
type du tableau.
Chaque élément d’un tableau à une dimension est repéré
par sa position, dans le tableau appelée indice.
d e ra ng
bl e au e l ’é l é m e nt
ta e p r é s ent
m du Cette cas
e r
No
1 2 3 3 4 5 6 7
temperature
25 30 34 36 33 22 27
115
Tableaux
 Généralités
Déclaration
Un tableau à une dimension est déclaré par la syntaxe:
<type_tableau> <nom_tableau> [<taille_tableau>];
Cette syntaxe déclare <nom_tableau> comme un tableau

de <taille_tableau> éléments de type <type_tableau>
Exemple: float notes [12];
Cette déclaration va réserver en mémoire une zone nommée notes constituée
de 12 emplacements contigus destinés à contenir chacun des réels.
Remarque: Pour faciliter l’évolution des programmes, il est
conseillé de définir les tailles des tableaux sous forme de
constantes explicites, à l’aide de symboles.
116
Tableaux
 Généralités
Initialisation d’un tableau
Les tableaux peuvent être initialisés tout comme les
variables de types simples. La valeur servant à
l’initialisation est décrite en mettant les valeurs du tableau
entre accolades et en les séparant par des virgules :
<type_tab> <nom_tab> [<taille_tab>] = {<val1>, ...,<valn>};
Exemple: float notes [12]={12.00, 9.5, 8};
117
Tableaux
 Généralités
Initialisation d’un tableau
Remarque:
Si le nombre de valeurs dans la liste d’initialisation est
inférieur à la taille du tableau, seuls les premiers
éléments seront initialisés ; les autres éléments seront
mis à zéro si le tableau est une variable globale (c’est à
dire déclaré hors de toute fonction) ou une variable locale
statique.
Lors de l’initialisation d’un tableau, il est possible de ne
pas spécifier le nombre d’éléments du tableau ; le
compilateur attribue alors à la taille du tableau le nombre
effectif de valeurs initiales.
118
Tableaux
 Généralités
Accès aux éléments d’un tableau
L’accès à un élément d’un tableau permet de traiter cet
élément comme n’importe quelle variable individuelle :
modifier sa valeur, l’utiliser dans un calcul, l’afficher, . . .
L’accès à un élément se fait en faisant suivre le nom du
tableau de l’indice de l’élément entre crochets [ ] :
<nom_tableau>[<indice>]
<indice> peut être :
− une valeur entière représentant la position de l’élément ;
− une variable entière contenant la position de l’élément ;
− une expression entière dont la valeur donne la position de
l’élément.
<indice> doit être compris entre 0 et la taille-1 du tableau.
119
Tableaux
 Généralités
Exemple:
float notes [NBMAX] ;
int i;
notes[0] = 10.5 ; /* affecter 10.5 au premier élément */
i=5 ;
scanf(%f,&notes[i]) ; /* lire l’élément d’indice i */
printf(%f,notes[2*i+1]) ;/*afficher la valeur de l’élément d’indice 2*i+1 */
Remarque:
Il ne faut pas confondre l’indice i d’un élément et sa
valeur notes[i].
Un tableau peut avoir des éléments dont la valeur est
indéterminée, donc avant d’utiliser un tableau il faut
l’initialiser.
120
Tableaux
 Généralités
Remarque:
Le nombre d’éléments d’un tableau ayant des valeurs
déterminées est inférieur ou égal à la taille du tableau,
autrement dit on peut déclarer un tableau de dix
éléments et n’en utiliser réellement que cinq.
Le fait que les éléments constituant un tableau soient
indicés permet de parcourir tous les éléments avec une
boucle.
121
Tableaux
 Généralités
Définition de type tableau
on définit un type tableau par :
typedef <type_tab> <alias> [<taille_tab>] ;
Exemple:
typedef float NOTE [NBMAX] ; /* NOTE : ensemble des tableaux de NMAX float */
Remplissage de tableau
Le remplissage d’un tableau consiste à renseigner les
différents éléments du tableau soit par lecture soit par
affectation.
Exemple: Ecrire un programme qui lit les n notes d’un
étudiant. On suppose qu’un étudiant ne peut avoir plus de
12 notes
122
Tableaux
 Généralités
Exemple:
#define NBMAX 12
int main(void)
{
float notes[NBMAX];
int n, i ;
do{
printf(Entrer le nombre de notes:);
scanf(%d, &n);
}while(n<1||n>NBMAX);
for( i =0; i<n; i++)
{
printf(Entrer la note %d:, i+1) ;
scanf(%f,&notes[i]);
}
return 0; 123
}
Tableaux
 Généralités
Remarque:
 Si n< NBMAX, on dit que le remplissage est partiel, sinon
qu’il est complet.
 Le remplissage d’un tableau peut être fait en désignant
directement, par leurs indices, les éléments à renseigner
et ce dans un ordre quelconque.
Affichage de tableau
L’affichage d’un tableau consiste à parcourir les éléments
du tableau ayant des valeurs déterminées et à afficher
leurs contenus.
Exemple: Ecrire un programme qui édite les notes d’un
étudiant précédemment saisies.
124
Tableaux
 Généralités
Affichage de tableau
Exemple:
#define NBMAX 12
int main(void)
{ int n, i ; float notes[NBMAX];
do{
printf(Entrer le nombre de notes:);
for( i =0; i<n; i++)
{
printf(Entrer la note %d:, i+1) ;
}
/*Affichage du tableau notes */
for(i=0; i <n; i++)
printf(%.2f , notes[i]);
return 0;
} 125
Tableaux
 Insertion d’une valeur à une position donnée
Il s’agit d’insérer un élément à une position donnée dans un
tableau.
Principe
 Vérifier que le tableau n’est pas plein (nombre éléments< taille);
 Décaler vers la droite tous les éléments du tableau, s’ils
existent, situés à droite de la position d’insertion (y compris
l’élément qui se trouve à la position d’insertion) en
commençant par l’élément le plus droite ;
 Insérer la valeur à la position dégagée ;
 Incrémenter éventuellement le nombre effectif d’éléments du
tableau. 126
Exemple: Ecrire un programme qui ajoute à une position donnée une note aux
Tableaux
 Insertion d’une valeur à une position donnée
#define NBMAX 12
int main(void)
{ float notes[NBMAX], no;
int n, i, pos ;
do{printf(Entrer le nombre de notes:); /*Affichage du tableau notes */
for( i =0; i<n; i++)
{ printf(Entrer la note %d:, i+1) ;
}
if(n< NBMAX ) /* s’il y a de la place dans le tableau */
{ do{printf(Entrer la position d’insertion: ) ; /* Lecture de la position d’insertion */
scanf(%d, &pos) ;
}while(pos<0 && pos> n);
printf(Entrer la note à insérer :) ;/* Lecture de la note à insérer */
scanf(%f,&no);
for( i= n-1; >=pos; i--) (* Décalage vers la droite des éléments du tableau */
notes[i+1]=notes[i];
notes[pos]=no ; /* Insertion de la note no dans le tableau à la position pos */
n++; /* incrémenter le nombre effectif de notes */
}
else printf(Tableau plein\n) ;
return 0;} 127
Tableaux
 Recherche d’éléments
Recherche complète
Principe
Parcourir tous les éléments du tableau en les soumettant au
critère de recherche.
Exemple: Ecrire en C un programme qui détermine le nombre d’apparitions
d’une note dans les notes déjà saisies d’un étudiant.
128
Tableaux
#define NBMAX 12 /* taille du tableau qui doit être fixe */
int main(void)
Recherche complète
{ float notes [nbmax] ;/* tableau des notes */
int n, /* nombre effectif de notes de l’étudiant */
Exemple: i ;/* compteur de notes */
float no ; /* note à rechercher */
int nbOcc; /* nombre d’occurrences de no */
do{ printf(Entrer le nombre de notes : ) ;
scanf(%d, &n) ;
}while(n<0 || n>NBMAX) ;
for( i = 0 ; i<n ; i++)
{ printf(Entrer la note %d : , i) ;
scanf(%f, &notes[i]) ;
}
printf( Entrer la note à rechercher: ) ;
scanf(%f, &no) ;
nbOcc=0 ; /* initialiser nbOcc à 0 */
/* parcours des éléments du tableau */
for (i=0 ; i < n ; i++)
if(notes[i] == no)
nbOcc++;
printf (L’etudiant a obtenu %d fois la note %.2f\n, nbOcc, no) ;
return 0 ;
129
Tableaux
Recherche partielle
Principe
Parcourir les éléments du tableau et s’arrêter dès qu’on a
trouvé l’élément ou si on a terminé le tableau.
Exemple: Ecrire en C un programme qui cherche si un étudiant a déjà
obtenue une note et affiche le rang de la première matière où il a eu cette note.
130
Tableaux
#define NBMAX 12 /* taille du tableau qui doit être fixe */
int main(void)
{ Tableaux
float notes [nbmax] à une dimension
;/* tableau des notes */
 intRecherche d’éléments
n, /* nombre effectif de notes de l’étudiant */
i ;/* compteur de notes */
Recherche
float no ; /* note partielle
à rechercher */
Exemple:
/* Remplissage du tableau */
for( i = 0 ; i<n ; i++)
}
printf(Entrer la note à rechercher: ) ;
i=0 ;
while (i< n && notes[i]!=no))
i++;
if(i<n)
printf (L’etudiant a obtenu la note %.2f pour la premiere fois dans la matiere
n° %d\n, no, i) ;
else
printf (L’etudiant n’a pas encore obtenu la note %.2f\n, no, i) ;
return 0 ;
}
131
Tableaux
Recherche du minimum, du maximum
Principe
Supposer que le premier élément contient le minimum (ou
maximum) ;
Parcourir les autres éléments du tableau et comparer
chaque élément avec le minimum supposé : si l’élément
courant est inférieur au minimum supposé, il devient le
minimum.
On peut rechercher le minimum soit par sa valeur soit par sa
position.
Exemple: Ecrire en C un programme qui recherche la plus faible des notes
déjà saisies d’un étudiant
132
Tableaux
/* Recherche du minimum par sa valeur */
#define NBMAX 12
int Tableaux
main(void) à une dimension
{ float notes [nbmax] ;/* tableau des notes */
Recherche d’éléments
Recherche
i ;/* compteur dedu minimum,
notes */ du maximum
float min ; /* le
Exemple: minimum
Ecrire en Cdesun notes */
programme qui recherche la plus faible des notes déjà
saisies d’un étudiant
/* Lecture du nombre réel de notes */
for( i = 0 ; i<n ; i++)
}
/* Recherche du minimum par sa valeur */
min = notes[0]; /* initialiser le minimum au premier élément du tableau */
/* parcours des éléments restants du tableau à la recherche du minimum */
for (i=1 ; i < n ; i++)
if(notes[i] < min)
min = notes[i];
printf (La note faible de l’etudiant est : %.2f\n, min) ;
return 0 ;
}
133
Tableaux
/* Recherche du minimum par sa position */
#define NBMAX 12
int main(void)
intRecherche d’éléments
n, i ;/* compteur de notes */
float imin ; /* le rang du minimum des notes */
Recherche du minimum, du maximum
Exemple:
/* Lecture du nombre réelCde
Ecrire en unnotes */
programme qui recherche la plus faible des notes déjà
do{ printf(Entrer
saisies d’un étudiantle nombre de notes : ) ;
for( i = 0 ; i<n ; i++)
}
/* Recherche du minimum par sa position */
/* initialiser le minimum au premier élément du tableau */
imin = 0;
/* parcours des éléments restants du tableau à la recherche du minimum */
for (i=1 ; i < n ; i++)
if(notes[i] < notes[imin])
imin = i;
printf (La note faible de l’etudiant est : %.2f\n, notes[imin]) ;
return 0 ;
}
134
Tableaux
 Suppression d’éléments
Suppression d’un élément connu par sa position
Principe
Décaler vers la gauche tous les éléments, s’ils existent, situés à
droite de l’élément à supprimer ;
Décrémenter éventuellement le nombre effectif d’éléments du
tableau.
Exemple: Ecrire en C un programme qui supprime la note se trouvant à une
position donnée des notes déjà saisies d’un étudiant
135
#define NBMAX 12
int main(void) Tableaux
Tableaux
int n, /* nombreàeffectif
unededimension
notes de l’étudiant */
i,pos;
/* compteur de notes */
Suppression d’éléments
/* position de la note à supprimer */
Suppression d’un élément connu par sa position
/* Lecture du nombre réel de notes */
Principescanf(%d, &n) ;
Décaler
}while(n<0vers la gauche
|| n>NBMAX) ; tous les éléments, s’ils existent, situés à
droite
for( i =de
0 ; l’élément
i<n ; i++) à supprimer ;
Décrémenter éventuellement
scanf(%f, &notes[i]) ; le nombre effectif d’éléments du
}
tableau.
/*Exemple: Ecrire en
Lecture de la position de Cla un programme
note à supprimerqui*/ supprime la note se trouvant à une
position donnée
do{ printf( des
Entrer notes déjà
la position de lasaisies d’un étudiant
note à supprimer: ) ;
scanf(%d, &pos) ;
}while(pos<0 || pos>n-1) ;
/* Décalage vers la gauche des éléments du tableau */
for (i=pos+1 ; i < n ; i++) /*Ou for (i=pos ; i < n-1 ; i++)
notes[i-1] = notes[i]; notes[i] = notes[i+1];*/
n--;
return 0 ;
}
136
Tableaux
 Suppression d’éléments
Suppression d’un élément connu par sa valeur
Principe
Le principe consiste à se ramener au cas précédent :
Rechercher la position de l’élément à supprimer à l’aide
de sa valeur ;
Si l’élément est retrouvé, décaler vers la gauche tous les
éléments, s’ils existent, situés à droite de l’élément à
supprimer ;
Décrémenter éventuellement le nombre effectif
d’éléments du tableau.
137
#define NBMAX 12
int main(void)
Tableaux
i, /* compteur de notes */
pos; Suppression d’éléments
/* position de la note à supprimer */
float no; /* note à supprimer */
Suppression
do{ printf(Entrerd’un élément
le nombre de notesconnu
: ) ; par sa position
Principe
for( i = 0 ; i<n ; i++)
Décaler vers la
{ printf(Entrer gauche
la note %d : ,tous
i) ; les éléments, s’ils existent, situés à
droite
} de l’élément à supprimer ;
printf(Entrer la note
Décrémenter à supprimer: ) ;
éventuellement le nombre effectif d’éléments du
tableau.de la position de l’élément dans le tableau, s’il est dans le tableau*/
/* recherche
pos =0 ;
while(pos < n-1 && notes[pos] !=no)
pos++;
if(notes[pos]==no) / * alors l’élément est trouvé au rang pos */
{ /* Décalage vers la gauche des éléments du tableau */
for (i=pos+1 ; i < n ; i++)
notes[i-1] = notes[i];
n--;
} else
printf(%.2f n’est pas dans le tableau\n, no) ;
return 0 ;
138
}
Algorithmes de tri
Les programmes de tri de tableaux sont couramment
utilisés dans la gestion des données.
Un tri est en informatique une opération consistant à
réorganiser une collection d'objets selon un ordre
déterminé;
Les objets à trier devront donc faire partie d'un ensemble
muni d'une relation d'ordre total.
Si les objets sont réorganisés par ordre croissant (c'est-à-
dire l’élément d’indice i est inférieur ou égal à l’élément
d’indice i+1, pour tout i) on parle de tri croissant ;
Si les objets sont réorganisés par ordre décroissant (c'est-
à-dire l’élément d’indice i est supérieur ou égal à l’élément
d’indice i+1, pour tout i) on parle de tri décroissant.
On admettra qu’un tableau vide ou à un élément est trié.
Dans la suite, on traitera des tris croissants
139
Algorithmes de tri
 Tri par sélection
Tri par sélection du minimum
Principe
Chercher l’indice du plus petit élément du tableau T[1..n] et
permuter l’élément correspondant avec l’élément d’indice 1;
Chercher l’indice du plus petit élément du tableau T[2..n] et
permuter l’élément correspondant avec l’élément d’indice 2 ;
……..
Chercher l’indice du plus petit élément du tableau T[n-1..n] et
permuter l’élément correspondant avec l’élément d’indice n-1;
En résumé, on parcourt le tableau T (i variant de 1 à n-1) et à
chaque itération i
- on détermine l'indice posmin du plus petit élément de T sur
l'intervalle [i..n]
- on échange T[i ] et T[posmin]
140
Algorithmes de tri
Principe
141
Algorithmes de tri
Exemple: Etant donné un tableau de n éléments, écrire en C un programme qui le trie
par sélection du minimum.
142
#define NBMAX 50 /* on pourra remplacer 50 par n’immporte quel entier */
int main(void)
{ float T [nbmax]; /* on pourra remplacer float par tout autre type */
int n, /* nombre effectif d’élément du tableau*/
Algorithmes de tri
i, /* désigne les différentes positions (0,..., n-2) du tableau */
 j, Tri par sélection
/* parcourt T[i+1], …, T[n-1] pour trouver le plus petit */
posmin; /* indice du minimum de T[i], T[i+1], …, T[n-1] */
Tri floatpartmp;sélection du minimum
/* servant à permuter T[i] et T[posmin] */
Exemple:
do{ printf(EntrerEtantledonné
nombre tableau de :n)éléments,
un d’elements ; écrire en C un programme qui le trie
scanf(%d,
par sélection &n) ;
du minimum.
for( i = 0 ; i<n ; i++)
scanf(%f, &T[i]) ;
}
/* Tri par sélection du minimum */
for (i=0 ; i < n-1 ; i++) /* pour chaque position i=0, …, n-2 */
{ /* Rechercher l’indice du minimum de T[i], T[i+1], …, T[n-1] */
posmin = i ;
for(j=i+1 ; j<n ; j++)
if(T[j] < T[posmin])
posmin = j;
if(i!=posmin)
{ tmp = T[i];
T[i] = T[posmin];
T[posmin] = tmp;
}
}
return 0 ;} 143
Tableaux une dimension
Algorithmes de tri
Tri par sélection du maximum
Principe
Chercher l’indice du plus grand élément du tableau T[1..n] et
permuter l’élément correspondant avec l’élément d’indice n;
Chercher l’indice du plus grand élément du tableau T[1..n-1] et
permuter l’élément correspondant avec l’élément d’indice n-1 ;
……..
Chercher l’indice du plus grand élément du tableau T[1..2]
et permuter l’élément correspondant avec l’élément d’indice 2;
En résumé, on parcourt le tableau T (i variant de n à 2) et à
chaque itération i
-on détermine l'indice posmax du plus grand élément de T sur
l'intervalle [1..i]
-on échange T[i ] et T[posmax]
144
#define NBMAX50 /* on pourra remplacer 50 par n’immporte quel entier */
int main(void)
Algorithmes
int n, /* nombre effectifde tri
d’élément du tableau*/
i, /* désigne les différentes positions (n-1,..., 1) du tableau */
 j, /* Tri parT[i-1],
parcourt sélection…, T[0] pour trouver le plus petit */
posmax;
Tri par /* indice du maximum de T[i], T[i+1], …, T[n-1] */
sélection du maximum
float tmp; /* servant à permuter T[i] et T[posmax] */
Principe
do{ printf(Entrer le nombre d’elements : ) ;
Chercher
}while(n<0 || l’indice
n>NBMAX)du ; plus grand élément du tableau
Exemple: T[1..n] et
Etant donné un tableau
permuter l’élément correspondant avec l’élément
for( i = 0 ; i<n ; i++) d’indice
de n éléments, écriren;en
Chercher scanf(%f, l’indice
&T[i]) ; du plus grand élément du tableau T[1..n-1]
C un programme qui le et
trie par sélection du
} maximum. d’indice n-1 ;
/* Tri par sélection du maximum */
…….. for (i=n-1 ; i >0 ; i--) /* pour chaque position i= n-1, …, 1*/
Chercher{ /* Rechercher l’indicedu
l’indice du maximum
plus de T[i],élément
grand T[i-1], …, T[0]
du */tableau T[1..2]
posmax = i ;
et permuter
for(j=i-1 ; j>=0 l’élément
; j--) correspondant avec l’élément d’indice 2;
if(T[j] > T[posmax])
En résumé, on parcourt
posmax = j; le tableau T (i variant de n à 2) et à
chaque itération i
if(i!=posmax)
{ tmp = T[i];
-on détermine T[i] = T[posmax]; l'indice posmax du plus grand élément de T sur
l'intervalle
T[posmax][1..i] = tmp;
}
-on} échange T[i ] et T[posmax]
return 0 ;} 145
Algorithmes de tri
 Tri par insertion
Principe
Insérer à sa position l’élément d’indice 2 dans la tranche triée
T[1] du tableau ;
Insérer à sa position l’élément d’indice 3 dans la tranche triée
T[1], T[2] ;
Et ainsi jusqu’à l’étape n où il faut insérer à sa position l’élément
T[n] dans la tranche triée T[1], T[2], …, T[n-1] ;
En résumé, on parcourt le tableau T (i variant de 2 à n) et à

chaque itération i
-on détermine la position j de T[i] dans l'intervalle [1..i]
-on insère T[i] à la jeme place.
146
Algorithmes de tri
Principe
147
Algorithmes de tri
Principe
148
#define NBMAX50 /* on pourra remplacer 50 par n’immporte quel entier */
int main(void)
int n, /* nombre effectif d’élément du tableau*/
Algorithmes de tri
i, /* désigne les différentes positions (1,..., n-1) du tableau */
j; /*Tri par T[i],
parcourt sélection
…, T[0] pour trouver la position d’insertion de T[i] */
float tmp; /* servant à retenir T[i] */
/*Tri pardu
Lecture sélection
nombre réeldu maximum
de notes */
Principe
do{ printf(Entrer le nombre d’elements : ) ;
Chercher
}while(n<1 || l’indice
n>NBMAX)du ; plus grand élément du tableau Exemple: T[1..n] et
Etant donné un tableau
/* Remplissage du tableau */ d’indice
de n éléments, écriren;en
for( i = 0 ; i<n ; i++)
Chercher
{ printf(Entrerl’indice
la notedu %dplus
: , i) ;grand élément du tableau T[1..n-1]
C un programme qui le et
scanf(%f, &T[i]) ; trie par insertion
permuter
}
l’élément correspondant avec l’élément d’indice n-1 ;
/* ……..
Tri par insertion */
for (i=1 ; i <n ; i++) /* pour chaque élément i= 1, …, n-1*/
Chercher l’indice du plus grand élément du tableau T[1..2]
{ tmp = T[i]; /* prendre T[i] */
et permuter
/* rechercher la l’élément correspondant
position d’insertion avec
de temp=T[i] dans l’élément
la partie triée */ d’indice 2;
j=i-1 ;
En résumé, while(j>=0on && tmpparcourt
< T[j]) le tableau T (i variant de n à 2) et à
chaque itération
{T[j+1] = T[j] ; i
j--;
-on détermine} l'indice posmax du plus grand élément de T sur
T[j+1] = tmp[1..i]
l'intervalle ; /* Insérer T[i] à la position j+1 */
}
-on returnéchange
0 ;} T[i ] et T[posmax]
149
Tableaux
 Passage de tableau en paramètre
 Les tableaux peuvent être des paramètres de fonctions.
Paramètre tableau de taille fixe
Lorsqu’ une fonction doit s’appliquer des tableaux de même
taille, la taille apparaît dans le type du paramètre formel
correspondant.
 Exemple:
150
Tableaux
Exemple:.
# include <stdio.h>
# define NB 10
int main(void)
{ int nbEt; /* Nombre d’étudiants*/
int i ;
float note[NB] ; /* tableau devant contenir les notes d’un étudiant */
void lire_note(float not[NB]) ; /* déclaration de lire_note qui permet d’entrer les notes*/
float cal_moy(float not[NB]) ; /* déclaration de cal_moy qui calcule la moyenne des notes*/
printf( Entrer le nombre d’etudiants : ) ;
scantf(%f, &nbEt) ;
for ( i = 0; i < nbEt; i++)
{ printf( Entrer les notes de l’etudiant n° %d\n,i+1) ;
lire_note(note); /* appel de lire_note sur le tableau note*/
printf(\n’) ;
printf(la moyenne de l’etudiant n° %d est %.2f, i+1 , cal_moy(note));
printf(\n\n\n) ;
}
return 0 ; 151
Tableaux
Exemple:.
void lire_note(float not[NB]) /* définition de lire_note */
{ int i;
printf(‘’ 1ere note: ‘’);

scanft(‘’%f’’,&not[0]);
for (i = 1; i < NB; i++)
{ printf(%ieme note: , i+1);
scanft(%f,&not[i]);
}
}
float cal_moy(float not[NB]) /* définition de cal_moy */

{ float moy, som = 0;
for (i = 0; i < NB; i++)
som += not[i];
moy = som/NB ;
return moy;
} 152
Tableaux
Paramètre tableau de taille variable
Lorsqu’ une fonction doit s’appliquer des tableaux de tailles
différentes, la taille est omise dans le type du paramètre formel
correspondant.
Exemple:.
void lire_note(float tab[]) void lire_note( float *tab)
{ ou {
…………….. ……………..
} }
Remarque
Dans la pratique, afin d’éviter d’utiliser des variables globales,
le nombre d’éléments sera fournie comme paramètre
supplémentaire de la fonction
153
Tableaux
Remarque
# include <stdio.h>
# define NB1 10
#define NB2 15
int main(void)
{ int i ;
float note1[NB1] ;
float note2[NB2] ;
void lire_note(float tab[], int n) ; /* déclaration de lire_note */
lire_note(note1, NB1) ;
lire_note(note2, NB2) ;
return 0 ;
}
void lire_note(float tab[], int n) /* définition de lire_note */
{ int i;
printf(‘’ 1ere note: ‘’);
scanft(‘’%f’’,&not[0]);
for (i = 1; i < n; i++)
{ printf(‘’ %ieme note: ‘’, i+1);
scanft(‘’%f’’,&not[i]);
}
} 154
Tableaux
Mode de transmission des paramètres tableaux
Considérons l’exemple suivant :
# include <stdio.h>
/* échange les éléments d’indices donnés d’un tableau*/
void echange_tableau(double t[], int m, int n)
{double temp = t[m] ;
t[m] = t[n] ;
t[n] = temp;
}
int main (void)
{double tab[] = {11.5,2,13,24,15.03,6};
echange_tableau(t, 2, 4);
/* affichage des éléments du tableau après l’appel*/
for (i = 0 ; i < 5 ;i++)
printf(‘’ tab[%d] = %.2f’’, i, tab[i]);
return 0;
}
A l’exécution, on a:
tab[0] = 11.50 tab[1] = 2.00 tab[2] = 15.03 tab[3] = 24.00 tab[4] = 13.00 tab[5] = 6.00
155
Tableaux
Mode de transmission des paramètres tableaux
On constate que le tableau tab a modifié après l’appel de
la fonction echange_tableau.
En fait, lorsqu’un tableau est passé comme paramètre
effectif à une fonction, il est affecté par les modifications de
la fonction.
 Ce comportement, qui semble contraire au mode de
passage par valeur du langage, s’explique par le lien entre
les tableaux et les pointeurs comme on le verra dans le
chapitre sur les pointeurs.
156
Tableaux
Tableaux à deux dimensions
Déclaration
< type_tab> <nom_tab> [<taille1>][<taille2>];
Cette syntaxe déclare <nom_tab> comme un tableau de
<taille1> tableaux de <taille2> éléments de type <type_tab> chacun ;
autrement dit <nom_tab> est un tableau de <taille1>*<taille2>
éléments de type < type_elt>.
L’accès à un élément d’un tableau à deux dimensions se
fait selon la syntaxe suivante :
<nom_tableau> [<indice1>][<indice2>]
Cette syntaxe désigne l’élément placé à la ligne <indice1> et à la
colonne <indice2>.
Les tableaux à deux dimensions peuvent s’initialiser
comme les tableaux unidimensionnels ; les valeurs
d’initialisation étant des tableaux.
157
Chaînes de caractères
Généralités
Définition
En C, il n’existe pas de type chaîne de caractères
En C, une chaîne de caractères est représentée par un
tableau de caractères dont le dernier élément est le
caractère nul '\0' de code 0.
Ainsi une chaîne composée de n caractères sera en fait
un tableau de n+1 éléments de type char.
Une constante chaîne de caractères est une
suite de symboles placés entre double quote ″ ″.
Exemple: ″Bonjour, le monde!″
158
Généralités
Déclaration de chaîne de caractères
Pour déclarer une chaîne de caractères, il suffit de déclarer
un tableau de caractères.
Exemple: char nom[26], prenom[36], fonction[36];
Initialisation de chaînes
Il y a deux façons d’initialiser à la déclaration une chaîne
de caractères:
en mettant entre accolades la suite des caractères de
la chaîne servant de valeur initiale ; cette suite devant
se terminer par le caractère de fin de chaîne '\0'.
à l’aide d’une constante chaîne de caractères. 159
Fonctions de traitement des chaînes de caractères
La bibliothèque C dispose de nombreuses fonctions
reparties dans plusieurs bibliothèques permettant de
manipuler les chaînes de caractères.
Fonctions de lecture et d’affichage de stdio.h
Fonction Syntaxe Action
printf printf(″%s″, ch) Affiche la chaîne ch qui être une constante ou une variable
scanf scanf(″%s″, ch) Lit la chaîne ch
permet de lire une ligne à partir du clavier, une ligne consistant en
une suite de caractères terminée par le caractère de retour à la ligne
gets gets(ch)
‘\n’, ce caractère est remplacé par le caractère terminal nul ‘\0’ en
mémoire.
affiche une chaîne de caractères à l’écran, le caractère terminal nul ‘\
puts puts(ch)
0’ est remplacé par le caractère ‘\n’ à l’affichage
lit n-1 caractères depuis le clavier et place le tout dans ch en
fgets fgets(ch, n, stdin)
terminant par le caractère nul '\0’.
fputs fputs(ch,stdout) Affiche ch à lécran
160
Fonctions de manipulation de string.h
strcpy strcpy(ch1,ch2) copie la chaîne ch2 dans la chaîne ch1 et retourne ch1.
strncpy strncpy(ch1,ch2,n) copie n 1ers caractères de la chaîne ch2 dans la chaîne ch1
strcat strcat(ch1, ch2) copie la chaîne ch2 à la fin de la chaîne ch1 et retourne ch1.
copie n caractères de la chaîne ch2 à la fin de la chaîne ch1et
strncat strncat(ch1,ch2,n)
retourne ch1.
compare ch1 et ch2 pour l'ordre lexicographique ; retourne une
strcmp strcmp(ch1,ch2) valeur négative si ch1 est inférieure à ch2, une valeur positive si
ch1 est supérieure à ch2, 0 si elles sont identiques.
strncmp strncmp(ch1,ch2,n) compare les n premiers caractères de ch1 et ch2.
stricmp stricmp(ch1,ch2) Agit respectivement comme strcmp et strncmp mais sans tenir
strnicmp strnicmp(ch1,ch2,n) compte de la différence entre majuscules et minuscules.
retourne un pointeur sur la 1ière occurrence de c dans ch, et NULL
strchr strchr(ch,c)
si c n'y figure pas.
retourne un pointeur sur la dernière occurrence de c dans ch, et
strrchr strrchr(ch,c)
NULL si c n'y figure pas.
retourne un pointeur sur la première occurrence de ch2 dans ch1,
strstr strstr(ch1,ch2)
et NULL si ch2 n'y figure pas.
retourne un pointeur sur la dernière occurrence de ch2 dans ch1,
strrstr strrstr(ch1,ch2)
et NULL si ch2 n'y figure pas.
strlen strlen (ch) retourne la longueur de la chaîne ch.
161
Fonctions de classification et conversion de ctype.h
islower islower(c)
Teste si le caractère c est une lettre minuscule
isupper isupper(c)
Teste si le caractère c est une lettre majuscule
isalpha isalpha(c)
Teste si le caractère c est une lettre (minuscule ou majuscule).
isalnum isalnum(c)
Teste si le caractère c est une lettre ou un chiffre.
isdigit isdigit(c)
Teste si le caractère c est un chiffre en base 10.
isxdigit isxdigit(c)
Teste si le caractère c est un chiffre en base 16.
isascii isascii(c)
Teste si le caractère c est un caractère ASCII standard (code:0 -127)
isspace isspace(c)
Teste si le caractère c est un caractère d’espacement (code: 9-13 ou 32)
isgraph isgraph(c)
Teste si le caractère c est un caractère imprimable (autre qu’un espace)
isprint isprint (c)
Teste si le caractère c est un caractère imprimable (espace compris)
iscntrl iscntrl(c)
Teste si le caractère c est un caractère de contrôle (code : 0-31 ou 127)
ispunct ispunct(c)
Teste si le caractère c est un caractère de ponctuation
Convertit le caractère c en majuscule si possible et retourne le résultat
toupper toupper(c)
de la conversion.
Convertit le caractère c en minuscule si possible et retourne le résultat
tolower tolower(c)
de la conversion.
162
Fonctions de conversion de chaînes de stdlib.h
convertit la chaîne ch en un entier signé long selon la base b
strtol reconnaît, outre les chiffres 0 à 9, les caractères + et –. La
conversion débute en tête de ch et se poursuit jusqu’à la
strtol strtol(ch, NULL, b)
rencontre d’un caractère ne faisant pas partie de l’ensemble des
caractères reconnus. Si la fonction ne reconnaît aucun de ces
caractères, elle renvoie 0.
strtoul strtoul(ch, NULL, b) convertit ch en un entier non signé long selon la base b
Convertit ch en un réel double.
strtod reconnaît, outre les chiffres 0 à 9, les caractères + et –,
les caractères E et e (exposant) et admet des blancs en tête.
strtod strtod(ch, NULL) La conversion débute au début de ch et se poursuit jusqu’à la
rencontre d’un caractère ne faisant pas partie de l’ensemble des
caractère reconnus. Si la fonction ne reconnaît aucun de ces
caractères, elle renvoie 0.
163
Fonctions de conversion de chaînes de stdlib.h
atoi atoi(ch) retourne la valeur numérique représentée par ch comme int
atol atol(ch) retourne la valeur numérique représentée par ch comme long
atof atof(ch) retourne la valeur numérique représentée par ch comme double
164

Présentation Cours C

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Présentation Cours C

Transféré par

Droits d'auteur :

Formats disponibles

Cours: Introduction Langage

 Le cours vise à initier les étudiants à la programmation.

 A l’issue du cours, les étudiants devraient être capables

 Apprendre à traduire correctement en C les

 Cours d’introduction à l’algorithmique, 1ère année

 1 devoir sur table

 Des évaluations à chaud

Etapes de réalisation de programmes

Problème à résoudre Faire faire Ordinateur

(Comment traduire?) Traduction

Analyse (Comment faire?)

qui contiennent effectivement des instructions qui

 Un fichier source comporte plusieurs parties:

int cube(int x) { /* définition de la fonction cube */

auto double int struct

char Caractère 1 -128 à 127

short int ou short Entier court 2 -32768 à 32767

unsigned short int Entier court non signé 2 0 à 65535

long int ou long Entier long 4 -2147483648 à 2147483 47

float flottant (réel) 4 3.4*10-38 à 3.4*1038 6chiffres (10-6)

Réels double flottant double 8 1.7*10-308 à 1.7*10308 15chiffres (10-15)

long double flottant double long 10 3.4*10-4932 à 3.4*104932 17chiffres (10-17)

 Un caractère peut être considéré comme un entier, la

 Exemple: int n; float prixttc, tva, montant;

 Exemple: int n=10; float prixttc, tva=0.02,montant;

Exemple 2: Affichage d’un entier en base 10, base 16 et base 8

Exemple 4: Affichage de la valeur d’une expression

Exemple 8: Affichage de réels avec précision

puts(chaîne) permet d’afficher une chaîne de caractère s.

Exemple 1:saisir un entier de 5 chiffres maximum

int i; float x;char c;

Ces deux fonctions prennent un caractère dans le tampon et le

Une expression est une suite bien ordonnée de noms de

 Les opérateurs arithmétiques s’appliquent sur des

Le résultat de la comparaison entre deux expressions

Le résultat d’un opérateur booléen est un entier non

(cf. Exo8 TPn°2)

 L’opérateur conditionnel ?: est un opérateur ternaire (trois

 L’opérateur séquentiel (ou virgule) permet d’évaluer de

Opérateur taille sizeof

(cf. Exo8 TPn°2) 66

La boucle do while:

La boucle for:

/* Fonction ne prenant pas de valeur et ne renvoyant pas de valeur */

void affiche_date(const TDate * d)

Passage par pointeur

Type du paramètre Passage par pointeur sur

Cette syntaxe déclare <nom_tableau> comme un tableau

Exemple: float notes [12]={12.00, 9.5, 8};

En résumé, on parcourt le tableau T (i variant de 2 à n) et à

printf(‘’ 1ere note: ‘’);

float cal_moy(float not[NB]) /* définition de cal_moy */

Vous aimerez peut-être aussi

float flottant (réel) 4 3.410-38 à 3.41038 6chiffres (10-6)

Réels double flottant double 8 1.710-308 à 1.710308 15chiffres (10-15)

long double flottant double long 10 3.410-4932 à 3.4104932 17chiffres (10-17)