Centre des classes préparatoires au BTS

Lycée technique - TAZA

MCW

Algorithmique et Programmation
Support de cours et TD corrigés
NOTRE OBJECTIF
Etre capable d’écrire un programme informatique qui
Soit:
Correct,

Simple,

Efficace,

Rapide

Avec le langage de programmation C

2
SOMMAIRE
 Introduction à la programmation,
 Rappel sur l’algorithmique,

 La programmation sous C,
 Introduction
 Types de base, variables, constantes
 Opérateurs et expressions
 Les entrées sorties en C
 Les structures de contrôle
 Les tableaux
 Les pointeurs
 Les chaines de caractères
3
 Les structures
INTRODUCTION À LA PROGRAMMATION
DÉFINITIONS
 Ordinateur:
 Puissant calculateur à composant électronique
 Comprend entre autres :
 Un microprocesseur avec une UC (Unité de Contrôle), une
UAL (Unité Arithmétique et Logique), une horloge, une
mémoire cache rapide
 La mémoire vive (RAM), contenant les instructions et les

données. La RAM est formée de cellules binaires organisées

en mot de 8 bits (octet)
 Les périphériques d’entrées/sorties, mémoires mortes
(disque dur, CD-ROM. . . ), réseau. . .

6
DÉFINITIONS
 Programmes exécutés par l’ordinateur
 Le système d’exploitation (OS) : ensemble des
programmes qui gèrent les ressources
matérielles et logicielles;
 Propose une aide au dialogue entre l’utilisateur et
l’ordinateur : l’interface textuelle (interprète de commande)
ou graphique (gestionnaire de fenêtres).
 Multitâche

 Multiutilisateur

 Programmes applicatifs dédiés à des

taches particulières
 Sont sous formes d’une série de commandes contenues dans
un programme dont le code source est écrit dans un langage
7
« compris » par l’ordinateur.
DÉFINITIONS
 Différents niveaux des langages
1. Langage machine: utilisé par le processeur. Il
s'agit des données telles qu'elles arrivent au
processeur, constituées d'une suite de 0 et de 1
(données binaire).
2. Langage de bas niveau qui représente le langage
machine sous une forme lisible par un humain. Il
est traduit en langage machine par un
assembleur
3. langage de haut niveau: est un langage de
programmation orienté autour d’un problème à
résoudre, utilise des mots usuels des langues
naturelles (très souvent de l'anglais) et des
symboles mathématiques familiers 8
DÉFINITIONS
 Langage et programmation informatique:
 Programmation: Activités permettant
l’écriture des programmes informatiques
→ Langage de programmation (C, Java, C#,
J#, VB, VB.NET, Pascal, Cobol, Fortran …)
 Informatique: contraction d'information et
automatique. La science du traitement de
l'information
En anglais: Computer science (science de
calcul)

9
DÉFINITIONS
 Production de programmes
1. Compilation: transformer un code
source écrit dans un langage de
programmation (langage de haut niveau ) en
un autre langage informatique (langage
d'assemblage ou langage machine) pour qu'il
puisse être exploité par la machine.
 Effectuée en effectue 5 étapes :
 analyse lexicale,

 prétraitement (préprocesseur),

 analyse syntaxique (parsing),

 analyse sémantique,

 génération de code optimisé (code objet)

 + « édition de liens » pour générer le langage machine

10
DÉFINITIONS
 Production de programmes
2. Interprétation: chaque instruction est
traduite (compilée) à fur et à mesure de son
appel (exécution)
 Un interpréteur se distingue d’un compilateur par le fait
que, pour exécuter un programme, les opérations d’analyse
et de traductions sont réalisées à chaque exécution du
programme (par un interpréteur) plutôt qu’une fois pour
toutes (par un compilateur).

3. Ces deux techniques de production de

programmes peuvent être combinées pour un
11
même langage
DÉFINITIONS
 Les catégories de langages
1. Langages interprétés:
Un programme écrit dans un langage interprété a besoin
d'un programme auxiliaire (l'interpréteur) pour
traduire au fur et à mesure les instructions du
programme.
2. Langages compilés:
Un programme écrit dans un langage compilé va être
traduit une fois pour toutes par un programme annexe,
compilateur, afin de générer un nouveau fichier qui sera
autonome appelé exécutable.
3. Langages intermédiaires:
Le programme écrit avec ces langages peut dans certaines
conditions subir une phase de compilation intermédiaire
vers un fichier écrit dans un langage qui n'est pas
intelligible (donc différent du fichier source) et non
exécutable (nécessité d'un interpréteur) 12
DÉFINITIONS
 Types de programmations
1. Séquentielle: où le déroulement des
instructions du programme est toujours le
même
2. Procédurale: qui se base sur le concept
d’appel de procédure (fonction)
 N’import quelle procédure peut être appelée à
n’importe quelle étape d’exécution
3. Objet: repose sur l’interaction de briques
logicielles appelées objets
 Objet représente un concept, une idée ou une entité
13
CHRONOLOGIE DES LANGAGES DE
PROGRAMMATION: SRC: WIKIPEDIA
 Avant 1950: les langages machines
 Les années 1950 à 1960:
 FORTRAN: le traducteur de formules
(FORmula TRANslator), inventé par John Backus et al
 LISP: spécialisé dans le traitement des listes (LISt
Processor), inventé par John McCarthy et al
 COBOL: spécialisé dans la programmation d'application de
gestion (COmmon Business Oriented Language), créé par
le Short Range Committe
 Les années1967 à 1978:
 Simula 67: implémente la POO et la simulation par
événement
 C: langages de programmation système
 Smalltalk: Un des premiers langages de programmation à
disposer d'un environnement de développement
intégré complètement graphique
14
 Pascal, Prolog, ML, Forth, SQL, ...
CHRONOLOGIE DES LANGAGES DE
PROGRAMMATION: SRC: WIKIPEDIA

 Les années 1980

 C++: C en POO
 Ada: langage de programmation système OO destiné
à être utilisés par les sous-traitants de la défense des
US
 ...

 Les années 1990 : l'ère Internet

 Python (1990), Ruby (1993), JavaScript (1995), Java
(1995), PHP(1995), C# (2000), ...

15
 RÉCAPITULATIF
 Le programme informatique:
C’est une ensemble d'instructions
exécutable par l'ordinateur. Ces
instructions sont écrites utilisant un
langage de programmation et traduites
par un compilateur.
 Étapes:

Fichiers Fichiers .exe

Compilateur Editeur de liens
Source Objets

16
LES CATÉGORIES DE LANGAGES:
EXEMPLES
 Langages interprétés:
Langage Domaine principal d'application
BASIC Programmation basique à but éducatif
MATLAB Calcul matriciel
Mathematica Calcul mathématique
PHP Développement de sites web dynamiques

 Langages compilés:
Langage Domaine principal d'application
C Programmation système
C++ Programmation système objet
Cobol Gestion
Fortran Calcul
Pascal Enseignement

 Langages intermédiaires:
Langage Domaine principal d'application
17
Java Programmation orientée internet
LISP Intelligence artificielle
LA STRUCTURE D'UN PROGRAMME
Un programme informatique est constitué
d'une suite d'instructions exécutées par la
machine.
 Les éléments d’un programme sont:
 Variables,
 Type de données,
 Instructions,
 Mots réservés,
 Les constantes,
 Les commentaires. 18
LES ÉLÉMENTS D’UN PROGRAMME
 Les variables:
 Dans la plupart des langages, on travaille
généralement sur des variables, c'est-à-dire que l'on
associe à un nom (variable) un contenu.
On peut associer à une variable «tva» la valeur 0.02.
 Le type de données:
 Le type de donnée désigne la taille de mémoire
qu’une donnée occupe ainsi que le format dans lequel
cette donnée est représentée.
1. langages non typés: on ne spécifie pas le type pour
les variables, Ex: PHP, HTML, …
2. langages typés: pour chaque variable on doit
associer un nom et un type. Ex: C, C#, Java, VB,
Vb.net, … 19
LES ÉLÉMENTS D’UN PROGRAMME
 La syntaxe :
 Chaque langage a sa propre syntaxe,
 Certains langages sont sensibles à la casse (case
sensitive): tva ≠ TVA,
 Les noms de variables admettent généralement une
longueur maximale.
 On utilise en général l’alphabet (non accentuée) et
l’alphanumérique.
 Les caractères spéciaux ne sont pas acceptés
 Les mots réservés (reserved words):
 Chaque langage à un ensemble de mots réservés que
l’on ne peut attribuer aux noms de variables.
 Les constantes:
 Données dont la valeur ne peut être modifiée. On 20
général, on les définis au début des programmes.
LES ÉLÉMENTS D’UN PROGRAMME
 Les commentaires :
 Ce sont des Lignes qui ne seront pas prises
en compte par le compilateur. Les
commentaires sont essentiellement utilisés
pour clarifier et donner des explications. On
utilise des instructions spéciales pour définir
un commentaire.
 Exemples:
en C, C++, Java on utilise // ou /* */
en VB on utilise ‘
en Matlab on utilise % 21
LES INSTRUCTIONS DANS UN PROGRAMME
L'instruction est l'élément clé de l'ordinateur car c'est
elle qui permet de spécifier au processeur l'action à
effectuer
 Dans une instruction on définit deux
éléments:
 Les opérateurs: les actions à effectuer par le processeur,
 Les opérateurs unaires,

 Les opérateurs binaires,

 Les opérateurs ternaires.

On distingue: opérateurs arithmétiques, opérateurs de

comparaison, opérateurs logiques, opérateurs de bits,
opérateurs d'affectation, opérateurs conditionnels et
opérateurs séquentiels.
 Les opérandes: les données sur lequel on va effectuer 22
l'opération.
 CHAPITRE 1:
INITIATION AU LANGAGE C
PLAN
 Historique
 Introduction
 De l’algorithmique à C
 Forme de base d’un programme en C
 Les types de données en C
 Les opérations de base
 Les fonctions d’Entrer/sortie
 Les tests et boucles,
 Les branchements inconditionnels
 Les tableaux et structures
 Les pointeurs
 Les chaines de caractères
 Les fonctions 24
GÉNÉRALITÉS SUR LA
PROGRAMMATION

Structure générale d'un

programme
Un programme informatique est constitué
d'une suite d'instructions exécutées par la
machine
 Les éléments d’un programme sont:
 Variables,
 Type de données,
 Instructions,
 Mots réservés,
 Les constantes, 25
 Les commentaires.
GÉNÉRALITÉS SUR LA PROGRAMMATION
 Les éléments d’un programme
 Les variables:
Dans la plupart des langages, on travaille généralement
sur des variables, c'est-à-dire que l'on associe à un nom
(variable) un contenu.
On peut associer à une variable «tva» la valeur 0.02.
 Le type de données:
Le type de donnée désigne la taille de mémoire qu’une
donnée occupe ainsi que le format dans lequel cette
donnée est représentée.
1. langages non typés: on ne spécifie pas le type pour les
variables, Ex: PHP, HTML, …
2. langages typés: pour chaque variable on doit associer
un nom et un type. Ex: C, C#, Java, VB, Vb.net, … 26
GÉNÉRALITÉS SUR LA PROGRAMMATION
 Les éléments d’un programme (suite)
 La syntaxe :
 Chaque langage a sa propre syntaxe,

 Certains langages sont sensibles à la casse (case

sensitive): tva ≠ TVA,
 Les noms de variables admettent généralement une
longueur maximale.
 On utilise en général l’alphabet (non accentuée) et
l’alphanumérique.
 Les caractères spéciaux ne sont pas acceptés
 Les mots réservés (reserved words):
Chaque langage à un ensemble de mots réservés que
l’on ne peut attribuer aux noms de variables.
 Les constantes:
Données dont la valeur ne peut être modifiée. On 27
général, on les définis au début des programmes.
GÉNÉRALITÉS SUR LA PROGRAMMATION
 Les éléments d’un programme (suite)
 Les commentaires :
ce sont des Lignes qui ne seront pas prises en
compte par le compilateur. Les commentaires
sont essentiellement utilisés pour clarifier et
donner des explications. On utilise des
instructions spéciales pour définir un
commentaire.
 Exemples:
en C, C++, Java on utilise // ou /* */
en VB on utilise ‘
en Matlab on utilise % 28
GÉNÉRALITÉS SUR LA PROGRAMMATION
 Les éléments d’un programme (suite)
L'instruction est l'élément clé de l'ordinateur car
c'est elle qui permet de spécifier au processeur
l'action à effectuer
 Dans une instruction on définit deux éléments:
 Les opérateurs: les actions à effectuer par le processeur,
 Les opérateurs unaires,

 Les opérateurs binaires,

 Les opérateurs ternaires.

On distingue: opérateurs arithmétiques, opérateurs de

comparaison, opérateurs logiques, opérateurs de bits,
opérateurs d'affectation, opérateurs conditionnels et
opérateurs séquentiels.
 Les opérandes: les données sur lequel on va effectuer 29
l'opération.
POURQUOI LE LANGAGE C?

 Avantages:
 Le plus utilisé

 Programmation proche du langage machine → accès aux

interfaces de l’ordinateur

 Inconvénients:
 Séquentiel

30
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,
 Plusieurs groupes mirent sur le marché des
compilateurs comportant des extensions
particulières,
 Définition d’une norme en 1988: ANSI C
31
INTRODUCTION
 Le langage C est:
 Un langage fortement typé,
 Sensible à la casse
 Un langage Compilé.

 Programmer en C:
1. Ecrire le code source en utilisant un éditeur de texte.
L’ extension des fichiers source C est *.c (HelloWord.c)
L’extension des fichiers source C++ est *.cpp
2. Compiler (traduire) le fichier source pour avoir un exécutable:
1. En code Objet ou fichier Objet (langage machine)
2. En exécutable *.exe (HelloWord.exe) utilisant un éditeur de liens 32
INTRODUCTION
 Environnements de développement (IDE)
 Sous Windows
 Code::Blocks
 Dev C++

 Visual C++

 Netbeans

 ...

 Sous Linux
 Code::Blocks
 Netbeans

 KDevelop

 Sous Mac Os
 Code::Blocks
 Xcode 33
 FORME DE BASE D’UN PROGRAMME EN C
Entête du programme
Directives de préprocesseur #include "stdio.h" // fonctions d’entrer-sortie
Déclarations globales #define varGlobal = 3

Fonction principale
Type_retourné main (arguments) void main (void)
{ {
Déclarations locales (à la fonction main) int var1=1, var2, var3; //variables locales
Affectation var2=4;
Affectation var3 = varGlobal * somme(var1, var2);
Affichage printf ("%d+%d=%d\n", var1, var2,var3);
} }

main est le nom de la fonction principale, aussi appelée point d'entrée du

programme.
Les accolades { et } entourent les instructions constituant le corps d’une fonction.
printf est une fonction d'écriture dans la sortie standard (la console par défaut).
Le caractère " délimite une chaîne de caractères 34
Le caractère \n est une séquence d'échappement
Un point-virgule ; termine l'instruction.
 DE L’ALGORITHMIQUE À C
Algorithmique C

Déclaration Variable a en Entier int a;

Variable
Affectation a←2 a=2;

printf ("texte à afficher");

Entrer Ecrire "texte à afficher"
puts("texte à afficher");
Entrer/Sorties
Sorties Lire variable scanf("%f", $a);

if (test)
{
Si (Test) Alors
// Instructions
// Instructions
}
Tests Si Sinon
Else
//Instructions
{
FinSi
// Instructions
}

35
DE L’ALGORITHMIQUE À C
Algorithmique C

while (Condition)
{
//Instructions
}
TantQue (Condition) Alors
Tant Que //Instructions ET
FinTantQue
do
Boucles {
//Instructions
} while (Condition)
for (i=1; i<=10; i++)
Pour i←1 à 10
{
Pour //Instructions
//Instructions
i Suivant
}

36
 DE L’ALGORITHMIQUE À C

Algorithmique C

Déclaration Tableau tab (10) en Entier int tab[10];

Tableau
Affectation tab (3) ← 5 tab[3]=5;

Déclaration Tableau tab (3,3) en Entier int tab[3][3];

Tableau
bidimensionnel
Affectation tab (1,1) ← 5 tab[1][1]=5;

Fonction facto(varIn en Entier) en int facto( int avrIn)

Entier [
Fonctions //Instructions //Instructions
Renvoyer varOut return varOut
FinFonction }

37
LES COMMENTAIRES
 Deux types
 Mono lignes avec //
// Ceci est un commentaire de ligne
 Sur plusieurs lignes avec /* et */
/* Et ceci est un autre commentaire
sur plusieurs lignes.
*/
/* Ceci est un commentaire sur une ligne */

38
VARIABLES
 Sont les conteneurs  servent à stocker les données
manipulées par le programme.
 Les variables sont nommées par des identificateurs
alphanumériques
 Le premier caractère doit être une lettre ou le symbole « _ ».
 Les autres caractères sont compris dans l’ensemble {a, .., z, A,
…, Z, 0, …, 9, ,_ }.
 Un identificateur doit être différent de tous les mots clés.
 C / C++ distingue entre majuscules et minuscules; on dit qu’il
est sensible à la casse

39
LES TYPES DE DONNÉES EN C
Toutes les variables sont typées en langage C :
 Types simples
 Types structurés
Types en
 Références (pointeurs) de types C

Simple Structuré Référence

Entiers Flottant Structure Tableau

versions
char short int long double float
unsigned

Le C est un langage (assez) fortement typé : on ne pourra

mettre dans une variable d’un type donné une valeur d’un
type incompatible. 40
LES TYPES SIMPLES
 Les Entiers (integer)
int a, b, c; // Entiers signés
 Occupent deux octets en mémoire
 Varient de -32 768 à 32 767.

unsigned int d ; // Entiers non signés

 Occupent deux octets en mémoire
 Varient de 0 à 65 535.

long e, f; // Entiers longs signés

 Occupent quatre octets en mémoire
 Varient de - 65 535 à 65 535.

unsigned long int d ; // Entiers longs non signés

 Occupent quatre octets en mémoire
 Varient de 0 à 131 070. 41
LES TYPES SIMPLES

 Les nombres à virgule

float b=-23.56; //Nombre à virgule signé court

 Occupent quatre octets en mémoire

double n; // float long

 Occupent huit octets en mémoire

42
LES TYPES SIMPLES
 Les caractères
char var1='A';
 On peut définir certains caractères spéciaux, par le
préfixe \ (antislash) :
 \n (nouvelle ligne), \t (tabulation),
\b (backspace), \' (apostrophe),
\\ (antislash), \" (double quote), \0 (nul),

 Les chaines de caractères

char nom [4] = {‘S' , 'M', ‘A' , '\0'} ;
43
LES TYPES SIMPLES
 Types booléens
 Non supportés dans tous les IDE
Deux états true/false ou 0/1
bool t=true;

44
LES TYPES DE DONNÉES EN C
 Conversion de type
Modifier le type d’une donnée en un autre type
1. Conversion implicite :
 effectuée automatiquement par le compilateur
float varFloat=5.56; // varFloat est une variable de type virgule flottante
int varInt = varFloat; // varInt est une variable de type entier égale à 5

2. Conversion explicite (opération de cast ):

 modification forcée du type
float varFloat=5.56; // varFloat est une variable de type virgule flottante
int varInt = (int) varFloat; // varInt est une variable de type entier égale à 5

45
DÉCLARATION DES VALABLES
 Syntaxe:
<type_de_la_variable> <nom_de_la_variable> ;
 Les déclarations se font au début d’un bloc d’instruction
après « { »
 On peut déclarer autant de variables que nécessaire
 On peut déclarer plusieurs variables de même type sur la
même ligne
<type_de_la_variable> <nom_var1>, <nom_var2>, ... <nom_varN> ;

{
int i; /* i : variable entière signée */
int j, k ; /* j et k de type entier*/
46
}
AFFECTATION DES VALABLES
 On utilise l’instruction « = »
int i, a;
i=5
a=i;
 Il est possible de déclarer et d’initialiser une variable
en même temps
char b='A', a;
 Affectation combinée
i = j = 5;
/* j=5 est une expression dont la valeur est 5, cette
valeur est stockée dans i */
i += 12; /*équivalent à i =i+12 */ 47
OPÉRATEURS DE BASE
 Arithmétiques:
 +, -, *, /, %
 Comparaison:
== (égalité), != (différent), < (strictement inférieur), >
(strictement supérieur), <= (inférieur ou égal), >=
(supérieur ou égal)
 Logique

&& (l’operateur ET), || (l’operateur OU), ! (Non

logique)

48
OPÉRATEURS DE BASE
 Incrémentation
++a (Post-incrémentation) et a++ (Pré-incrémentation) :
ajoute 1 à la valeur de la variable a

a = i ++;  a =i ; i=i+1;
a = ++ i;  i=i+1; a =i ;

 Décrémentation
--a (Post-décrémentation) et a-- (Pré-décrémentation) :
soustrait 1 à la valeur de la variable a
a = i --;  a =i ; i=i-1;
a = -- i;  i=i-1; a =i ;
49
AFFICHAGE DE DONNÉES
La fonction printf est utilisée pour afficher du texte, des
valeurs de variables ou des résultats d'expressions sur la
sortie standard (qui est l'écran).
Cette fonction est prédéfinie dans la bibliothèque stdio.h.
Syntaxe:
printf("<format>",<Expr1>,<Expr2>, ... )

 La partie format est en fait une chaîne de caractères qui

peut contenir: du texte, des séquences d'échappement , des
spécificateurs de format.
 Chaque expression peut être une variable ou une
expression dont la valeur est à représenter.
50
AFFICHAGE DE DONNÉES
Exemples:
1°/ printf("Bonjour tout le monde");
 affiche: Bonjour tout le monde
2°/ printf("Bonjour tout le \nmonde");
 affiche: Bonjour tout le
monde
3°/ int n=1234;
printf("n vaut %d", n);
 affiche: n vaut 1234

51
AFFICHAGE DE DONNÉES
On doit indiquer comment afficher les valeurs des expressions
au moyen des séquences d’échappement.

Les spécificateurs de format commencent toujours par le

symbole % et se terminent par une ou deux lettres qui
indiquent le format d'impression.

Type de la variable Syntaxe en C

C est char printf("%c", C) ;
N est int printf("%d", N) ;
L est long printf("%ld", L) ;
X est float printf("%f", X) ;
Y est double printf("%lf", Y) ; 52

Z est long double printf("%Lf", Z) ;

AFFICHAGE DE DONNÉES
Le langage C propose plusieurs couples de symboles, appelés
séquences d’échappement, permettant le contrôle de l'affichage
de texte. Les séquences d'échappement sont toujours précédées
par le symbole « \ ».

\n (nouvelle ligne),

\t (tabulation),
\b (backspace),
\' (apostrophe),
\\ (antislash),
\" (double quote),
\0 (nul), 53
AFFICHAGE DE DONNÉES
 Pour le type float on peut donner la précision
printf ("%.2f ",var1);
/* affiche la valeur de la variable var1 en format float (réel) avec 2
chiffres après la virgule*/

 C propose aussi la fonction puts (stdio.h)

puts ("chaine à afficher");

putchar('C');

54
AFFICHAGE DE DONNÉES
 Exercice:
Ecrire un programme qui affiche un message de félicitation
à l’occasion de la nouvelle année 2017 en utilisant soit puts
ou printf.
on utilise a forme suivante:
#include "stdio.h" // pour pouvoir utiliser les fonctions de sortie
void main (void)
{
// instructions
}
55
AFFICHAGE DE DONNÉES
 Exercice:
Ecrire un programme qui affiche un message de félicitation à
l’occasion de la nouvelle année 2017 en utilisant soit puts ou printf.
on utilise a forme suivante:
#include "stdio.h" // pour pouvoir utiliser les fonctions de sortie
void main (void)
{
printf ("Mes félicitation à l’occasion de la nouvelle année 2017 \n");
puts("Mes félicitation à l’occasion de la nouvelle année 2017 \n");
}
56
LECTURE DE DONNÉES
 La fonction scanf, de la biblio «stdio.h», est la
fonction duale de printf.
 Elle sert à analyser le texte tapé et le convertir en valeurs
placées dans les variables passées en paramètres, selon la
chaîne de format passée en premier paramètre.
Syntaxe:
scanf("<format>",<AdresseVariable1>,<AdrVar2>, ...)

 La partie format indique format de lecture des données

 <AdrVar> indiquent l’adresse de la variable auquelle la
donnée saisie sera attribuée
 L'adresse d'une variable est indiquée par le nom de la
variable précédé du signe &.
57
LECTURE DE DONNÉES
 Exemple:
int n1, n2;
float x;
scanf("%d", &n1);
scanf("%d %f", &n2, &x);

58
LECTURE DE DONNÉES
 Autres fonctions
 gets
char var[10];
gets(var);
printf(var);
 getchar
char c;
c=getchar();
printf("%c",c);
59
FONCTIONS D’ENTRER/SORTIE
 Exercice:
 Ecrire un programme qui demande à l’utilisateur de
saisir deux nombres et ensuite affiche leur somme

60
FONCTIONS D’ENTRER/SORTIE
#include "stdio.h"
void main()
{
// déclarer les variables
int var1, var2, som;
// demander de saisir les deux nombres
printf("Saisir les deux valeurs\n");
// lecture et affectation des variable
scanf("%d",&var1);
scanf("%d",&var2);
// faire la somme
som=var1+var2;
// afficher le résultat de la somme
printf("%d+%d=%d\n",var1, var2, som);
}
61
 CHAPITRE 2:
LES STRUCTURES DE CONTRÔLES
PLAN
 Introduction
 Les structures alternatives
 IF

 IF-ELSE

 IF-ELSE IMBRIQUÉE

 SWITCH-CASE

 Le conditionnel « ? »

 Les boucles
 FOR

 WHILE

 DO WHILE

 Les branchements inconditionnels

 BREAK, CONTINUE, GOTO, RETURN, EXIT 63
INTRODUCTION
Les structures de contrôle servent à orienter l’exécution
du programme en fonction de la valeur courante d’une
expression
Exécution conditionnelle d’un fragment de code si
une certaine condition est vérifiée
Exécution répétitive d’un fragment du code si une
certaine condition est vérifiée

Les conditions de contrôle sont des expressions logiques

booléennes

64
STRUCTURES DE CONTRÔLE
if
Syntaxe:
if(<expression>)
<bloc d’instructions>

Le bloc d’instructions est exécuté dans le cas où

l’expression est vraie (sa valeur est différente de zéro).
Le bloc d’instructions peut être:
 une seule instruction

 plusieurs instruction entre des accolades.

65
STRUCTURES DE CONTRÔLE
if
Exemples:
if( n%2 == 0) // % est le modulo
printf("Le nombre %d est pair", n);

if( b != 0) {
res=a/b;
printf("%d / %d = %d", a , b, res);
}

66
STRUCTURES DE CONTRÔLE
if - else
Syntaxe:
if(<expression>)
<bloc 1 d’instructions>
else
<bloc 2 d’instructions>

Si l’expression est vraie (différente de 0), le bloc 1

d’instructions est exécuté, sinon le bloc 2 est exécuté.

67
STRUCTURES DE CONTRÔLE
if - else
Exemples:
if( n%2 == 0)
printf("Le nombre %d est pair", n);
else
printf("Le nombre %d est impair", n);

if( a > b)
max = a;
else
max = b;
68
STRUCTURES DE CONTRÔLE
if – else
Lorsqu’on a plusieurs cas à tester, il est possible
combiner plusieurs structures if – else.
Syntaxe:
if ( <expr1> )
<bloc1>
else if (<expr2>)
<bloc2>
…
else
<blocN>
69
STRUCTURES DE CONTRÔLE
 Exercice :
 Ecrire un programme qui permet de dire que le
nombre saisi est positif ou négatif

70
STRUCTURES DE CONTRÔLE
#include "stdio.h"
void main()
{
// déclarer les variables
int var1;
scanf ("%d", &var1);
if (var1>=0)
{
printf ("Positif");
}
else
{
printf ("Négatif"); 71
}
}
STRUCTURES DE CONTRÔLE
 Exercice

Ecrire un programme qui permet de donner une

mention à une note saisie par l’utilisateur, les notes
doivent être de 0 à 20

72
#include "stdio.h"
void main()
{
float N;
printf ("Donner une note");
scanf("%f",&N);
printf ("La mention est:\t");
if(N>=16)
{
#include "stdio.h"
printf("TB");
void main()
}
{
else if (N>=14)
float N;
{
printf ("Donner une note: ");
printf("B");
scanf("%f",&N);
}
printf ("La mention est:\t");
else if (N>=12)
if (N>=16) printf("TB");
{
else if (N>=14) printf("B");
printf ("AB");
else if (N>=12) printf ("AB");
}
else if (N>=10) printf("P");
else if (N>=10)
else printf ("NV");
{
}
printf("P");
}
else
{ 73
printf ("NV");
}
}
 STRUCTURES ALTERNATIVES
 switch-case
La structure switch sert à traiter plusieurs choix en
fonction d’une expression entière (caractère ou entier).

switch (expression_de_test)
{
case expression1: //exécuté instructions1
case expression2: // exécuté instructions2
…
case expressionN: // exécuté instructionsN
default : // exécuté instructions par deafut
}

Remarque
74
 le mot clé break est utilisé pour indiquer la sortie de la
structure conditionnelle
STRUCTURES ALTERNATIVES
 switch-case
Exemple:
int jour;
…
switch(jour) {
case 1: printf("C’est un Lundi"); break;
case 2: printf("C’est un Mardi"); break;
case 3: printf("C’est un Mercredi"); break;
…
case 7: printf("C’est un Dimanche"); break;
default : printf("Ce n’est pas jour valide!!");
75
}
STRUCTURES ALTERNATIVES
 Exercice
Ecrire un programme qui vérifie si le caractère saisi par
l’utilisateur est une voyelle ou une consonne.
 Les voyelles sont a, e, i, o, u, y

 Exercice
Ecrire un programme qui simule une calculatrice de 4
opérations *, /, +, -

76
STRUCTURES ALTERNATIVES
 switch-case
Exemple2:
….
switch(c) {
case 'a': printf("C’est une voyelle"); break;
case 'e': printf("C’est une voyelle"); break;
case 'i': printf("C’est une voyelle"); break;
case 'o': printf("C’est une voyelle"); break;
case 'u': printf("C’est une voyelle"); break;
case 'y': printf("C’est une voyelle"); break;
default : printf(« C’est une consonne");
77
}
SOLUTION VOYELLE
#include <stdio.h>
void main()
{
char c;
printf("Entrer un caractère: ");
scanf ("%c",&c);
if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u')
{
printf("C'est une voyelle");
}
else{
printf("C'est une consonne"); 78
}
}
SOLUTION CALCULATRICE
#include <stdio.h>
void main()
{
char c;
float a,b;
printf("Choisir une opération");
printf("Taper + => addition, - => soustraction, * =>
multiplication et / => division\n");
printf("Exemple; 1+2\n");
scanf("%f%c%f", &a,&c,&b);
switch (c)
{
case '+': printf ("%.2f+%.2f=%.2f",a,b,a+b);break;
case '-': printf ("%.2f-%.2f=%.2f",a,b,a-b);break;
case '*': printf ("%.2fx%.2f=%.2f",a,b,a*b);break;
case '/': printf ("%.2f/%.2f=%.2f",a,b,a/b);break; 79
default: printf("Opération incorrect");
}
}
SOLUTION CALCULATRICE 2
#include <stdio.h>
void main()
{
int c;
float a,b;
printf("Choisir une opération\n");
printf("Taper 1 => addition, 2 => soustraction, 3 => multiplication et
4 => division\n");
printf("Taper l'opération: ");
scanf("%d",&c);
printf("Entrer les chiffres:\n");
scanf("%f%f", &a,&b);
switch (c)
{
case 1: printf ("%.2f+%.2f=%.2f",a,b,a+b);break;
case 2: printf ("%.2f-%.2f=%.2f",a,b,a-b);break;
case 3: printf ("%.2fx%.2f=%.2f",a,b,a*b);break;
case 4: printf ("%.2f/%.2f=%.2f",a,b,a/b);break; 80
default: printf("Opération incorrect");
}
}
STRUCTURES ALTERNATIVES
5. Le conditionnel « ? »
resultat= (test) ? valeur_si_test_valid :
valeur_si_test_non_valid
C’est l’équivalent à:
if (test)
resultat = valeur_si_test_valid;
Else
resultat= valeur_si_test_non_valid

 Exemple:
signe= (a<0)? true : false;
// si a < 0 alors la variable signe prend la valeur true
// si a > 0 alors la variable signe prend la valeur false

 Exercice
Ecrire un programme qui permet de dire que le nombre
81
saisi est positif ou négatif
BOUCLES
1. while:
while (Condition)
{
// Instructions
}
 Tant que la Condition est vérifiée les Instructions seront
exécutées
Exemple:
int i = 0;
while (i<=10)
{
printf("%d\t", i);
i++;
}

Résultat: cette boucle affiche les valeur entières allant de 0 à 10. 82

BOUCLES
1. while:
Exercice :
Ecrire un programme qui affiche toutes les puissances de 2,
jusqu'à une valeur maximale donnée par l'utilisateur. On
calculera la puissance par multiplications successives par 2.

83
SOLUTION PUISSANCE DE 2

#include <stdio.h>
void main(void)
{
int puissance=2,max;
printf("Entrer le nombre maximal : ");
scanf("%d",&max);
while (puissance<=max)
{
printf("%d\n",puissance);
puissance*=2;
} 84
}
BOUCLES
2. do-while
do
{
// Instructions
} while (Condition) ;
 Exercice 1:
programme qui demande à l’utilisateur d’entrer un chiffre entre 2 et 9.
Tant que le chiffre est dans cette plage le programme est exécuté .

 Exercice 2: (à faire)
Écrivez un programme de jeu demandant de deviner un nombre entre 0 et
10 choisi par l'ordinateur. On ne donnera pas d'indications avant la
découverte de la solution, où l'on indiquera le nombre d'essais. La solution
sera choisie par l'ordinateur par la fonction rand() qui rend un entier 85
aléatoire (déclarée dans stdlib.h).
SOLUTION DO-WHILE

#include <stdio.h>
void main(void)
{
int c;
do
{
printf("Entrer une valeur entre 2 et 9: ");
scanf("%d",&c);
}while (c >=2 && c<=9);
printf("Au revoir\n");
} 86
BOUCLES
3. for
for (etat_initial ; condition_finale ; état_incrémenté)
{
// instructions
}
i=i+1
 Exemple:
int i;
for (i=0; i<=10; i++)
{
printf ("%d\n",i);
}
 Exemple 2: quel est le résulta de:
int i; 0
for (i=0; i<=10; i++) 2
4
{ 6
printf ("%d\n",i); 8
10
87
i++;
}
BOUCLES
 Exercice :
Ecrire un programme qui calcule la moyenne de N notes. Le
nombre de note N doit être saisi ainsi que les notes.
#include <stdio.h>
void main(void)
{
int i,N;
float Note,M=0;
printf("entrer le nombre de notes: ");
scanf("%d",&N);
for (i=0; i<N; i++)
{
printf("entrer la note numéro %d: ",i+1);
scanf ("%f",&Note);
M+=Note; 88
}
printf("La moyenne est %.2f", M/N);
}
LES BRANCHEMENTS INCONDITIONNELS
 break
Utilisée pour sortir de une boucle

 continue
provoque le passage à la prochaine itération d'une boucle

 goto
permet de passer directement d’une ligne de code vers une
autre ligne de code qui est identifiée par une étiquette
(label)

 return
permet de sortir/retourner d’une fonction

 exit
permet de quitter le programme 89
BREAK
#include <stdio.h>
void main(void)
{
int i,N=10;
for (i=0; i<N; i++)
{
printf("%d\n",i);
if (i==5) break;
}
printf("Au revoir");
}

90
CONTINUE

#include <stdio.h>
void main(void)
{
int i,N=10;
for (i=0; i<N; i++)
{
if (i==5) continue;
printf("%d\n",i);
}
printf("Au revoir");
}

91
RETURN

#include <stdio.h>
void main(void)
{
int i,N=10;
for (i=0; i<N; i++)
{
if (i==5) return;
printf("%d\n",i);
}
printf("Au revoir");
}

92
RETURN
#include <stdio.h>
void main(void)
{
int i,N=10;
for (i=0; i<N; i++)
{
if (i==5) goto etiquette;
printf("%d\n",i);
}
printf("Au revoir");
etiquette: printf("J'ai sauté jusqu'a cette etiquette");
}

93
 CHAPITRE 3:
TABLEAUX ET POINTEURS
PLAN
 Tableaux simples
 Tableaux multidimensionnels

 Pointeurs

 Pointeurs et tableaux

95
INTRODUCTION
 Réflexion
 Manipuler les notes d’un étudiant:
 3 Modules
 Saisi de notes

 Saisi de coefficients

 Calcul de la moyenne

 Affichage des modules validés et modules non-validés

 ...

 Variable: ne permet de stocker qu’une seule donnée

(type)
 Il faut faire le traitement au-fur-et-à-mesure  très lourd
 Pour mieux organiser notre code, il faut utiliser
des variables élaborées: TABLEAUX 96
INTRODUCTION
 Solution:
 La plupart des langages de programmation
proposent des conteneurs permettant de stocker un
ensemble de données dans une « seule variable »
 Et pour accéder au contenu de la variable, il suffit de la
parcourir
 En C, on trouve deux types;
 Tableau: permet de stocker plusieurs données de même type
(Notes, coefficients, ...)
 Structure: permet de stocker des données hétérogènes

97
TABLEAUX SIMPLES
 Définition:
 Un tableau est une variable composée de données de même
type, stockées en mémoire de manière adjacente (l’une
après l’autre).
 Déclaration
type nom_du_tableau [nombre_d_elements];

 Exemples:
int note[20] ; // tableau de type entier de 20 éléments
float poids[15], tailles[6];
char prenom[255];

98
TABLEAUX SIMPLES
 Accès aux éléments
nomTableau[indiceElement]

 En C, les éléments d’un tableau de taille N sont indexés de

0 à N-1
 l’indice du premier élément est 0

 l’indice du Nième élément est N-1

99
TABLEAUX SIMPLES
 Exemples:

int maListe[10];
maList[0]=25; //Affecter au 1er élément de maList la valeur 25.
maList[2]=3;
maList[9]=-30; //Affectation au dernier élément la valeur -30.
printf("%d", maList[0]); //affiche la valeur 25; le contenu du 1er élément
printf("%d", maList[2]); // affiche la valeur 3.
// Lecture de la console
scanf("%d", &maList [0]);
/*mémoriser dans le 1er élément (élément d’indice 0) du tableau un
entier saisi au clavier.*/ 100
TABLEAUX SIMPLES
 Initialisation
 Il est possible d’initialiser un tableau lors de sa
déclaration:
type nomTableau[taille]= {Valeurs séparés par virgule};
 Exemples:
int nbr[10]={15,10,2,3,4,-5,6,8,8,9};
/* tableau de 10 éléments initialisés respectivement par
les valeurs indiqués entre { };
nbr[0]=15 ... nbre[5]=-5 ... nbre[10]=9
*/

101
TABLEAUX SIMPLES
 Initialisation (suite)
 Lors de l’initialisation d’un tableau, on peut omettre la
taille du tableau (le nombre des éléments )
type nomTableau[]= {Valeurs séparés par virgule};
 Le nombre d’éléments du tableau est égale au nombre de
valeurs indiquées dans la liste entre les accolades

 Exemple:
int nbr[]={15,10,2,3,4,-5,6,8,8,9};
// même déclaration que la précédente
int tab[10]={1,2,3}; /* les 3 premiers éléments sont initialisés
par les valeurs indiqués et les7
autres éléments sont initialisés par 0 102
*/
TABLEAUX SIMPLES
 Lecture et écriture dynamique
 Pour accéder aux éléments du tableau d’une manière
dynamique, utiliser les boucles (for de préférence)
 Exemple
int i, tab[5];
printf("Entrer les éléments du tableau :\n");
for(i=0; i<5; i++)
scanf("%d", &tab[i]); // Lecture des éléments
printf("Les éléments du tableau sont:\n");
for(i=0; i<5; i++)
printf("%d\t", tab[i]); // Affichage des éléments
103
LES TABLEAUX SIMPLES
 Exercice:
 Ecrire un programme qui lit un tableau d’entiers au clavier et
qui affiche:
 Tous les éléments du tableau

 La somme des éléments

 Les éléments dans un sens inverse

104
LES TABLEAUX MULTIDIMENSIONNELS
 Définition:
 Un tableau à plusieurs dimensions est défini comme
un tableau de tableaux.
 Définir et utiliser des tableaux de dimensions 2, 3, …
dimensions.
 Pour un tableau de N dimensions, il faut donner la
taille pour chaque dimension (N valeurs)
 Déclaration:
type nom_tableau [N1] [N2] [N3] …[Nn] ;

105
TABLEAU À DEUX DIMENSIONS
 Un tableau à deux dimensions peut être
interprété comme une matrice.
 Un tableau à 2 dimensions de L lignes et C colonnes
contient donc L*C composantes.

L lignes

106
C colonnes
TABLEAU À DEUX DIMENSIONS
 Déclaration
type NomTableau[nbLignes][nbColonnes];
 Exemple
int t[10][20];
float M1[20][20], M2[50][100];
char liste[100][20];

107
TABLEAU À DEUX DIMENSIONS
 Accès aux éléments
 Considérons un tableau à 2D de n lignes et m colonnes.
les indices des lignes du tableau varient de 0 à n-1, et les
colonnes de 0 à m-1.
 La composante de la 2ème ligne et 4ème colonne d’un
tableau T est notée: T[1][3].
 Exemple:
int t[3][2]; // Matrice de 3x2
t[0][0]=5; // Mettre 5 à la 1ére ligne et 1ére colonne
t[2][1]=-3: // Mettre -3 à la 3éme ligne et 3éme colonne

108
TABLEAU À DEUX DIMENSIONS
 Initialisation
 Comme pour le cas simple, lors de la déclaration d'un
tableau multidimensionnel, on peut initialiser ses
éléments, en indiquant la liste des valeurs respectives
entre accolades.
 A l'intérieur de la liste, les composantes de chaque ligne
du tableau sont aussi (pas obligatoire) comprises entre
accolades.
 Exemple
int t[4][3]= { {1 , 3, 0} , {-4 , 9 , 2} , {6, 3 , -1} , {4, 0 , 5} };
int t[4][3]= { 1 , 3, 0 , -4 , 9 , 2 , 6, 3 , -1 , 4, 0 , 5 };
109
TABLEAU À DEUX DIMENSIONS
 Remarques
 Lors de l'initialisation, les valeurs sont affectées ligne par
ligne en passant de gauche à droite.
 Comme pour le cas 1D, il n’est pas nécessaire d’indiquer
toutes les valeurs. Les valeurs manquantes seront
initialisées par zéro.
 Il est cependant défendu d'indiquer trop de valeurs pour
un tableau.

110
TABLEAU À DEUX DIMENSIONS
 Affichage des éléments
 Pour afficher les éléments des tableaux à 2 dimensions,
on utilise deux indices et la boucle for, souvent
imbriquée, pour parcourir les lignes et les colonnes.
 Exemple
for(int i=0;i<NL; i++){
for(int j=0;j<NC; j++)
printf("%d\t",Tab[i][j]);
printf("\n");
}
// NL : le nombre de lignes
// NC : le nombre de colonnes 111
LES POINTEURS
 LES POINTEURS
 Réflexion;
int i=5;
printf ("i=%d son adresse mémoire:%d", i,&i);
Va donner comme résultat aprés execution
i=5 son adresse mémoire:2293532

int i=5,j=-154;
printf ("j=%d son adresse mémoire:%d\n", j,&j);
printf ("i=%d son adresse mémoire:%d", i,&i);
Va donner comme résultat aprés execution
j=-154 son adresse mémoire:2293528
i=5 son adresse mémoire:2293532
Variable j i
113
mémoire -154 5

adresse … … 2293528 2293532 …

 LES POINTEURS

 Définition
 Variable: sert à stocker les données manipulées par un
programme. Lorsque l’on déclare une variable, un espace
mémoire lui sera réservé pour y stocker sa valeur.
L’emplacement de cet espace dans la mémoire est nommé
adresse.
 Pointeur: est une variable qui désigne un emplacement
mémoire (une adresse) occupée par une donnée

Variable p i
mémoire 2293532 5

adresse 2290004 … … 2293532 …

114
On dit que p pointe sur l’adresse mémoire occupée par la
variable i
LES POINTEURS
 Déclaration:
un pointeur est déclaré au moyen de l’opération d’indirection «*».
 Syntaxe :
type * Nom_du_Pointeur>;

Nom_du_Pointeur ne peut (doit) recevoir que des adresses de

variables du type Type
 Exemple:
 int i, j; // déclaration de deux variables de type entier
 int *p; // déclaration d’un pointeur sur une variable entière
 float *ptr; // déclaration d’un pointeur sur une variable float
 char nom, *ptr;
115
// déclaration d’une variable de type char et un pointeur sur char.
LES POINTEURS

 Initialisation:
 Lorsqu’on déclare un pointeur sans l’initialiser, on ne sait
pas sur quoi il pointe.
 Pointeur qui ne pointe sur rien
 int *ptr = NULL;
 Pointeur qui pointe sur une variable p i
 int i=5; 2293532 5
 int *p=&i; 2293528 2293532
 Pointeurs qui pointent sur la même adresse
 int i=5; q p i
 int *p=&i; 2293532 2293532 5
 int *q=p; 2293524 2293528 2293532 116
LES POINTEURS
 Manipulation:
 Exemple:
int i=5;
int *p=&i;
 &i: l’adresse mémoire de la variable i

 printf("%d\n",&i);  2293528
 p: l’adresse mémoire sur laquelle pointe p
printf("%d\n",p); 2293528
 *p: représente le contenu de la case mémoire sur laquelle p
pointe:
printf("%d\n",*p);  5
 &p: l’adresse mémoire de la variable p:
117
printf("%d\n",&p);  2293532
LES POINTEURS

 Manipulation (suite):
 Pointeur qui ne pointe sur rien p
int *p = NULL; 0
2293532
int i=5; i p
p=&i; 5 2293528
printf("*p=%d\n",*p);  *p=5 2293528 2293532
i p
*p=80; 80 2293528
2293528 2293532
printf("i=%d\n",i);  i=80
q i p
118
int *q=p; 2293528 80 2293528
printf("*q=%d\n",*p);  *q=80 2293524 2293528 2293532
(*p)++; // eq. à i++;
LES POINTEURS
 Manipulation (suite):
 Exercice: que produit le code suivant
int a=51;
int b=120;
int * ptr;
ptr = (a>b) ? &a : &b;
(*ptr)++;
printf("a=%d, b=%d, *pointeur=%d \n", a,b,*ptr);

119
LES POINTEURS
 Manipulation (suite):
 Exercice: que produit le code suivant
int a=51;
int b=120;
int * ptr;
ptr = (a>b) ? &a : &b; // ptr pointe sur la case b
(*ptr)++; // incrément ele contenu de la case pointée par ptr
printf("a=%d, b=%d, *pointeur=%d \n", a,b,*ptr);

 Le résultat:
a=51, b=121, *pointeur=121

120
LES POINTEURS ET TABLEAUX
 Réflexion
 int tab[5]={1,58, 7};

tab[0] tab[1] tab[2] tab[3] tab[4]

1 58 7 0 0
2293496
Equivalent à
tab
1 58 7 0 0
2293496

 Le nom d'un tableau représente l'adresse de son

premier élément
121
 Équivalent à dire que le nom d'un tableau est
un pointeur constant sur le premier élément du tableau
LES POINTEURS ET TABLEAUX
 Pointeurs et tableaux sont en étroite relation:
 Exemple 1:
int tab[10]={1,58, 7}, i;
printf ("%d\n",*(tab)); // 1: tab pointe sur le 1er élément
printf ("%d\n",*(tab+1)); // 58: tab+1 pointe sur le 2éme élément
printf ("%d",*(tab+i)); // 7: tab+i pointe sur le iéme élément
 Exemple 2:
int tab[10]={1,58, 7}, i;
int *ptr;
ptr=tab; // équivalent à ptr=&tabl[0];
printf ("%d\n",*(ptr)); // 1: ptr pointe sur le 1er élément de tab
printf ("%d\n",*(ptr+1)); // 58: ptr+1 point esur le 2éme élément de tab
i=2; 122
printf ("%d",*(ptr+i)); // 7: ptr+i point sur l’iéme élément de tab
LES POINTEURS ET TABLEAUX
 Relation entre pointeur et tableau (suite):
 Exercice:
 Déclarer un tableau de 5 éléments {15, 8, -8, 7, 9}
 Afficher en utilisant une boucle for tous les éléments du

tableau:
1. Utilisant les indexes
2. Utilisant les pointeurs

123
LES POINTEURS ET TABLEAUX
 Relation entre pointeur et tableau (suite):
 Solution
#include <stdio.h>
main()
{
int tab[5]={15, 8, -8, 7, 9}, i;
for (i=0; i<5; i++)
{
printf ("%d\t",tab[i]);
}
printf("\n");
for (i=0; i<5; i++)
{
printf ("%d\t",*(tab+i));
}
124
}
OCCUPATION MÉMOIRE
 Taille d’une variable
 Pour toute variable créée, une zone mémoire lui sera
associée, servant à stocker son contenu
 La taille dépend du type de la variable:
 char : 1 octet
 int : 2 ou 4 octets (selon l’architecture du système)

 float : 4 octets

 double : 8 octets

 etc

125
OCCUPATION MÉMOIRE
 Taille d’une variable
 L’opérateur « sizeof()» retourne la taille en octets
d’un type ou d’une variable passée en paramètre.
sizeof( type) ou bien sizeof( nom_variable)
 Exemple:
double x, tab[]={1,2,5,8};
printf("Sur mon système un ‘double’ fait %d octets", sizeof(x)); 
taille de la variable x: 8 octets
// équivalent à
printf("Sur mon système un ‘double’ fait %d octets", sizeof(double));
 taille de la variable du type double: 8 octets
// Astuce: taille d’un tableau: sizeof(tab)/sizeof(type)
126
printf ("Taille du tableau est: %d", sizeof(tab)/sizeof(double));
ALLOCATION DYNAMIQUE
 Cas d’un pointeur:
 Contrairement aux variables, un pointeur n’a pas
d’existence tant qu’on ne l’a pas initialisé.
 Il existe en C, des fonctions permettant d'allouer la
mémoire à un pointeur.
 La fonction malloc de la bibliothèque « stdlib » permet
de réserver de la mémoire au cours d’exécution d’un
programme.
 Syntaxe:
malloc( <NombreOctets> )
 Elle renvoie l’adresse d’un bloc mémoire de taille indiquée
en argument <NombreOctets>.
127
 Elle renvoie 0 dans le cas d’échec.
ALLOCATION DYNAMIQUE
 Cas d’un pointeur: allocation (Réservation) de mémoire
 Exemple 1: Sans allocation de mémoire
#include <stdio.h>
#include<stdlib.h>
main()
{
char *ptrChr;
printf("Entrer un texte de 10 caractéres\n");
scanf("%s",ptrChr);
printf("Texte saisi: %s\n",ptrChr);
}
 Erreur d’exécution: après la saisi du texte par
l’utilisateur, le programme va générer une erreur (Bug).
Car le pointeur ptrChr n’a d’espace mémoire réservé 128
ALLOCATION DYNAMIQUE
 Cas d’un pointeur: allocation (Réservation) de mémoire
 Exemple 2: Avec allocation de mémoire
#include <stdio.h>
#include<stdlib.h>
main()
{
char *ptrChr;
//Réservation de la mémoire
ptrChr = (char*)malloc(255); /* lui réservé 255 octets en mémoire */
printf("Entrer un texte: \n");
scanf("%s",ptrChr);
printf("Texte saisi: %s\n",ptrChr);
}
 Le texte saisi sera affiché sans problème 129
ALLOCATION DYNAMIQUE
 Cas d’un pointeur: Libération de la mémoire réservée:
 La fonction free de la biblio. « stdlib » permet la
libération de l’emplacement mémoire réservé par malloc.
Syntaxe:
free(<Pointeur>);

130
ALLOCATION DYNAMIQUE
 Cas d’un pointeur: allocation/libération de mémoire
 Exemple:
char *ptrChr;
int *ptrIn;
float *ptrNotes;
//Réservation de la mémoire
ptrChr = (char*)malloc(10); /* réserve 10 octets mémoire (10 caractères) */
ptrIn = (int*)malloc(20); /*réserve 20 octets, soit la place pour 5 entiers*/
ptrNotes =(float*)malloc(16); /*réserve 16 octets, soit la place pour 4 réels */
//Libération de la mémoire
free(ptrChr); /* libère l’espace mémoire réservé pour ptr*/
free(ptrIn); /* libère l’espace mémoire réservé pour le pointeur notes */
free(ptrNotes); /* libère l’espace mémoire réservé pour le pointeur notes */131
 CHAPITRE 4:
LES FONCTIONS
PLAN
 Introduction
 Fonctions
 Déclaration
 Appel

 Variables locales et variables globales

 Passage de paramètres
 Par valeur
 Par adresse
 Fonctions récursives

133
INTRODUCTION
 Réflexion
 Ecrire un programme C qui permet de:
 Demander à l’utilisateur de saisir deux valeurs
 De calculer et afficher le factoriel de chaque valeur

 De calculer et afficher la somme des valeurs saisies

 De calculer et afficher le factoriel de cette somme

 ...

134
#include <stdio.h> INTRODUCTION
void main()
{
int a, b,f,s,i,N;
printf("donner deux valeurs: ");
scanf ("%d%d",&a,&b);
s=a+b;
N=a;
for (i=1, f=1; i<=N; i++)
f=f*i;
printf ("%d!=%d\n", N,f);
N=b;
for (i=1, f=1; i<=N; i++)
Le même bloc
f=f*i; d’instructions qui se
printf ("%d!=%d\n", N,f); répète
N=s;
for (i=1, f=1; i<=N; i++)
f=f*i; Regrouper le bloc
d’instructions dans une 135
printf ("%d!=%d\n", N,f);
seule entité et faire
} l’appel en cas de besoin
 INTRODUCTION
#include <stdio.h> #include <stdio.h>
void main() void main()
{ {
int a, b,f,s,i,N; int a, b,f,s,i,N;
printf("donner deux valeurs: printf("donner deux valeurs: ");
"); scanf ("%d%d",&a,&b);
scanf ("%d%d",&a,&b); s=a+b;
s=a+b; fact (a);
N=a; fact (b);
for (i=1, f=1; i<=N; i++) fact (s);
Faire appel
f=f*i; aux fonctions }
printf ("%d!=%d\n", N,f); void fact(int N)
N=b; {
for (i=1, f=1; i<=N; i++) // fait le traitement et affiche
f=f*i; int f,i;
printf ("%d!=%d\n", N,f); for (i=1, f=1; i<=N; i++)
N=s; f=f*i;
for (i=1, f=1; i<=N; i++) printf ("%d!=%d\n", N,f); 136
f=f*i; }
printf ("%d!=%d\n", N,f);
}
 INTRODUCTION
#include <stdio.h> #include <stdio.h>
void main() void main()
{ {
int a, b,f,s,i,N; int a, b,f,s,i,N;
printf("donner deux valeurs: printf("donner deux valeurs: ");
"); scanf ("%d%d",&a,&b);
scanf ("%d%d",&a,&b); s=a+b;
s=a+b; f=fact (a);
N=a; printf ("%d!=%d\n", a,f);
for (i=1, f=1; i<=N; i++) f=fact (b);
Faire appel
f=f*i; aux fonctions printf ("%d!=%d\n", b,f);
printf ("%d!=%d\n", N,f); f=fact (s);
N=b; printf ("%d!=%d\n", s,f);
for (i=1, f=1; i<=N; i++) }
f=f*i; int fact(int N)
printf ("%d!=%d\n", N,f); { // fait le traitement
N=s; int f,i;
for (i=1, f=1; i<=N; i++) for (i=1, f=1; i<=N; i++)
137
f=f*i; f=f*i;
printf ("%d!=%d\n", N,f); return f;
}
INTRODUCTION
 Fonctions et procédures
 Sont des blocs d'instructions indépendants désignés
par un nom (identificateur).
 Elles présentent plusieurs avantages:
 Programmes « modulaires »  Mettre en commun les
parties qui se répètent
 Bonne structuration et meilleure lisibilité des programmes

 Facilité de la maintenance du code (il suffit de modifier une

seule fois)
 Réutilisation dans différents programmes.

138
 INTRODUCTION
 Fonctions et procédures (suite)
 Par définition; une procédure effectue un traitement sans
renvoyer aucune valeur. Alors qu’une fonction effectue le
traitement et renvoie une valeur (en générale le résultat du
traitement)
 En programmation C, il n’y a pas de différence entre
fonctions et procédures dans la déclaration mais plutôt dans
la façon d’utilisation
 Dans la suite on va adopter le mot FONCTION pour
identifier soit une fonction ou une procédure
 Fonction: fonction qui fait un traitement et renvoie une valeur
 Procédure: fonction qui ne renvoie rien

Fonction Procédure 139

Paramètres Résultat Paramètres
NomFonction NomFonction
FONCTIONS
 Déclaration
 Déclarée en dehors de la fonction principale « main »
 Peut être appelée de n’importe où
 Syntaxe
<type> <nom_fonction> ([type1 arg1[,type2 arg2, …]])
{
//Corps de la fonction
[return (expression)]
}
 La première ligne c’est l’en-tête de la fonction
 type est le type du résultat retourné.
 Dans le cas ou la fonction ne retourne pas de résultat, elle est de type
void. Et on n’écrit pas l’instruction return (expression)
 nom_fonction : le nom ou l’identificateur de la fonction
 entre parenthèses, on spécifie les arguments (paramètres) de la
fonction et leurs types. 140
 return (expression): le mot clé return suivi de la valeur à
renvoyer (qui doit être du même type que la fonction)
FONCTIONS
 Syntaxe
<type> <nom_fonction> ([type1 arg1[,type2 arg2, …]])
{
//Corps de la fonction
[return (expression)]
}
 Remarques
 Dans le cas ou une fonction n'a pas d’argument en entrée, on peut
déclarer la liste des paramètres comme (void) ou simplement
laisser vide entre parenthèses ( )
 Si une fonction doit retourner une valeur, on fait appel au mot clés
« return ».
 Le type de retour doit être le même que le type de la fonction dans l’entête
 Peut être utilisé n’importe où dans le code (là ou on veut quitter la fonction
en retournant une valeur)
 Peut exister plusieurs fois dans une fonction
 Les paramètres (arguments) des fonctions sont des variables
locales au bloc d’instructions de la fonction. 141
 Cependant, on peut définir d’autres variables dans le bloc
 Une fonction peut avoir des arguments de différents types
 FONCTIONS
 Exemples
void hello()
{ Fonction « hello » qui affiche un
printf("Hello every body\n"); texte et qui ne retourne rien
}

float multiplication (float a, float b) Fonction «multiplication » qui

{ calcule le produit de deux réels
return a * b; passés en argument et retourne
} le résultat
void fact(int N)
{
int f,i; Fonction «fact» qui calcule le
for (i=1, f=1; i<=N; i++) factoriel d’un entier passé en142
f=f*i; argument et affiche le résultat
printf ("%d!=%d\n", N,f);
}
 FONCTIONS
 Prototype
 Pour certain compilateur, il est obligatoire de donner la
définition d'une fonction. Si une fonction est définie après
son premier appel, elle doit être déclarée auparavant.
 La déclaration d'une fonction se fait en haut après les
inclusions « include » par son prototype et qui indique le
type de la fonction ainsi que les types des arguments:
Type NomFonction (type1 [param1],…, typeN [paramN]);

#include <stdio.h> #include <stdio.h>

Ou bien
float multiplication (float, float); float multiplication (float a, float b);
143
FONCTIONS
 Appel d’une fonction
 On appelle une fonction en utilisant son nom, avec la valeur des
arguments entre parenthèses, dans l’ordre de sa définition.
NomFonction (para1,…, paraN)
 Remarques:
 Il faut respecter l’ordre et les types des arguments
 Dans le cas d’une fonction ne retournant rien, l’appel de la fonction
sera direct
hello();
 Dans le cas d’une fonction qui retourne une valeur, la fonction doit être
utilisée dans une instruction d’affectation
x=fact(5);
printf(”%d”, fact(6));
 Lors de l’appel d’une fonction, les paramètres sont appelés paramètres
effectifs (ou arguments) : ils contiennent les valeurs pour effectuer le
traitement. 144
 Lors de la définition, les paramètres sont appelés paramètres formels
 FONCTIONS
 Exemples
#include <stdio.h> #include <stdio.h>
float multiplication (float a, float b) float multiplication (float, float );
{ void main()
return a * b; {
} float a, b,m;
void main() printf("donner deux valeurs: ");
{ scanf ("%f%f",&a,&b);
float m=multiplication(3,8); m=multiplication(a,b);
printf("%.2f",m); printf("%.2fx%.2f=%.2f",a,b,m);
} }
Ex1
float multiplication (float x, float y)
#include <stdio.h> {
void main() return x * y;
{ } Ex3
hello();
}
void hello() 145
{
printf("Hello every body\n");
Ex2
FONCTIONS
 Exercice
1. Ecrire une fonction Maxi qui retourne le maximum de
deux entiers donnés.
2. Utiliser cette fonction dans la fonction main en
demandant à l’utilisateur d’entre deux nombres et
d’afficher le maximum
3. Ajouter une autre fonction, nommée Maxi3 qui retourne
le maximum de 3 valeurs passés en argument; il faut
utiliser la fonction Maxi

146
FONCTIONS
#include <stdio.h>
void main()
{
int x,y,z;
printf ("entrer deux valeurs\n");
scanf("%d%d",&x,&y);
printf("le max est: %d\n", Maxi(x,y));
// 2-
printf ("entrer trois valeurs\n");
scanf("%d%d%d",&x,&y,&z);
printf("le max est: %d\n", Maxi3(x,y,z));
}
int Maxi(int a, int b)
{
return a>b ? a :b;
}
int Maxi3(int a, int b, int c)
147
{
return c>Maxi(a,b) ? c : Maxi(a,b); // return Maxi(Maxi(a,b),c);
}
FONCTIONS:
 Variables locales et variables globales
 Chaque variable déclarée est accessible dans son contexte
de déclaration
 Une variable définie à l'intérieur d’une fonction est une
variable locale à la fonction, et elle n’est connue qu'à l'intérieur
de cette fonction
 Elle est créée à l'appel de la fonction et détruite à la fin de
son exécution
 Une variable définie à l’extérieur des fonctions est une variable
globale
 Elle est définie durant toute l’application et peut être
utilisée et modifiée par toutes les fonctions du programme
 Une variable locale cache la variable globale qui a le même
nom
 Une variable déclarée dans un bloc d'instructions est
uniquement visible à l'intérieur de ce bloc
 C’est une variable locale à ce bloc, elle cache, localement, toutes
les variables du même nom des blocs qui l'entourent
148
 FONCTIONS:
 Variables locales et variables globales (suite)
 Exemples
#include <stdio.h>
int a=150; // variable globale
void main()
{ dans main a=150
printf("dans main a=%d\n",a);
}
#include <stdio.h>
int a=150; // variable globale
void main()
{ dans main a=10
int a=10; // variable locale à main cache a globale
printf("dans main a=%d\n",a); 149
}
 FONCTIONS:
 Variables locales et variables globales (suite)
 Exemples
#include <stdio.h>
int a=150; // variable globale
void main()
{
int a=10; // variable locale à main cache a globale
affecte(a);
printf("dans main a=%d\n",a); dans affecte avant affectation a=10
} dans affecte après affectation a=5
void affecte(int a) dans main a=10
{
// a est une variable locale à affecte cache a globale
printf("dans affecte avant affectation a=%d\n",a);
a=5; 150
printf("dans affecte aprés affectation a=%d\n",a);
}
 FONCTIONS
 Passage de paramètres
 Réflexion: quel est le résultat d’exécution des deux
programmes
#include <stdio.h> #include <stdio.h>
void main() void main()
{ {
int a=10; int a=10;
affecte(a); affecte(&a);
printf("a=%d\n",a); printf("a=%d\n",a);
} }
void affecte(int a) void affecte(int *b)
{ {
a=5; *b=5;
} }
151
 FONCTIONS
 Passage de paramètres
 Réflexion: quel est le résultat d’exécution des deux programmes

#include <stdio.h> #include <stdio.h>

void main() void main()
{ {
int a=10; int a=10;
affecte(a); affecte(&a);
printf("a=%d\n",a); printf("a=%d\n",a);
} }
void affecte(int a) void affecte(int *b)
{ {
a=5; *b=5;
} }
152

a=10 a=5
 FONCTIONS
 Passage de paramètres
1. Passage par valeur
 La transmission des paramètres en C est par défaut par valeur.
Ainsi quand une variable passée en argument à une fonction c’est sa
valeur qui est passée
2. Passage par référence (adresse)
 Pour effectuer une transmission par adresse en C, on déclare le
paramètre formel de type pointeur et lors d'un appel de la fonction,
on envoie l'adresse et non la valeur du paramètre effectif.

void Incrementation (int n, int *m) int main( )

{ {
n=n+1; int a = 1, b=2;
*m =*m+1; Increment ation(a, &b);
} printf(“a = %d et b=%d \n", a,b);
153 }

a=1 et b=3
FONCTIONS
 Récursivité
 Une fonction récursive si elle peut s'appeler elle-même
 Pour éviter un récursivité infinie, il faut fixer un cas limite
(cas trivial) qui arrête la récursivité
 Exemple; #include <stdio.h>
void main()
{
Factoriel de 8 c’est 8 * Factoriel de 7 int a=8, f;
Factoriel de 7 c’est 7 * Factoriel de 6 f=fact(a);
printf("!%d=%d\n",a,f);
..
}
Factoriel de n c’est n * Factoriel de (n-1) int fact(int N)
... {
Il faut s’arrêter à 1 sachant que le factoriel de 1 est 1 if ( N==1 )
return 1;
else 154
return ( N * fact (N-1) );
}
FONCTIONS PRÉDÉFINIES
 Fonctions arithmétiques : <math.h>
 double sin(double X) // sinus de X
 double cos(double X) // cosinus de X
 double tan(double X) // tangente de X
 double exp(double X) // fonction exponentielle : eX
 double log(double X) // logarithme naturel
 double log10(double X) // logarithme à base 10
 double pow(double X, double Y) // X exposant Y
 double sqrt(double X) // racine carrée de X
 double floor(double X) // arrondir en moins
 double ceil(double X) // arrondir en plus
155
FONCTIONS PRÉDÉFINIES
 Classification et conversion de caractères : <ctype.h>
 int isupper(int C) // retourne une valeur différente de zéro,
si C est majuscule
 int islower(int C) // retourne une valeur différente de zéro,
si C est minuscule
 int isdigit(int C) // retourne une valeur différente de zéro,
si C est un chiffre décimal
 int isalpha(int C) // retourne une valeur différente de zéro si C
est alphabétique
 int isalnum(int C) // // retourne une valeur différente de zéro si
C est alphanumérique
 int tolower(int C) // convertit C en minuscule
 int toupper(int C) // convertit C en majuscule 156
TABLE ASCII

157
TABLE ASCII
 Exemple
void main()
{
A sont code ASCII 65
char c='A';
printf("%c sont code ASCII %d", c,c);
}

158
 CHAPITRE 5:
LES CHAINES DE CARACTÈRES
PLAN
 Introduction
 Déclaration

 Lecture et Affichage
 I/O standards
 Autres fonctions I/O

 Fonctions de manipulation
 Fonctions utiles

 Tableaux de chaines de caractères

160
INTRODUCTION
 Il n'existe pas de type spécifique pour les chaînes de
caractères en C
 Une chaîne de caractères est traitée comme un tableau de type
char à une seule dimension (tableau de caractères) ou un pointeur
sur caractères
 En C, le dernier élément d’une chaine de caractères est le
caractère '\0' qui définit la fin de la chaîne (NUL)

 Adresse et mémoire:
 Pour mémoriser une chaîne de N caractères, il faut lui réserver
N+1 octets en mémoire (le dernier ‘\0’)
 Le nom de la variable chaîne est l’identifiant de l'adresse mémoire
du premier caractère de la chaîne 161
DÉCLARATION
 Syntaxe
char <NomChaine> [<Longueur>];
 Exemple :
char nom[20];
char jour[10];
char txt[300];

162
DÉCLARATION
 Initialisation
1. Une chaîne de caractères peut être initialisée comme un tableau:
char nom[6] = {‘S’,’A’,’B’,’R’, ’I’,’\0’};
ou bien
char nom[] = {‘S’,’A’,’B’,’R’, ’I’,’\0’};
2. Utiliser une chaîne constante pour initialiser une chaîne de
caractères. Le texte doit être entre double guillemets
char nom[6]="SABRI";
ou bien
char *nom ="SABRI";

nom

S A B R I \0 163
2293496
AFFICHAGE

 Affichage d’une chaîne de caractères

 Utiliser le préfixe de format « %s »
char message[100]="Bonjour monde";
char *msg ="Salam";
printf("%s", message); Bonjour monde
printf("%s", msg); Salam
 La chaîne est affichée jusqu’au premier « \0 » rencontré.

164
LECTURE
 Lecture d’une chaîne de caractères
 Comme pour les tableaux, pour lire une chaîne de caractères, on
n’a pas besoin de « & » car la variable fait référence à une zone
mémoire.
char message[100];
scanf ("%s", message);
printf("%s\n", message);

165
AUTRES FONCTIONS D’ENTRER/SORTIES
 La fonction puts (<stdio.h>) affiche sur la console la chaîne de
caractères indiquée en argument et provoque un retour à la
ligne.
 Syntaxe:
puts(chaine);
 Exemple:
puts("Mon message est:"); //équivalent à printf("Mon message est: ");
puts(message); //équivalent à printf("%s\n",message);
 La fonction gets (<stdio.h>) permet la lecture d’une chaîne de
caractères de la console
 Syntaxe:
gets(chaine);
 Exemple:
gets(message); // équivalent à scanf("%s", message);
 Remarque: 166
 Le problème avec scanf est que les espaces seront considérés comme la
lecture du contenu d'une autre variable
LECTURE ET AFFICHAGE
 Exercice:
 Ecrire un programme qui demande à l’utilisateur de saisir
une chaine de caractères et qui
 Affiche la longueur du texte saisi
 Affiche chaque lettre de la chaine sur une ligne

 Inverse le texte saisi et l’affiche:

 Utiliser une deuxième variable

 Utiliser la même variable

167
 Solution
#include <stdio.h>
#include <string.h>
main()
{
char txt[255], txtBis[255], temp;
int i, l=0;
printf("entrer une chaine \n");
gets(txt);
for (i=0; txt[i]!='\0';i++, l++)
printf("%c\n", txt[i]);
printf ("le texte contient %d caractères\n", l);
// Inverser le texte dans une autre variable
for (i=0; i<l;i++)
{
txtBis[i]=txt[l-1-i];
}
txtBis[l]='\0'; // pour éviter le problème d'arrêt
// Inverser le texte la même variable
for (i=0; i<(l/2);i++)
{
temp=txt[i];
txt[i]=txt[l-1-i];
txt[l-1-i]=temp; 168
}
printf("%s",txtBis);
}
SÉQUENCES D’ÉCHAPPEMENT
 Remarques:
 Pour déclarer une chaine vide: ""
 On peut utiliser toutes les séquences d'échappement :
 "Ce \ntexte \nsera réparti sur 3 lignes."
 "Affichage de \"guillemets\" \n"

 {'L','\'','a','s','t','u','c','e','\0'}: pour afficher Le symbole ‘

il faut utiliser la séquence d'échappement \'

 "un " "deux"

" trois"
équivalent à "un deux trois"

169
FONCTIONS DE MANIPULATION
 Sont déclarées dans <string.h>
 strlen(<s>) : renvoie la taille d’une chaîne s sans compter le '\0'
final
 strcpy (<s>, <t>) : copie <t> vers <s>
 strcat (<s>, <t>) : ajoute <t> à la fin de <s>
 strchr (<s>, <c>) : recherche de la première occurrence d’un
caractère <c> dans la chaine <s> et retourne un pointeur sur la
première occurence
 strcmp(<s>, <t>): compare <s> et <t> lexico-graphiquement et
fournit un résultat:
 la valeur 0 si les 2 chaines sont identiques
 une valeur négative si la 1ère chaine précède la 2ème
 une valeur positive si la 1ère chaine suit la 2ème
 strncpy (<s>, <t>, <n>) : copie au plus <n> caractères de <t> vers
170
<s>
 strncat (<s>, <t>, <n>) ) : ajoute au plus <n> caractères de <t> à la fin de <s>
FONCTIONS DE MANIPULATION
 Remarques:
 On ne peut pas 'affecter' une chaîne à une variable de type
tableau de caractères déjà initialisée:

char message[100]="Bonjour monde";

char *msg ="Salam";
msg= "Hello"; // Autorisée
// message="Welcome";
// Erreur de compilation; affectation non permise
// il faut faire une copie avec strcpy
strcpy(message, "Welcome");
171
FONCTIONS UTILES
 Fonctions de conversion: nombre vers/de caractère
(<stdlib.h>)
 atoi(<s>): retourne la valeur numérique représentée par <s>
comme une valeur de type int.
int a=atoi("255"); //equi a=255;
 atof(<s>): retourne la valeur numérique représentée par <s>
comme une valeur de type float.
 atol(<s>) : retourne la valeur numérique comme long.

172
FONCTIONS UTILES
 Fonctions de la bibliothèque (<ctype.h>)
 isupper() : teste si le caractère indiqué en argument est une lettre
majuscule (de 'A‘ à 'Z').
 islower() : si le caractère est une minuscule (de 'a‘ à 'z')
 isdigit() : si le caractère est un chiffre (de '0‘ à '9')
 isalpha(): si le caractère est une lettre.
 isalnum(): si le caractère est une lettre ou un chiffre.
 isspace() : si le caractère est un caractère d'espacement (' ', '\t', '\n',
'\r', '\f‘).
 tolower() : convertir en minuscule la lettre indiquée en argument.
 toupper() : convertir en majuscule la lettre indiquée en argument.

173
TABLEAUX DE CHAÎNES DE CARACTÈRES
 Déclaration:
char <NomTabChaines>[<NbChaines>][<Longueur>];
 <NbChaines>: nombre de chaines de caractéres
 <Longueur>: Taille maximale de chaque chaine
 Exemple:
char Jours[7][9];
strcpy(Jours[0],"lundi"); l u n d i \0
strcpy(Jours[1],"mardi"); m a r d i \0
strcpy(Jours[2],"mercredi"); m e r c r e d i \0
strcpy(Jours[3],"jeudi");
strcpy(Jours[4],"vendredi"); .....
strcpy(Jours[5],"samedi");
strcpy(Jours[6],"dimanche"); d i m a n c h e 174
\0
TABLEAUX DE CHAÎNES DE CARACTÈRES
 Affichage: lundi
for(i=0; i<7; i++) mardi
mercredi
printf("%s\n", Jours[i]); jeudi
//Noms des jours de la semaine. vendredi
samedi
//On peut romplacer printf par la fonction puts. dimanche
for(i=0; i<7; i++) L
printf("%c", upper(Jours[i][0])); M
M
//Le 1er caractère en majuscule du nom du jour. J
V
S
D

175
 CHAPITRE 6:
LES STRUCTURES
PLAN
 Introduction
 Déclaration

 Initialisation

 Accès aux champs

 Copie et comparaison de structures

 Les structures imbriquées

 Structure comme étant nouveau type

177
INTRODUCTION
 En C, une structure est un nouveau type de données
regroupant un ensemble de variables
 appelées champs
 de types différents

 Une structure permet de faciliter la représentation

d’un objet réel caractérisé par plusieurs informations.
 Exemple de structures:
 L’étudiant est caractérisé par son nom , son âge, sa
moyenne, …
 L’ordinateur est caractérisé par sa marque, sa taille du
disque dur, sa fréquence du CPU, sa taille d’écran, …
178
DÉCLARATION
 La déclaration d'une structure se fait le plus souvent
comme suit:
 Syntaxe 1:

struct <NomStructure>{
<ListeChamps>
};

 ListeChamps représente la liste de déclaration des variables

(champs) de la structure.

179
 DÉCLARATION
 Exemple:
struct Etudiant{
char nom[30];
char *adresse;
int age;
float moyenne;
};

Remarque
 Le nom d’une structure n’est pas un nom de variable, c’est
le nom d’un nouveau type qu’on peut utiliser dans un
programme.
180
La déclaration d'une structure ne réserve pas d’espace
mémoire.
DÉCLARATION
 Syntaxe 2:
struct <NomStructure>{
<ListeChamps>
}[< ListeVariables>] ;

 ListeVariables est la liste de variables pouvant être déclarées lors

de la déclaration d’une structure

 Exemple: struct Etudiant{

char nom[30];
int age;
float moyenne;
181
}et1, et2;
DÉCLARATION
 Syntaxe 3:
struct <NomStructure>{
<ListeChamps>
};
struct <NomStructure> <ListeVariables>;

 Exemple:
struct Etudiant{
char nom[30];
int age;
float moyenne;
}; 182

struct Etudiant etud, etud2;

INITIALISATION
 L’initialisation d’une variable structure se fait par
l’indication des valeurs de ses champs en accolades
(comme les tableaux).
 Exemple:
struct Etudiant etud={"Toto" ,20 , 15.50};

183
ACCÈS AUX CHAMPS
 Pour accéder à un champ d’une variable de type
structure on utilise l’opérateur « . » comme suit:
<NomVariable>.<NomChamp>
 Exemple:
etud.nom // accès à la valeur du champ nom de etud.
etud.age // accès à la valeur du champ age de etud.

184
 ACCÈS AUX CHAMPS
 Exemple 1:
 Déclaration de la variable de type structure en dehors de
main

#include <stdio.h>
struct Personne {
int age;
char sexe;
};
struct Personne pers1;
main()
{
pers1.age=25;
pers1.sexe='F';
printf("L'age est %d et le sexe est: %c", pers1.age,pers1.sexe); 185
}
 ACCÈS AUX CHAMPS
 Exemple 1:
 Déclaration de la variable de type structure dans main

#include <stdio.h>
struct Personne {
int age;
char sexe;
};
main()
{
struct Personne pers1;
pers1.age=25;
pers1.sexe='F';
printf("L'age est %d et le sexe est: %c", pers1.age,pers1.sexe); 186
}
 ACCÈS AUX CHAMPS
 Exemple 1:
 Déclaration de la variable à la définition de la structure

#include <stdio.h>
struct Personne {
int age;
char sexe;
} pers1;
main()
{
pers1.age=25;
pers1.sexe='F';
printf("L'age est %d et le sexe est: %c", pers1.age,pers1.sexe);
} 187
 ACCÈS AUX CHAMPS
 Exemple 2:
#include <stdio.h>
struct Personne {
int age;
char sexe;
}pers1;
main()
{
printf("Entrer le sexe: ");
scanf("%c",&pers1.sexe);
printf("Entrer l'age: ");
scanf("%d",&pers1.age);
printf("L'age est %d et le sexe est: %c", pers1.age,pers1.sexe);
}
188
LES STRUCTURES
 Exercice:
 Ecrire un programme permettant la gestion des employés
d’une entreprise donnée.
 Chaque employé est caractérisé par son nom, son age et son

salaire.
 Définir la structure Employe

 Ecrire un fonction qui lit au clavier les informations d’un

employé
 Ecrire une fonction qui affiche les informations d’un employé

 Tester l’appel aux différentes fonctions

189
#include <stdio.h>
void Afficher();
void Saisir();
struct Employe {
char nom[15];
int age;
float salaire;
};
struct Employe emp;
main()
{
Saisir(); Afficher();
}
void Saisir()
{
printf("Entrer le nom: "); scanf("%s",emp.nom);
printf("Entrer l'age: "); scanf("%d",&emp.age);
printf("Entrer le salaire: "); scanf("%f",&emp.salaire);
}
void Afficher()
{
printf("Les informations de l'employé sont:\n"); 190
printf("Nom: %s, Age: %d et sont salaire est: %.2fDH\n", emp.nom, emp.age,
emp.salaire);
}
TABLEAUX DE STRUCTURES
 Comme pour les types simples, on peut déclarer une
variable de type tableau/pointeur d’une/sur structure
définie
 Syntaxe:
struct <nom_structure> varSt[<taille>];
Ou bien
struct <nom_structure> *varSt;

191
TABLEAUX DE STRUCTURES: ACCÈS AU CHAMPS
 Dans le cas d’un tableau de type structure on utilise les
crochets [] avec l’indices (le premier indice est 0)
NomVariablePointeur>[<indice>]. <NomChamp>
 Exemple:
cls[0].id
 Dans le cas d’un pointeur de type structure, on utilise
l’opérateur « -> »:
<NomVariablePointeur>-><NomChamp>
 Exemple:
ptr ->Nom // équivalent à (*ptr).nom
ptr ->age
192
TABLEAUX DE STRUCTURES
 Exemple:
#include <stdio.h>
struct Employe {
//char nom[15];
int age;
float salaire;
};

main()
{
struct Employe emp, empT[5], *empP;
empP=&emp; // pointer sur une adresse mémoire de type Employe
empP->age=50;
empP->salaire=12.54;
printf("%d\n",empP->age);
empT[0].age=25; 193
printf("%d",empT[0].age);
}
TABLEAUX DE STRUCTURES
 Exercice:
 Ecrire un programme permettant la gestion des employés
d’une entreprise donnée.
 Chaque employé est caractérisé par son nom, son age et son
salaire.
 Définir la structure Employe

 Ecrire un fonction qui lit au clavier les infos d’un employé

 Ecrire une fonction qui affiche les infos d’un employé

 Déclarer une variable de type tableau d’Employé

 Ecrire une fonction qui demande à l’utilisateurs de saisir les

infos des 4 employés
 Ecrire une fonction qui affiche les informations des 4
Employés
 Tester l’appel aux différentes fonctions 194
#include <stdio.h>
void Saisir5();
void Afficher5();
struct Employe {
char nom[15];
int age;
float salaire;
};
struct Employe emp, empT[5];
main()
{
Saisir5();
Afficher5();
}
void Saisir5()
{
int i;
for (i=0;i<5;i++)
{
printf("Entrer le nom: ");
scanf("%s",empT[i].nom);
printf("Entrer l'age: ");
scanf("%d",&empT[i].age);
printf("Entrer le salaire: ");
scanf("%f",&empT[i].salaire);
}

}
void Afficher5()
{
int i;
printf("Les informations des employés sont:\n");
for (i=0;i<5;i++) 195
{
printf("Nom: %s, Age: %d et sont salaire est: %.2fDH\n", empT[i].nom, empT[i].age, empT[i].salaire);
}
}
 COPIE ET COMPARAISON DE STRUCTURE
 En langage C, les structures sont manipulées champ
par champ.
 Cependant, il est possible d’affecter une variable de type
structure à une autre variable de même type (la même
structure).
 Exemple:
struct Etudiant e1={"Yassir", 20, 14.25};
struct Etudiant e2;
e2=e1;
Remarque
 Par contre, il n’est pas possible de comparer des variables
de type structure.
 e1==e2, e1!=e2,… sont incorrectes. 196

 Il faut comparer champ par champ

LES STRUCTURES IMBRIQUÉES
 Une structure peut contenir des champs de type
structure (même ou autre structure).
 Exemple:
struct Adresse{ struct Personne{
int num; char NomPrenom[40];
char rue[30], ville[20] ; char sexe;
}; struct date dateNais;
struct date{ struct Adresse adr;
int jour, annee;
char mois[10];
};
197
STRUCTURE COMME ÉTANT NOUVEAU TYPE
 En langage C, il est possible de définir des types nouveaux
synonymes de types existants (simple, structure,
pointeur,…) en utilisant le mot clé typedef.
 Les nouveaux types peuvent être utilisés ensuite comme les
types prédéfinis.
 Exemple:
typedef int entier; //définit un nouveau type appelé entier
entier n, tab[100]; //utilisation du type entier
typedef struct {
int jour, mois, annee;
} date;
198
date DateNaissance, Dtb[5]; //utilisation du type date