Présentation générale REPUBLIQUE TUNISIENNE

MINISTERE DE L’ENSEIGNEMENT SUPERIEUR ET DE LA RECHERCHE

SCIENTIFIQUE
ECOLE NATIONALE D’INGENIEURS DE SFAX
DEPARTEMENT GENIE CIVIL

Support de cours
Langage de programmation C

ELABORE PAR :
M. Atef BOUBAKER

Année Universitaire : 2022-2023

1
Présentation générale

Table des matières

PRESENTATION GENERALE ................................................................................ 6
I. DEFINITION DE LA PROGRAMMATION ....................................................................... 6
II. LANGAGE C ............................................................................................................... 6
III. Bibliothèques ............................................................................................................ 6
IV. ETAPES DE CREATION D’UN PROGRAMME C .......................................................... 7
4.1. L'édition du programme ............................................................................................... 7
4.2. La compilation.............................................................................................................. 7
4.3. L'édition de liens .......................................................................................................... 7

ELEMENTS DE BASE DU LANGAGE C .............................................................. 9

I. STRUCTURE D’UN PROGRAMME C ............................................................................. 9
II. COMMENTAIRES ..................................................................................................... 10
III. TYPES SIMPLES ........................................................................................................ 10
3.1. Type entier................................................................................................................. 10
3.2. Type réel .................................................................................................................... 10
IV. IDENTIFICATEURS ................................................................................................ 11
V. OPÉRATEURS STANDARDS ....................................................................................... 13
5.1. Les opérateurs de calcul ............................................................................................. 13
5.2. Les opérateurs d'assignation....................................................................................... 13
5.3. Les opérateurs d'incrémentation ................................................................................ 14
5.4. Les opérateurs de comparaison .................................................................................. 14
5.5. Les opérateurs logiques (booléens) ............................................................................. 15
5.6. Conversions de types.................................................................................................. 15
VI. PRIORITÉS DES OPÉRATEURS ................................................................................ 17
VII. OPERATIONS D’ENTREE/SORTIE ........................................................................... 18
7.1. Écriture formatée des données ................................................................................... 18
7.2. Lecture formatée des données.................................................................................... 19

STRUCTURES CONDITIONNELLES ................................................................. 22

I. STRUCTURES ALTERNATIVES .................................................................................... 22
1.1. Structures alternatives simples ................................................................................... 22
1.2. Structures alternatives imbriquées ............................................................................. 23
II. STRUCTURES SÉLECTIVES ......................................................................................... 24
LES STRUCTURES RÉPÉTITIVES ..................................................................... 26
I. STRUCTURE WHILE .................................................................................................. 26

2
Présentation générale
II. STRUCTURE DO – WHILE ....................................................................................... 27
III. STRUCTURE FOR ...................................................................................................... 27
FONCTIONS .............................................................................................................. 30
I. DÉFINITION ET DÉCLARATION .................................................................................. 30
1.1. Définition d’une fonction............................................................................................ 30
1.2. Déclaration d’une fonction ......................................................................................... 31
1.3. Types des fonctions .................................................................................................... 32
II. APPEL D’UNE FONCTION .......................................................................................... 32
2.1. Appel d’une fonction de type "void" ........................................................................... 32
2.2. Appel d’une fonction ayant un type de retour simple .................................................. 32
III. PASSAGE DES PARAMÈTRES..................................................................................... 33
IV. PORTÉE DES VARIABLES ....................................................................................... 35
TABLEAUX ................................................................................................................ 37
I. TABLEAUX À UNE DIMENSION ................................................................................. 37
1.1. Définition ................................................................................................................... 37
1.2. Déclaration et mémorisation ...................................................................................... 37
1.3. Initialisation et réservation automatique .................................................................... 38
1.4. Accès aux composantes .............................................................................................. 38
1.5. Affichage et saisie ...................................................................................................... 38
II. TABLEAUX À DEUX DIMENSIONS ............................................................................. 39
2.1. Définition ................................................................................................................... 39
2.2. Déclaration et mémorisation ...................................................................................... 39
2.3. Initialisation et réservation automatique .................................................................... 40
2.4. Accès aux composantes .............................................................................................. 41
2.5. Affichage et saisie ...................................................................................................... 42
ANNEXE A : ENONCES DES TRAVAUX DIRIGES .................................................................. 43

3
Présentation générale

Fiche élément constitutif

Objectifs généraux
L’étudiant sera apte à :
Résoudre des problèmes simples.
Développer des programmes corrects par rapport à leurs spécifications.
Utiliser le concept de décomposition fonctionnelle des problèmes.
Objectifs spécifiques
Comprendre le cycle de vie d’un programme.
Savoir les spécificités du langage C.
Ecrire des programmes utilisant des structures de contrôle alternatives et / ou
répétitives.
Ecrire des programmes utilisant la programmation procédurale.

Mots clés
Programme, Langage C, Fonction, Tableau

Contenu de la formation
Variables et Constantes
Types de données simples
Opérateurs et priorité
Actions élémentaires simples (Entrée / Sortie / Affectation)
Structures conditionnelles
Structures répétitives
Fonctions
Tableaux

Prérequis
Cette matière requiert que l'étudiant ait étudié la matière « Algorithmiques et structure de
données 1 ».

Bibliographie
La bible du programmeur C/C++, Jamsa, Reynald Goulet.
Programmation C, Gerhard WILLMS, Micro Application.
Exercices en langage C, Claude DELANNOY, Eyrolles.

Netographie
http://www.ltam.lu/Tutoriel_Ansi_C/ [consulté : 07 /04/2019]
https://www.rocq.inria.fr/secret/Anne.Canteaut/COURS_C/cours.pdf [consulté :
07 /04/2019]
http://www.areaprog.com/c/articles-2-les-fichiers [consulté : 07 /04/2019]
http://www.edu.upmc.fr/physique/master/LMMB/IMG/pdf/cours_C.pdf [consulté :
07 /04/2019]

4
Présentation générale

PRESENTATION GENERALE

Objectifs :
Expliquer la programmation avec le langage C.
Identifier quelques bibliothèques du langage C.
Identifier les étapes de création d’un programme C.

Eléments de contenu :
Définition de la programmation
Langage C
Bibliothèques
Etapes de création d’un programme C

5
Présentation générale

Chapitre 1

PRESENTATION GENERALE

I. DEFINITION DE LA PROGRAMMATION
La programmation est la traduction d’un algorithme développé pour la résolution d’un problème.
D’une manière générale, l’objectif de la programmation est de permettre l’automatisation d’un certain
nombre de tâches. Programmer c’est donc décomposer la tâche à automatiser sous la forme d’une
séquence d’instructions en utilisant des données adaptées.
Un langage de programmation est donc un moyen formel permettant de décrire des traitements (i.e.
des tâches à effectuer) sous la forme de programmes (i.e. des séquences l’instructions et des données
de haut niveau, c’est-à-dire compréhensibles par le programmeur) et pour lequel il existe un traducteur
permettant l’exécution effective des programmes par un ordinateur.
Les aspects syntaxiques (règles d’écriture des programmes) et sémantiques (définition des
instructions) d’un langage de programmation doivent être spécifiés de manière précise, généralement
dans un manuel de référence.
II. LANGAGE C
C’est un langage développé en 1970 par Dennis Ritchie aux Laboratoires Bell d'AT&T. Le succès des
années qui suivaient et le développement de compilateurs C ont rendu nécessaire la définition d'un
standard actualisé et plus précis.
En 1978, le duo Brian W. Kernighan / Dennis M. Ritchie a publié la définition classique du langage C
(connue sous le nom de standard K&R-C) dans un livre intitulé 'The C Programming Language'.
En 1983, le American National Standards Institute (ANSI) chargeait une commission de mettre au
point une définition explicite et indépendante de la machine pour le langage C. La seconde édition du
livre parue en 1988, respecte tout à fait le standard ANSI-C et elle est devenue par la suite la bible des
programmeurs en C.
III. Bibliothèques
La pratique en C exige l'utilisation de bibliothèques de fonctions. Une bibliothèque est un ensemble de
primitives et/ou de fonctions traitant des opérations homogènes.
Ces bibliothèques sont disponibles dans leur forme précompilée (extension ".LIB"). Pour pouvoir les
utiliser, il faut inclure des fichiers entête (header files d’extension ".H") dans les programmes. Ces
fichiers contiennent des prototypes des fonctions définies dans les bibliothèques et créent un lien entre
les fonctions précompilées et les programmes.
L'instruction #include insère les fichiers entête indiqués comme arguments dans le texte du
programme au moment de la compilation. La programmation C travaille avec différents types de
fichiers qui sont identifiés par leurs extensions :

Extension Description
.C fichiers source
.OBJ fichiers compilés (versions objet)
fichiers compilés et liés (versions
.EXE
exécutables)
.LIB bibliothèques de fonctions précompilées
.H fichiers en-tête (header files)

Après la compilation, les fonctions precompilées des bibliothèques seront ajoutées au programme pour
former une version exécutable.

6
Présentation générale

Exemples
<math.h> : Pour calculer des fonctions mathématiques courantes. La version du langage C sortie
en 1999 a ajouté de nombreuses fonctions mathématiques, en particulier pour converger avec la
norme CEI 559 dite aussi IEEE 754.
<stdio.h> : Fournit les fonctions d'entrée/sortie du langage C.
<stdlib.h> : Pour exécuter diverses opérations telles que la conversion, la génération de nombres
pseudo-aléatoires, l'allocation de mémoire, le contrôle de processus, la gestion de l'environnement
et des signaux, la recherche et le tri.
<string.h> : Pour manipuler les chaînes de caractères.
<time.h> : Pour convertir entre différents formats de date et d'heure.
IV. ETAPES DE CREATION D’UN PROGRAMME C
La manière de développer et d'utiliser un programme dépend naturellement de l’environnement de
programmation. Nous fournissons ici quelques indications générales (s'appliquant à n'importe quel
environnement) concernant ce que l'on pourrait appeler les grandes étapes de la création d'un
programme, à savoir : édition, compilation et édition de liens.
4.1. L'édition du programme
L'édition du programme (ou "saisie") consiste à créer, à partir d'un clavier, tout ou partie du texte d'un
programme : on parle alors de "programme source". En général, ce texte sera conservé dans un fichier
que l'on nommera fichier source d’exension ".c" ou ".cpp".
4.2. La compilation
Elle consiste à traduire le programme source (ou le contenu d'un fichier source) en langage machine,
en faisant appel à un programme nommé compilateur. Le résultat de compilation porte le nom du
fichier avec l’extension ".obj".
4.3. L'édition de liens
Le fichier objet créé par le compilateur n'est pas directement exécutable. Il lui manque, au moins, les
différents fichiers objet correspondants aux fonctions prédéfinies (on dit aussi "fonctions standard")
utilisées par le programme (comme printf, scanf, sqrt).
C'est effectivement le rôle de l'éditeur de liens que d'aller rechercher dans la "bibliothèque standard"
les modules objet nécessaires. Le résultat de l'édition de liens est ce que l'on nomme un "programme
exécutable", c'est-à-dire un ensemble autonome d'instructions en langage machine. Si ce programme
exécutable est rangé dans un fichier, il pourra ultérieurement être exécuté sans qu'il soit nécessaire de
faire appel à un quelconque composant de l'environnement de programmation.

Figure: Etapes de programmation

7
Eléments de base du langage C

ELEMENTS DE BASE DU LANGAGE C

Objectifs :
Définir les identificateurs et leurs types.
Identifier les opérateurs et l’ordre de priorité.
Expliquer les opérations d’entrées / sorties.

Eléments de contenu :
Structure d’un programme C
Commentaires
Types simples
Identificateurs
Opérateurs standards
Priorités des opérateurs
Opérations d’entrées / Sorties

8
Eléments de base du langage C

Chapitre 2

ELEMENTS DE BASE DU LANGAGE C

Les variables et les constantes sont les données principales qui peuvent être manipulées par un
programme. Les opérateurs contrôlent les actions que subissent les valeurs des données. Pour produire
de nouvelles valeurs, les variables et les constantes peuvent être combinées à l'aide des opérateurs dans
des expressions.

I. STRUCTURE D’UN PROGRAMME C

Comme n’importe quel programme de n’importe quel langage de programmation, un programme C
doit comporter une partie déclarative et une partie corps du programme.

Structure
[Les phrases < include > pour l’inclusion des bibliothèques]
[Définition des constantes]
[Déclaration des variables globales]
main ( ) {
[Déclaration des variables locales]
[Suite d’instructions]
return 0 ;
}

avec :
- include permet d’appeler une bibliothèque qui sera utilisée dans le corps du programme.
- Constante est un espace mémoire dont le contenu est inchangeable.
- Variable est un espace mémoire dont le contenu est changeable.
- Chaque instruction doit se terminer par un point virgule.
- Le mot clé main indique le debut du programme principal. Ce dernier est appelé en C fonction
principale ou de démarrage. La fonction main peut ne pas avoir de type, donc elle aura le type par
défaut int.
- L’instruction return 0 indique à l'environnement que le programme s'est terminé avec succès, sans
anomalies ou erreurs fatales. Cette instruction est obligatoire si la fonction main est de type int.

Exemple
Soit le programme C suivant qui permet d’afficher le message "Bonjour les amis".
#include <stdio.h>
main( ) {
printf("Bonjour les amis ");
return 0 ;
}
La pseudo instructiuon #iinclude <stdio.h> permet d’appeler la bibliothèque "stdio.h" qui assure les
opérations d’entrée/sortie (lecture/écritue).

Remarque
Le fonction main peut être de type void, et dans ce cas, il n’y aura pas de return.

Exemple
Soit le même exemple précédent qui permet d’utiliser le type void pour la fonction main.

9
Eléments de base du langage C

#include <stdio.h>
void main( ) {
printf("Bonjour les amis ");
}

II. COMMENTAIRES
Un commentaire est une indication qui ne sera pas compilée par le système et utilisé pour des
éventuelles explications. Il peut commencer par l’un des deux symboles suivants :
- '//' pour indiquer que le reste de la ligne est utilisé pour un commentaire.
- '/*' et se termine par les symboles '*/' pour indiquer que le texte du commentaire s’étale sur une ou
plusieurs lignes.
Exemples
// Ceci est un commentaire sur une seule ligne

/* Ceci est un deuxième

commentaire correct */

/* Ceci est /* évidemment */ défendu */

Remarque
Il est interdit d'utiliser des commentaires imbriqués.

III. TYPES SIMPLES

3.1. Type entier
Avant de pouvoir utiliser une variable, nous devons nous intéresser à deux caractéristiques de base :
- le domaine des valeurs possibles,
- le nombre d'octets qui est réservé pour une variable.

Le tableau suivant résume les caractéristiques de quelques types entiers de C:

Définition Domaine Domaine Nombre
minimal maximal d'octets
char -128 127 1
short -32768 32767 2
int -2147483648 2147483647 4
long -2147483648 2147483647 4

- Une variable du type char peut contenir tous les caractères alphabétiques majuscules et
minuscules, les chiffres de ‘0’ à ‘9’, ainsi que les caractéres spéciaux ( ? , [ , :,…).
- Le type short est codé sur 2 octets.
- Le type int est le type de base pour les calculs avec les entiers relatifs.
- Le type long est codé sur 4 octets. Comme une variable int occupe 4 octets, le type long devient
nécessaire seulement si on veut utiliser le même programme sur d'autres machines, sur lesquelles le
type standard des entiers est 2 octets.

3.2. Type réel

En C, on a le choix entre deux types de rationnels : float et double. Le tableau ci-dessous présente les
caractéristiques de chacun d’eux :

Définition Précision Mantisse Nombre d'octets

float simple 6 4
double double 15 8

10
Eléments de base du langage C
Remarque
En C, il n'existe pas de type spécial pour des variables logiques. Le type numérique peut être utilisé
pour exprimer des opérations logiques :
valeur logique faux <=> valeur numérique zéro
valeur logique vrai <=> toute valeur différente de zéro
Si l'utilisation d'une variable logique est indispensable, le plus naturel sera d'utiliser une variable du
type int.
Les opérations logiques en C retournent toujours des résultats du type int : 0 pour faux, 1 pour vrai.

IV. IDENTIFICATEURS
Un identificateur peut être un nom de variable, de constante ou de fonction. Un identificateur est
composé d'une suite de lettres (majuscules et minuscules), de chiffres et/ou du caratère ‘_’. Le
premier caractère doit être une lettre.
C distingue les majuscules et les minuscules, ainsi : 'Nom_de_variable' est différent de
'nom_de_variable'.
La longueur des identificateurs n'est pas limitée, mais C distingue seulement les 31 premiers
caractères.

Remarque
Il est déconseillé d'utiliser le symbole '_' comme premier caractère pour un identificateur, car il est
souvent employé pour définir les variables globales de l'environment C.

Exemples
Identificateurs corrects Identificateurs incorrects
nom1 1nom
nom_2 nom.2
_nom_3 -nom-3
Nom_de_variable Nom de variable
deuxieme_choix deuxième_choix
mot_francais mot_français

La déclaration d’un identificateur permet de préciser son type et son nom.

Exemple
int a ;
Ceci permet de réserver un emplacement mémoire statique relatif à l’identificateur pour contenir sa
valeur.
Les identificateurs peuvent être de l’un des trois types suivants :

a. Variables
Les variables contiennent les valeurs qui sont utilisées pendant l'exécution du programme. Les noms
des variables sont des identificateurs corrects.
Exemple
Soit le programme C suivant qui permet de calculer et afficher la somme de deux variables A (dont la
valeur est initialisée à 20) et B (dont la valeur est initialisée à 35).
#include <stdio.h>
main( ) {
int A ,B, Som ;
A=20 ;
B=35 ;
Som = A+B;
printf("la somme est : %d", Som) ;
return 0 ;
}
La déclaration des variables permet de :

11
Eléments de base du langage C
- introduire les variables qui seront utilisées,
- fixer leurs types,
- fixer les opérations autorisées,
- et réserver l’espace mémoire nécessaire.

Syntaxe
typeBase nomVar1, nomVar2, ..., nomVarN;

La déclaration d’une variable permet de réserver un emplacement mémoire succeptible de contenir une
valeur dont le type est compatible avec le typeBase déclaré. La valeur de cette variable pourra changer
au cours du temps d’exécution du programme.
Exemples
int x, X, nb_etd;
x=3 ;
X=7 ;
nb_etd=30 ;
float x1 ;
x1=2 ;
double Surface ;
Surface=23.45 ;

Il est possible d'initialiser les variables lors de leur déclaration :

int MAX = 1023;
char TAB = 'a';
float X = 1.05;

b. Constantes
En pratique, nous utilisons souvent des valeurs constantes pour des calculs, pour initialiser des
variables, pour les comparer aux variables, etc. Dans ces cas, l'ordinateur doit attribuer un type aux
valeurs constantes selon leurs valeurs. Pour pouvoir prévoir le résultat et le type exact des calculs, il
est important pour le programmeur de connaître les règles selon lesquelles l'ordinateur choisit les types
pour les constantes.

La déclaration d’une constante permet de réserver un emplacement mémoire succeptible de contenir

une valeur dont le type est déduit à partir de la valeur qui lui a été affectée. La valeur de cette
constante ne pourra plus changer au cours du temps d’exécution du programme.

Exemple
Constante Type attribué
a=1 entier
a=1.2 réel
a=’x’ caractère
a="abc" chaîne
… …

Une constante peut être définie de deux manières :

1. une constante globale qui sera définie avec la pseudo-instruction define
Syntaxe
#define nomConst valeur
Exemples
#define PI 3.14
#define resultat "reussi"

12
Eléments de base du langage C
2. une constante locale qui sera définie dans le corps du programme.
Syntaxe
const type nomConst=valeur ;
En utilisant le mot clé const, nous pouvons indiquer que la valeur d'une variable ne change pas au
cours d'un programme.
Exemple
const int MAX = 100;

Le type de la constante sera déduit à partir de sa valeur :

- si elle est numérique sans point décimal, elle sera traitée comme un entier de type int ;
- si elle est numérique avec point décimal, elle sera traitée comme un réel de type double ;
- si elle est placée entre deux côtes, elle sera traitée comme un caractère ;
- si elle est placée entre deux guillemets, elle sera traitée comme une chaîne de caractères ;
c. Fonctions
En C, une fonction, identifiée par un nom, est définie par un bloc d'instructions délimité par des
accolades { }. Cette notion sera traitée en détail dans le chapitre 7 : "Les fonctions".

V. OPÉRATEURS STANDARDS
Les opérateurs sont des symboles qui permettent de manipuler des objets (variables ou constantes).
C'est-à-dire les évaluer, effectuer des opérations, etc.
On distingue plusieurs types d'opérateurs :
- les opérateurs de calcul,
- les opérateurs d'assignation,
- les opérateurs d'incrémentation,
- les opérateurs de comparaison,
- les opérateurs logiques,

5.1. Les opérateurs de calcul

Les opérateurs de calcul permettent de modifier mathématiquement la valeur d'une variable ou
d’effectuer une opération sur une ou plusieurs variables.

Opérateur Description Effet Exemple Résultat

Met la valeur
opérateur Affecte une valeur
= x=7 7 dans la
d'affectation à une variable
variable x
opérateur Additionne deux
+ x+3 10
d'addition valeurs
opérateur de Soustrait deux
- x-3 4
soustraction valeurs
opérateur de Multiplie deux
* x*3 21
multiplication valeurs
opérateur de
/ Divise deux valeurs x/3 2.3333333
division
Affecte le reste de
opérateur de
% la division à une x%3 1
division
variable

5.2. Les opérateurs d'assignation

Ces opérateurs permettent de simplifier des opérations telles que ajouter une valeur dans une variable
et stocker le résultat dans la même variable. Une telle opération s'écrirait habituellement de la façon
suivante par exemple : x=x+2.
Avec les opérateurs d'assignation, il est possible d'écrire cette opération sous la forme suivante : x+=2.
Ainsi, si la valeur de x était 7 avant l’opération, elle sera de 9 après.

13
Eléments de base du langage C
Les autres opérateurs du même type sont les suivants :
Opération Effet
opd1 += opd2 additionne les valeurs des deux opérandes opd1 et opd2 et
stocke le résultat dans opd1.
opd1 -= opd2 soustrait la valeur de l’opérande opd2 de opd1 et stocke le
résultat dans opd1.
opd1 *= opd2 multiplie les valeurs des deux opérandes opd1 et opd2 et
stocke le résultat dans opd1.
opd1 /= opd2 divise la valeur de opd1 par opd2 et stocke le résultat dans
opd1.

5.3. Les opérateurs d'incrémentation

Ce type d'opérateur permet d’augmenter facilement ou diminuer d'une unité une variable. Ces
opérateurs sont très utiles pour les structures telles que les boucles, qui ont besoin d'un compteur
(variable qui augmente ou diminue de un en un).
Un opérateur de type x++ permet de remplacer des notations lourdes telles que x=x+1 ou bien x+=1.
Les opérateurs ++ et -- sont employés dans les cas suivants :
• incrémenter/décrémenter une variable. Dans ce cas il n'y a pas de différence entre la notation
préfixe (++I / --I) et la notation postfixe (I++ / I--).

Résultat (avec
Opérateur Description Effet Syntaxe x=7
initialement)
Augmente d'une x++ 8
++ Incrémentation
unité la variable ++x 8
Diminue d'une unité x-- 6
-- Décrémentation
la variable --x 6

• incrémenter/décrémenter une variable et en même temps affecter sa valeur à une autre variable.
Dans ce cas, la notation choisie (préfixe ou postfixe) va influencer sur le résultat de l‘affectation. En
effet,
- la notation préfixe modifie la valeur de la variable puis affecte la nouvelle valeur dans la
deuxième variable. Les deux opérandes seront alors modifiées toutes les deux.
- la notation postfixe affecte l’ancienne valeur de la première variable dans la deuxième puis
incrémente la première.

Dans ce cas, nous devons choisir entre la notation préfixe ou postfixe :

Opération Description Résultat
(avec x=7)
y = x++ passe d'abord la valeur de x à y puis y=7
incrémente x. x=8
y = x-- passe d'abord la valeur de x à y puis y=7
décrémente x. x=6
y= ++x incrémente x puis passe la nouvelle x=8
valeur à y. y=8
y = --x décrémente x puis passe la nouvelle x=6
valeur à y. y=6

5.4. Les opérateurs de comparaison

Les opérateurs de comparaison permettent de comparer deux opérandes ou une opérande avec une
valeur. Le résultat de la comparaison est numérique : 1 si la comparaison est correcte, autre valeur
sinon.

14
Eléments de base du langage C

Opérateur Description Effet Exemple Résultat

(avec x = 7)
Compare deux Retourne 1 si x
== opérateur
opérandes et vérifie x==3 est égale à 3,
d'égalité
leur égalité 0 sinon
Vérifie que l’opérande
opérateur Retourne 1 si x
gauche est strictement
< d'infériorité x<3 est inférieure à
inférieure à celle de
stricte 3, 0 sinon
droite.
Vérifie que l’opérande Retourne 1 si x
opérateur
gauche est inférieure est inférieure
<= d'infériorité x<=3
ou égale à celle de ou égale à 3,
large
droite. 0 sinon
Vérifie que l’opérande
opérateur de Retourne 1 si x
gauche est strictement
> supériorité x>3 est supérieure
supérieure à celle de
stricte à 3, 0 sinon
droite.
Vérifie que l’opérande Retourne 1 si x
opérateur de
gauche est supérieure est supérieure
>= supériorité x>=3
ou égale à celle de ou égale à 3,
large
droite. 0 sinon
Vérifie que l’opérande
Retourne 1 si x
opérateur de gauche est est
!= x!=3 est différente
différence différente de celle de
de 3, 0 sinon
droite.

5.5. Les opérateurs logiques (booléens)

Ce type d'opérateurs permet de vérifier si une ou plusieurs conditions sont vraies. Une condition peut
contenir une ou plusieurs sous conditions qui sont séparées par un de ces opérateurs. Le résultat final
de la condition globale est évalué à vrai ou à faux.

Opérateur Description Effet Syntaxe

Vérifie qu'une des
|| OU logique ((condition1)||(condition2))
conditions est vrai.
Vérifie que toutes
&& ET logique les conditions sont ((condition1)&&(condition2))
vrai.
Donne l’inverse
d'une condition
(retourne la valeur
NON
! 1 si la condition (!condition)
logique
vaut 0, 0 si elle
vaut 1) sans
changer sa valeur.

5.6. Conversions de types

La grande souplesse du langage C permet de mélanger des données de différents types dans une même
expression. Avant de faire des calculs, les données doivent être converties dans un même type. La
plupart de ces conversions se passent automatiquement, sans l'intervention du programmeur. Parfois il
est nécessaire de convertir une donnée dans un type différent de celui que choisirait la conversion
automatique, dans ce cas, nous devons forcer la conversion à l'aide d'un opérateur spécial "( )".

15
Eléments de base du langage C
a. conversions de type automatiques
Si un opérateur a des opérandes de différents types, les valeurs des opérandes seront converties
automatiquement dans un type commun.
Ces manipulations implicites convertissent en général des types plus petits en des types plus larges de
telle sorte qu’il n’aura pas de perte de précision.

Lors d'une affectation, la donnée à droite du signe d'égalité est convertie dans le type de la donnée à
gauche.

Exemple : Considérons le calcul suivant :

int I = 8;
float X = 12.5;
float Y;
Y = I * X;

Pour pouvoir être multiplié avec X, la valeur de I est convertie en float (le type le plus large entre le
int et le float). Le résultat de la multiplication est du type float.
Nous obtenons comme résultat : Y = 100.000000

Dans ce cas, il peut y avoir perte de précision si le type de la destination est plus faible que celui de la
source.

Exemple : Considérons le calcul suivant :

int I = 3;
float X = 12.5;
int Y;
Y = I * X;
Nous obtenons comme résultat : Y = 37 au lieu de 37.5

Règles de conversions automatiques

Les conversions automatiques utilisées lors d'une opération arithmétique peuvent suivre l’une des
règles suivantes :
Les types char et short sont convertis en int.
char int
short int

Le type entier est converti dans le type du rationnel.

int float

Pour les réels, l'ordinateur choisit le plus large des deux types selon l'échelle suivante :
float double

Lors d'une affectation, le résultat est toujours converti dans le type de la destination. Si ce type est
plus faible, il peut y avoir une perte de précision.

Exemple
Observons les conversions nécessaires lors d'une simple division :
int X;
float A=12.48;
char B=4;
X=A/B;
A est un float, B est un int. A/B doit donner un float après avoir convertir B en float. Lorsque le
resultat float est affecté dans la variable X qui est int, les chiffres après la virgule seront perdu, ce qui
conduit au résultat X=3.

16
Eléments de base du langage C
b. conversions de type forcées
Ce type de conversion est appelé aussi "casting" ou "transtypage".
Il est possible de convertir explicitement une valeur en un type quelconque en forçant la
transformation à l'aide de l’opérateur ( ).

Syntaxe
(Type) Expression ;

Exemple
Si nous voulons diviser deux variables du type entier et si nous voulons avoir un résultat de type réel,
nous devons convertir la valeur de l'une des deux opérandes en float. Automatiquement C convertira la
valeur de l'autre opérande en float et effectuera une division réelle :
char A=3;
int B=4;
float C;
C = (float)A/B;
La valeur de A est explicitement convertie en float. La valeur de B est automatiquement convertie en
float. Le résultat de la division (type rationnel, valeur 0.75) est affecté à C.
Résultat: C=0.75

Remarque
Les types de A et de B restent inchangés ; seulement les valeurs utilisées dans les calculs sont
converties.

VI. PRIORITÉS DES OPÉRATEURS

Lorsqu'on associe plusieurs opérateurs dans une même expression, il faut que le système sache dans
quel ordre les traiter. Voici donc, dans l'ordre (prédéfini) décroissant, les priorités de tous les
opérateurs :
Priorité Opérateurs
+++++++++ ()
++++++++ -- ++ !
+++++++ * / %
++++++ + -
+++++ < <= >= >
++++ == !=
+++ &&
++ ||
+ = += -= *= /= %=

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

Pour les opérateurs unaires (!,++ et --) et pour les opérateurs d'affectation (=,+=,-=,*=,/=,%=),
l'évaluation se fait de droite à gauche dans l'expression.

Exemple
L’instruction a = b = c = 1; correspond à a = (b = (c = 1));

17
Eléments de base du langage C
VII. OPERATIONS D’ENTREE/SORTIE
La bibliothèque standard <stdio.h> contient un ensemble de fonctions qui assurent la communication
de la machine avec le monde extérieur.

7.1. Écriture formatée des données

La fonction printf est utilisée pour transférer du texte, des valeurs de variables ou des résultats
d'expressions vers l'écran.

Syntaxe
printf("format",Expr1,Expr2, ..., ExprN ) ;
Avec :
format : format de représentation.
Expri : variables et expressions dont les valeurs sont à afficher.

La partie "format" est en fait une chaîne de caractères qui peut contenir :
- du texte,
- des séquences d'échappement (\n,\t,\a,\b),
- et/ou des spécificateurs de format (%d, %f, …).

Les spécificateurs de format pour printf sont résumés dans le tableau suivant :
Symbole Type Description
%d int entier relatif
%u int entier naturel (unsigned)
%o int entier exprimé en octal
%x int entier exprimé en hexadécimal
%c int ou char caractère
%f double réel en notation décimale
%e double réel en notation scientifique
%s char* chaîne de caractères

Pour chaque expression à évaluer et afficher, il doit correspondre un spécificateur de format.

Le spécificateur de format doit être inséré dans le format là où on veut afficher le résultat d’évaluation
de l’expression correspondante.

Le format peut être écrit dans l’un des trois cas suivants :
- affichage d’un message.
Exemple : printf ("voici ma premiere ligne") ;
- affichage d’un message et d’une variable.
Exemple : printf ("le resultat est %d ", R ) ;
- affichage de plusieurs éléments (messages, varaibles et expressions).
Exemple : printf ("la somme de %d et %d est égale à %d", A, B, A+B) ;

Exemple 1
Soit une variable B contenant un caractère. Le format %c permet d’afficher le contenu de la variable
alors que le format %d permet d’afficher le code ASCII du caractère correspondant.
char B = 'A';
printf("Le caractère %c a le code %d !\n", B, B);

Cette séquence affiche sur l'écran : Le caractère A a le code 65 !

18
Eléments de base du langage C
Exemple 2
Soit une variable B de type caractère initialisée à une valeur numérique. L’affichage du caractère
correspondant à cette valeur sera calculé automatiquement avec des soustractions successives (de la
valeur 256) jusqu’à obtenir une valeur contenue entre 0 et 255.
char A=67;
char B = 355;
printf("Le caractère %c a le code %d !\n", A, A);
printf("Le caractère %c a le code %d !\n", B, B);
Cette séquence affiche sur l’écran :
Le caractère C a le code 67 !
Le caractère c a le code 99 !

Remarques
- L’écriture "printf(" %10 f \n" ,x) ; " désigne qu’il y aura affichage d’un float de 10 caractères dont
le point décimal en fait partie.
- L’écriture "printf(" %10.3 f \n" ,x) ; " désigne qu’il y aura affichage d’un float de 10 caractères
dont 3 sont des chiffres après la virgule et le point décimal en fait partie.

7.2. Lecture formatée des données

La fonction scanf est la fonction symétrique à printf qui permet de saisir des valeurs des données. Elle
nous offre pratiquement les mêmes conversions que printf, mais en sens inverse.

Syntaxe
scanf("format", var1, var2, ... , varN);
Avec:
format : format de lecture des données.
vari : variables auxquelles les données seront attribuées.

La fonction scanf reçoit ses données à partir du clavier.

La chaîne de format détermine comment les données reçues doivent être interprétées.
Les données reçues correctement sont mémorisées successivement dans l’ordre aux variables
indiquées par vari.

Les spécificateurs de format pour scanf sont les mêmes que ceux de la fonction printf.

Exemple 1
char mois[10] ;
scanf("%s ", mois);

Si la variable à saisir est numérique, il faut faire précéder son nom par l’opérateur & pour désigner son
adresse.

Exemple 2
Soient les deux instructions suivantes:
int JOUR, MOIS, ANNEE;
scanf("%d %d %d", &JOUR, &MOIS, &ANNEE);

L’instruction scanf lit trois entiers relatifs. Les valeurs sont attribuées respectivement aux trois
variables JOUR, MOIS et ANNEE.
Pour saisir les trois valeurs, l’utilisateur pourra utiliser le retour chario après la saisie de chaque valeur.
Il pourra aussi les séparer par des tabulations ou des simples espaces comme suit :

12 7 2006 ou 12 007 2006 ou 12 7 2006

19
Eléments de base du langage C
où la variable JOUR va contenir la valeur 12, la variable MOIS va contenir la valeur 7 et la variable
ANNEE va contenir la valeur 2006.

Exemple 3
Soient les instructions suivantes :
int A,B;
scanf("%4d %2d", &A, &B);
Le nombre précisé dans le %d indique le nombre de chiffres que doit contenir l’entier à saisir. En
effet, si nous saisissons le nombre 1234567, nous obtiendrons les affectations suivantes : A=1234 et
B=56.
Le chiffre 7 sera gardé pour la prochaine instruction de lecture.

20
Structures conditionnelles

STRUCTURES CONDITIONNELLES

Objectifs :
Identifier les différents types de structures alternatives.
Expliquer l’expression conditionnelles.

Eléments de contenu :
Structure alternatives
Expressions conditionnelles
Structures sélectives

21
Structures conditionnelles

Chapitre 3

STRUCTURES CONDITIONNELLES

I. STRUCTURES ALTERNATIVES

1.1. Structures alternatives simples

Syntaxe de la forme réduite

if ( expression )
blocInstructions
- Si l'expression fournit une valeur différente de zéro, alors le blocInstructions est exécuté.
- Si l'expression fournit une valeur égale à zéro, alors le blocInstructions ne sera pas exécuté.

Syntaxe de la forme complète

if ( expression ) {
blocInstructions1
}
else {
blocInstructions2
}
- Si l'expression fournit une valeur différente de zéro, alors le blocInstructions1 est exécuté.
- Si l'expression fournit une valeur égale à zéro, alors le blocInstructions2 est exécuté.

La partie expression peut désigner :

- une variable d'un type numérique,
- ou une expression fournissant un résultat numérique.

La partie blocInstructions peut désigner :

- un bloc d'instructions compris entre accolades dont chaque instruction est terminée par un point-
virgule,
- ou une seule instruction terminée par un point-virgule.

Exemples
1-
if (N>0)
printf ("N est positif \n");
2-
if (a > b)
max = a;
else
max = b;
3-
if (N != 0)
printf ("%d n’est pas nul \n",N);
else
printf ("%d est nul \n",N);

Cette instruction est équivalente à :

22
Structures conditionnelles

if (N )
printf ("%d n’est pas nul \n",N);
else
printf ("%d est nul \n",N);

1.2. Structures alternatives imbriquées

Les blocs d’instructions blocInstructions1 et/ou blocInstructions2 peuvent être, à leur tour, une
structure alternative.

Syntaxes
if ( expression1 ) ou if ( expression1 ) {
if ( expression2 ) { blocInstructions1
blocInstructions11 }
} else
[else { if ( expression2 ) {
blocInstructions12 blocInstructions21
} }
] [else {
[else { blocInstructions22
blocInstructions2 }
} ]
]

Exemple 1
Soient les deux parties des programmes suivantes qui permettent d’afficher le signe d’un nombre N.
Les deux parties sont équivalentes.
if (N>= 0) if (N> 0)
if(N>0) printf ("%d est positif \n",N);
printf ("%d est positif \n",N); else
else if(N<0)
printf ("%d est nul \n",N); printf ("%d est négatif \n",N);
else else
printf ("%d est négatif \n",N); printf ("%d est nul \n",N);

Exemple 2
Soit la partie d’un proramme suivante qui permet de tester si une valeur donnée N est à la fois multiple
de de 2 et 5.

if (N%2= =0 && N%5= =0)

printf (“le nombre est à la fois multiple de 2 et 5 ") ;
else
printf (“le nombre n’est pas à la fois multiple de 2 et 5 ") ;
ou
if (N%2= =0) {
if(N%5= =0)
printf (“le nombre est à la fois multiple de 2 et 5 ") ;
}
else
printf (“le nombre n’est pas à la fois multiple de 2 et 5 ") ;
avec l’obligation des deux accolades pour que le else se refère au premier if.

23
Structures conditionnelles

Remarque
En C une partie else est toujours liée au dernier if qui ne possède pas de partie else. Pour éviter des
confusions et pour forcer une certaine interprétation d'une expression, il est recommandé d'utiliser les
accolades { }.

II. STRUCTURES SÉLECTIVES

L’instruction switch définit un aiguillage qui permet d’effectuer un branchement à une étiquette en
fonction de la valeur d’une expression.
Syntaxe
switch (expression) {
[ case etiq1 : listeInstructions1 ; break ; ]
[ case etiq2 : listeInstructions2 ; break ; ]
….
[ case etiqn : listeInstructionsN ; break ; ]
[ default : listeInstructions ]
}
Avec :
- Les étiquettes de cas etiqi doivent être des expressions de type scalaire (entier, caractère, logique,
énumération).
- Une fois le branchement est éffectué, l’exécution se poursuit, par défaut, jusqu’à la fin du bloc
switch. L’instruction d’échappement break permet de forcer la sortie du bloc.
- Le bloc default n'est pas obligatoire. Il sera exécuté si la valeur saisie ne correspond à aucun des
cas.

Exemple
Soit le programme C suivant qui permet d’afficher le nom du jour selon son numéro donné par
l’utilisateur :
#include<stdio.h>
main() {
int jour;
printf("donner un numéro de jour");
scanf("%d",&jour);
switch (jour) {
case 1 : printf (" Lundi\n"); break ;
case 2 : printf (" Mardi\n");
case 3 : printf (" Mercredi\n"); break ;
case 4 : printf (" Jeudi\n");
case 5 : printf (" Vendredi\n");
case 6 : printf (" Samedi\n");
case 7 : printf (" Dimanche\n");
default : printf (" jour erroné\n");
}
return 0;
}

24
Structures répétitives

STRUCTURES REPETITIVES

Objectifs :
Identifier les différents types de structures répétitives.
Expliquer l’utilisation des structures répétitives.

Eléments de contenu :
Structure while
Structur do while
Structure for

25
Structures répétitives
Chapitre 4

LES STRUCTURES RÉPÉTITIVES

Théoriquement, les structures répétitives sont interchangeables. Mais il est absolument recommandé
de choisir toujours la structure la mieux adaptée au cas à traiter.

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

Syntaxe
while ( expression ) {
blocInstructions
}
Avec :
- Tant que l'expression fournit une valeur différente de zéro, le blocInstructions est exécuté.
- Si l'expression fournit la valeur zéro, l'exécution continue avec l'instruction qui suit le
blocInstructions (après l’accolade fermante).
- Le blocInstructions peut être exécuté zéro ou plusieurs fois.

La partie expression peut désigner :

♦ une variable d'un type numérique,
♦ une expression fournissant un résultat numérique.

La partie blocInstructions peut désigner :

♦ un bloc d'instructions compris entre accolades et dont chaque instruction se termine par un
point virgule,
♦ une seule instruction terminée par un point-virgule.

Exemple
Soit le programme qui permet d’afficher les nombres de 0 à 9 suivant :
#include <stdio.h>
main() {
int I = 0;
while (I<10) {
printf("%d \n", I);
I++;
}
return 0;
}
Ce même programme pourra être écrit comme suit :
#include <stdio.h>
main() {
int I;
I = 0;
while (I<10)
printf("%d \n", I++);
return 0;
}

26
Structures répétitives

II. STRUCTURE DO – WHILE

La structure do-while est semblable à la structure Répéter .. Jusqu’à en algorithmique.
La structure do-while évalue la condition après avoir exécuté le bloc d'instructions.

Syntaxe
do {
blocInstructions
} while ( expression );

Le blocInstructions est exécuté au moins une fois et aussi longtemps que l'expression fournit une
valeur différente de zéro.

Une application typique de do-while est la saisie d’une donnée qui doit remplir une certaine condition.

Exemple
Ecrire un programme qui permet de saisir une valeur entière comprise entre 1 et 10.
#include <stdio.h>
main() {
int N;
do {
printf("donner un nombre compris entre 1 et 10 :");
scanf("%d", &N);
}while (N<1 || N>10);
}

III. STRUCTURE FOR

La structure Pour en langage algorithmique est utilisée pour faciliter la programmation de boucles de
comptage. La structure for en C est plus générale et beaucoup plus puissante.
Syntaxe
for ( expr1 ; expr2 ; expr3 ) {
blocInstructions
}

Avec :
- expr1 est évaluée une seule fois avant d’entrer à la boucle. Elle est utilisée pour initialiser les
données de la boucle.
- expr2 est évaluée avant chaque réexécution de la boucle. Elle est utilisée pour décider si la boucle
sera exécutée ou non.
- expr3 est évaluée à la fin de chaque exécution de la boucle. Elle est utilisée pour réinitialiser une
ou quelques données de la boucle.

Si le bloc d’instructions contient une seule instruction, les accolades peuvent être alors omises.

Exemple 1
Ecrire un programme qui permet d’afficher le carré des entiers positifs inférieurs à 10.
#include <stdio.h>
main() {
int I;
for (I=0 ; I<10 ; I++)
printf("Le carré de %d est %d \n", I, I*I);
return 0 ;
}

27
Structures répétitives

Remarque
Les parties expr1, expr2 et expr3 peuvent contenir plusieurs sous instructions qui doivent être séparées
par des virgules.

Exemple 2
Ecrire un programme qui permet d’afficher la somme des entiers positifs inférieurs ou égal à 100.
#include <stdio.h>
main() {
int n, som;
for (som=0, n=1; n<=100; n++)
som+=n;
printf("La somme des nombres de 1 à 100 est %d\n", som);
return 0 ;
}

Remarque
On peut déclarer la variable à l’intérieur de l’instruction for au moment de son initialisation.

Exemple
L’instruction "for(int i=0 ;i<=10 ;i++) { }" est équivalente aux deux instructions suivantes: "int i;
for( i=0 ;i<=10 ;i++) { }".

28
Tableaux

FONCTIONS

Objectifs :
Identifier les différents types de structures alternatives.
Expliquer l’expression conditionnelles.

Eléments de contenu :
Définition et declaration
Appel d’une fonction
Passage des paramètres
Portée des variables

29
Tableaux

Chapitre 5

FONCTIONS

Chaque programme comporte au moins une fonction qui est la fonction main. Une fonction est un
regroupement de variables et d’instructions identifiable par un nom et ayant un objectif bien
déterminé. Les fonctions en C correspondent aux fonctions et procédures en langage algorithmique.

I. DÉFINITION ET DÉCLARATION
1.1. Définition d’une fonction
La définition d’une fonction détermine l’entête de la fonction et les instructions qui la composent.
L’entête comporte le type du résultat retourné, l’identifiant ou le nom de la fonction et la déclaration
des paramètres entre parenthèses.
Syntaxe
typeFonct nomFonct (typePar1 par1 , typePar2 par2 , …) {
// déclaration des variables locales
// instructions
[ return (resultat);]
}
Avec :
- typeFonct : le type du résultat retourné par la fonction. Il peut être void ou un autre type simple.
- nomFonct : l’identifiant de la fonction qui doit être unique.
- typePari pari : les paramètres formels sont les variables de communication entre la fonction et
le programme appelant. Ils ne sont visibles et connus qu’à l’intérieur de la fonction.
- return(resultat) : c’est une instruction qui n’existe que si le type de la fonction est différent de
void. Le resultat retourné doit avoir le même type qie celui de la fonction.

Exemple1
Soit la fonction carre suivante qui permet de chercher le carré d’un réel donné :
float carre(float a) {
float c;
c=a*a ;
return c ;
}
Cette fonction n’affiche pas le résultat, mais elle le fait retourner comme résultat dans son nom.

Exemple2
Soit la fonction somme suivante qui permet de chercher la somme de deux réels donnés :
float somme(float a, float b) {
float s=a+b ;
return s ;
}

a. Variables locales
Une variable est dite locale si elle est définie à l'intérieur d’une fonction. Elle n'est accessible qu'à
l'intérieur de l'environnement de sa déclaration.
On peut utiliser le même nom à une variable locale déclarée à l'intérieur d'une autre fonction.
Autrement dit, deux variables locales de deux fonctions différentes peuvent avoir le même nom sans
pour autant désigner la même variable.

30
Tableaux

b. Variables globales
Les variables globales sont déclarées au début du fichier, à l’extérieur de toutes les fonctions et seront
disponibles à toutes les fonctions du programme.
En général, les variables globales sont déclarées immédiatement derrière les instructions d’inclusion
des bibliothèques.

c. Paramètres formels
Les paramètres formels (ou fictifs) sont les variables déclarées dans l’entête de fonction à définir. Ils
sont utilisées pour la communication entre la fonction appelante et la fonction appelée.
Ce sont des variables créées au moment de l'appel d'une fonction pour recevoir les valeurs envoyées de
la part de la fonction appelante. Ces paramètres seront supprimés de la mémoire dès que la fonction
aura terminé son traitement.

d. Paramètres réels
Les paramètres réels sont les variables déclarées dans la fonction appelante. Ils contiennent des valeurs
à transférer à la fonction au moment de l'appel.
Les paramètres réels sont transférés dans le même ordre respectif de déclaration des paramètres
formels. Ils doivent être dans le même ordre et respectivement dans le même type.

Exemple1
Pour l’exemple qui a permis de calculer le carré d’un réel, on pourra avoir la fonction main suivante :
main ( ) {
float y ;
scanf ( ″ %f ″, &y) ;
float r=carre (y) ;
printf("le carré de %f est : %f ″,y,r) ;
return 0 ;
}

Exemple2
Pour l’exemple qui a permis de calculer la somme de deux réels, on pourra avoir la fonction main
suivante :
main ( ) {
float x,y ;
scanf ( ″ donner la première valeur : %f ″, &x) ;
scanf ( ″ donner la deuxième valeur : %f ″, &y) ;
float r=somme (x,y) ;
printf("la somme de %f et %f est : %f ″,x,y,s) ;
return 0 ;
}

1.2. Déclaration d’une fonction

La déclaration d’une fonction détermine seulement le type du résultat retourné, l’identifiant ou le nom
de la fonction et les types des paramètres entre parenthèses. La déclaration ne contient pas de corps de
la fonction.
La déclaration est utilisée :
- avant la fonction appelante, et
- lorsque la fonction appelée est placée après la fonction main (ou la fonction appelante).

La déclaration de la fonction pourra être :

- locale par rapport à la fonction appelante (placée juste avant la fonction appelante),
- ou globale par rapport à toutes les fonctions (placée avant toutes les fonctions).

31
Tableaux

Syntaxe
typeFonct nomFonct (typePar1 , typePar2 , …) ;

La déclaration d’une fonction est une instruction en soit, et donc elle doit se terminer par un point
virgule.

1.3. Types des fonctions

Une fonction peut avoir l’un des types suivants :
- void si elle correspond à la notion de procédure en algorithmique. Et dans ce cas, aucun résultat ne
sera retourné par la fonction.

Exemple
Ecrire une fonction Affiche qui permet d’afficher le carré d’un nombre quelconque.
void affiche ( float x ) {
printf ( ″ Le carré de %f est %f ″, x, x*x) ;
}

- un type simple si elle correspond à la notion de fonction en algorithmique. Et dans ce cas, la

fonction doit faire retourner un résultat de type compatible avec son type.

Exemple
Ecrire une fonction Fact qui permet de calculer le factoriel d’un nombre entier.
int fact ( int n) {
int i, f = 1 ;
for ( i=1 ; i<=n ; i++)
f *= i ;
return f ;
}

II. APPEL D’UNE FONCTION

Une fonction peut être appelée dans la fonction main ou dans une autre fonction.
2.1. Appel d’une fonction de type "void"
L’appel d’une fonction de type void se fait à l’aide du nom de la fonction suivi des paramètres réels
entre parenthèses.

Syntaxe
nomFonct (parRéel1 , parRéel2, …) ;

Exemple
Ecrire un programme C qui permet d’appeler la fonction affiche précédente.
#include<stdio.h>
main ( ) {
float a;
scanf ( ″ %f ″, &a) ;
affiche (a);
return 0 ;
}

2.2. Appel d’une fonction ayant un type de retour simple

Pour les fonctions ayant un type de retour simple, l’appel peut être fait par l’un de trois modes, selon
le besoin :

32
Tableaux
- dans une affectation,
- dans un affichage,
- ou dans une expression.
a. Appel de fonction dans une affectation
Ce mode d’appel permet d’affecter le résultat retourné par la fonction dans une variable qui doit être
de même type ou d’un type compatible.

Exemple
Ecrire un programme C qui permet d’appeler la fonction fact précédente dans une affectation.
main ( ) {
int a, facta ;
scanf ( " %d ", &a) ;
facta = fact (a);
printf ( "Le factoriel de %d est %d ", a, facta) ;
return 0 ;
}

b. Appel de fonction dans un affichage

Ce mode d’appel permet d’appeler la fonction dans une instruction d’affichage. Le résultat retourné
par la fonction sera alors affiché.
Le spécificateur de format utilisé dans l’affichage doit être de même type ou d’un type compatible
avec celui du résultat de la fonction.

Exemple
Ecrire un programme C qui permet d’appeler la fonction fact précédente dans une instruction
d’affichage.
main ( ) {
int a ;
scanf (" %d ", &a) ;
printf (" Le factoriel de %d est %d ", a, fact(a)) ;
return 0 ;
}

c. Appel de fonction dans une expression

Dans ce type d’appel, le résultat retourné par la fonction sera évalué dans l’expression.

Exemple
Ecrire un programme qui permet de calculer la combinaison de p parmi n.
main ( ) {
int n, p ;
float cnp ;
do {
printf(“donner deux valeurs entières :”);
scanf ( ″ %d%d ″, &n,&p) ;
} while ((p>n)||(p<0)) ;
cnp = fact (n)/(fact(p)*fact(n-p));
printf ( ″ La combinaison de %d parmi %d est %f ″, p, n, cnp) ;
return 0 ;
}

III. PASSAGE DES PARAMÈTRES

Une fonction ayant des paramètres formels a besoin de valeurs réelles correspondantes pour pouvoir
s’exécuter. Ces valeurs lui seront transmises au moment de son appel à travers les paramètres réels.

33
Tableaux
Cette transmission s’appelle passage de paramètres par valeurs qui consiste à copier le contenu des
paramètres réels dans les paramètres formels correspondants.
Dans ce cas, les paramètres formels contiendront une copie des paramètres réels.
Le passage par valeur ne permet pas à la fonction appelée de modifier directement la valeur du
paramètre réel. Elle ne peut modifier que sa propre copie temporaire.

Exemple : Ecrire une fonction echange qui permet d’échanger les valeurs de deux entiers. Ecrire le
programme C qui permet d’appeler cette fonction.
#include< stdio.h>
main ( ) {
// Déclaration de la fonction echange
void echange (int , int) ;
int n = 10 , p = 20 ;
printf ( ″ Avant appel : %d %d \n ″, n, p) ;
echange ( n,p) ;
printf ( ″ Après appel : %d %d \n ″, n, p) ;
return 0 ;
}
// Définition de la fonction echange
void echange (int a, int b) {
int c ;
printf ( ″ Début échange : %d %d \n ″, a, b) ;
c=a;a=b;b=c;
printf ( ″ Fin échange : %d %d \n ″, a, b) ;
}

Si on a besoin de faire retourner plusieurs valeurs, ou on a besoin de modifier les valeurs des
paramètres réels de la fonction appelante, il faut alors utiliser le principe de passage par adresse.
Dans ce cas, les paramètres de la fonction doivent être utilisés sous forme d’adresses et non pas de
valeurs. La fonction appelante fournie alors l’adresse de son paramètre pour que la fonction appelée
aura la possibilité de travailler sur la même case mémoire de la variable.
Les paramètres de la fonction seront alors des pointeurs.

Exemple : La fonction echange qui permet d’échanger deux valeurs a été définie avec des paramètres
passés par valeurs. Elle ne peut pas modifier les paramètres n et p du programme appelant puisqu’elle
échange seulement des copies de n et p.
Le moyen d’obtenir le résultat voulu est de faire en sorte que le programme appelant passe en
paramètres des pointeurs sur les valeurs à modifier.
#include< stdio.h>
main ( ) {
void echange (int *, int *) ;
int n = 10 , p = 20 ;
printf ( ″ Avant appel : %d %d \n ″, n, p) ;
echange ( &n, &p) ;
printf ( ″ Après appel : %d %d \n ″, n, p) ;
return 0 ;
}
// Définition de la fonction echange
void echange (int* a, int* b) {
int c ;
printf ( ″ Début échange : %d %d \n ″, *a, *b) ;
c = *a ; *a = *b ; *b = c ;
printf ( ″ Fin échange : %d %d \n ″, *a, *b) ;
}

34
Tableaux

IV. PORTÉE DES VARIABLES

Un bloc d’instructions est encadré d’accolades et composé de deux éventuelles parties :
- déclarations locales au bloc,
- et ensemble d’instructions formant le corps du bloc.
Les variables déclarées dans un bloc d’instructions sont visibles uniquement à l’intérieur de ce bloc.
On dit que ce sont des variables locales à ce bloc.

Syntaxe
{
// déclarations locales
// instructions
}
Ainsi, un bloc d’instructions d’une fonction ou d’une commande if, while, do ou for peut contenir des
déclarations locales de variables et même des fonctions.
Exemple
Ecrire une fonction somme qui permet d’afficher la somme des n premiers nombres positifs.
#include< stdio.h>
void somme (int n) {
if (n>0){
int i ;
int s=0;
for (i = 1 ; i<=n ; i++)
s+=i;
printf(“la somme est : %d”,s);
}
else
printf(" la valeur de n est négative ") ; }
Les variables s et i sont déclarées à l’intérieur d’un bloc conditionnel. Si la condition n’est pas
remplie, elles ne seront pas définies. A la fin du bloc conditionnel, elles disparaissent.

Remarque
Les variables locales des fonctions forment un bon exemple pour expliquer leur visibilité par rapport à
l’ensemble du programme. En effet, une variable locale n’est visible qu’à l’intérieur du bloc du corps
de la fonction. Ailleur, cette variable n’existe pas et n’est plus connue.

35
Tableaux

TABLEAUX

Objectifs :
Définir la notions d’un tableau.
Expliquer l’utilisation des tableaux.

Eléments de contenu :
Tableaux à une dimension
Tableaux à deux dimensions

36
Tableaux

Chapitre 6

TABLEAUX

I. TABLEAUX À UNE DIMENSION

1.1. Définition
Un tableau uni-dimensionnel A est une variable structurée formée d'un nombre de variables simples de
même type. Ces dernières sont appelées les composantes du tableau. Le nombre de composantes N est
appelé la dimension du tableau.

Représentation schématique
A:
0 1 N-1

N composantes

Dans le langage C, les indices des cases commencent par 0. la dernière case possède l’indice N-1. "

1.2. Déclaration et mémorisation

a. Déclaration de tableaux en C
La déclaration d’un tableau nécessite la précision du type des éléments qu’il contiendra et le nombre
de ces éléments (dimension).
Syntaxe
TypeSimple NomTableau [Dimension];

Exemples
int A[10];
float B[100];
char C[30], D[100];

b. Mémorisation
En C, n’importe quel tableau occupe un espace mémoire contigu capable de mémoriser tous les
éléments du tableau. Le nom du tableau désigne toujours l’adresse du premier élément. Les adresses
des autres composantes sont calculées (automatiquement) relativement à cette adresse en utilisant leurs
indices.

Exemple
Soit un tabeau A contenant l’ensemble des valeurs entières suivantes : 10, 20, 30, 40, 50.

1E06 1E0A 1E0E 1E12 1E16

10 20 30 40 50
A 1E06
0 1 2 3 4

Pour accèder à la valeur de la case numéro 3, il y aura calcul de son adresse qui est égale à
(1E06+3*taille de l’entier).

37
Tableaux

1.3. Initialisation et réservation automatique

a. Initialisation
Lors de la déclaration d'un tableau, on peut initialiser les composantes du tableau, en indiquant la liste
des valeurs respectives entre accolades.
Syntaxe
TypeSimple NomTableau [N]={val1, val2, …, valN};

Exemples
int A[5] = {10, 20, 30, 40, 50};
float B[4] = {-1.05, 3.33, 8.5, -12.3};
int C[10] = {1, 0, 0, 1, 1, 1, 0, 1, 0, 1};

Il faut évidemment veiller à ce que le nombre de valeurs dans la liste corresponde à la dimension du
tableau.
Si la liste ne contient pas assez de valeurs pour toutes les composantes, les composantes restantes
seront initialisées automatiquement par la valeur par défaut du type du tableau.
Si le nombre d’éléments dans la liste dépasse la dimension du tableau, le système génére alors une
erreur.

b. Réservation automatique
Si la dimension n'est pas indiquée explicitement lors de l'initialisation, alors l'ordinateur réserve
automatiquement le nombre d'octets nécessaires pour contenir toutes les valeurs indiquées entre
accolades.
Syntaxe
TypeSimple NomTableau[ ]={val1, val2, …, valN};

Exemples
int A[ ] = {10, 20, 30, 40, 50};
// réservation de 5 cases contenant des entiers.
float B[ ] = {-1.05, 3.33, 8.5, -12.3};
// réservation de 4 cases contenant des réels.

1.4. Accès aux composantes

L’accès à une case d’un tableau se fait par l’opération d’indiçage. Cette opération consiste à indiquer
le nom du tableau suivi par l’indice de l’élément à référencer entre deux crochets.
Syntaxe
NomTableau[indice]

Exemple
Soit un tableau A déclaré comme suit :
int A[ 5 ] = {1200, 2300, 3400, 4500, 5600} ;
- L’écriture A[0] désigne le contenu de la première case du tableau dont l’indice est égal à 0.
- L’écriture A[1] désigne le contenu de la deuxième case du tableau dont l’indice est égal à 1.
-…
- L’écriture A[4] désigne le contenu de la dernière case du tableau dont l’indice est égal à 4.

1.5. Affichage et saisie

La structure for se prête particulièrement bien aux tableaux. La plupart des applications se laissent
implémenter par simple modification des exemples types de l'affichage et de l'affectation.

38
Tableaux

Exemple1
Ecrire un programme C qui permet de saisir les éléments d’un tableau de 5 entiers.
#include<stdio.h>
main( ) {
int A[5];
int I; // Compteur
for (I=0; I<5; I++)
scanf("%d", &A[I]);
return 0;
}

Exemple2
Ecrire un programme C qui permet d’afficher les éléments d’un tableau de 5 entiers remplie par les
valeurs suivantes : {10,20,30,40,50}.
#include<stdio.h>
main( ) {
int A[5] = {10, 20, 30, 40, 50};
int I; // Compteur
for (I=0; I<5; I++)
printf("%7d\t", A[I]);
return 0;
}

II. TABLEAUX À DEUX DIMENSIONS

2.1. Définition
Un tableau A à deux dimensions correspond à une matrice de L lignes et C colones. L et C sont alors
les deux dimensions du tableau. Un tableau à deux dimensions contient alors L*C composantes.
Un tableau à deux dimensions est dit carré si L est égale à C.

Représentation schématique
C colones

A: 0 1 2 C-1
0 …
1
L lignes 2
…
L-1

2.2. Déclaration et mémorisation

a. Déclaration de tableaux à deux dimensions en C
Syntaxe
TypeSimple NomTableau[L][C];

avec L est la dimension des lignes, et C est la dimension des colones.

Exemples
int A[10][10];
float B[2][20];
char C[15][40];

39
Tableaux

b. Mémorisation
Avec le langage C, un tableau A à deux dimensions est interprété au niveau de la mémoire comme un
tableau uni-dimensionnel de dimension L dont chaque composante est un tableau uni-dimensionnel de
dimension C.

Exemple
Mémorisation d'un tableau à deux dimensions :
int A[3][2] = {{1, 2 },{10, 20 },{100, 200}};

A 1 2 10 20 100 200
1E06

2.3. Initialisation et réservation automatique

a. Initialisation
Lors de la déclaration d'un tableau, on peut initialiser les composantes du tableau en indiquant la liste
des valeurs respectives entre accolades. A l'intérieur de la liste, les composantes de chaque ligne du
tableau sont encore une fois comprises entre accolades. Pour améliorer la lisibilité des programmes, on
peut indiquer les composantes sur plusieurs lignes.

Syntaxe
TypeSimple NomTableau[L][C]={{listeValeursPremièreLigne},
{listeValeursDeuxièmeLigne},
…
{listeValeursDernièreLigne}
};

Exemples
int A[3][10] ={{ 0,10,20,30,40,50,60,70,80,90},
{10,11,12,13,14,15,16,17,18,19},
{1,12,23,34,45,56,67,78,89,90} };

float B[3][2] = {{-1.05, -1.10 },

{86e-5, 87e-5 },
{-12.5E4, -12.3E4} };
Il faut évidemment veiller à ce que :
- le nombre de valeurs dans les listes des valeurs de chaque ligne ne dépasse pas la dimension
de colonnes,
- et le nombre de listes ne dépasse pas la dimension de lignes.
Si la liste ne contient pas assez de valeurs pour toutes les composantes, les composantes restantes
seront initialisées automatiquement par la valeur par défaut du type du tableau.
Si le nombre d’éléments dans la liste dépasse la dimension du tableau, le système génére alors une
erreur.

40
Tableaux

Exemples
int C [4][4] = {{1, 0, 0, 0 }, C: 1 0 0 0
{1, 1, 0, 0 }, 1 1 0 0
{1, 1, 1, 0 }, 1 1 1 0
{1, 1, 1, 1 }} ;
1 1 1 1
int C [4][4] = {{1, 1, 1, 1 }} ; C: 1 1 1 1
0 0 0 0
0 0 0 0
0 0 0 0

int C [4][4] = {{1},{1},{1},{1}} ; C: 1 0 0 0

1 0 0 0
1 0 0 0
1 0 0 0
int C [4][4] = {{1, 1, 1, 1, 1 }} ; erreur

b. Réservation automatique
Avec la réservation automatique des tableaux à deux dimensions, on peut omettre d’indiquer le
nombre de lignes mais pas le nombre de colonnes.

Si le nombre de lignes L n'est pas indiqué explicitement, l'ordinateur réserve automatiquement le

nombre d'octets nécessaires selon le nombre de listes indiquées.

Exemple
int A[][10] = {{ 0,10,20,30,40,50,60,70,80,90},
{10,11,12,13,14,15,16,17,18,19},
{ 1,12,23,34,45,56,67,78,89,90}};
// réservation de 3 lignes contenant chacune 10 éléments.

Si le nombre de colonnes C n'est pas indiqué explicitement, le système génère une erreur.

Exemple
int A[3][] = {{ 0,10,20,30,40,50,60,70,80,90},
{10,11,12,13,14,15,16,17,18,19},
{ 1,12,23,34,45,56,67,78,89,90}};
// erreur.
2.4. Accès aux composantes
L’accès à une case d’un tableau à deux dimensions se fait par l’opération d’indiçage. Cette opération
consiste à indiquer le nom du tableau suivi par l’indice de l’élément à référencer. L’indice est définie
en indiquant les numéros de ligne et de colonne entre crochets.

Syntaxe
NomTableau[Ligne][Colonne]

Les éléments d'un tableau de dimensions L et C se présentent de la façon suivante :

41
Tableaux

A[0][0] A[0][1] A[0][2] ... A[0][C-1]

A[1][0] A[1][1] A[1][2] ... A[1][C-1]

A[2][0] A[2][1] A[2][2] ... A[2][C-1]

... ... ... ... ...

A[L-1][0] A[L-1][1] A[L-1][2] ... A[L-1][C-1]

Les indices du tableau varient de 0 à L-1 pour les lignes, et de 0 à C-1 pour les colonnes. La
composante de la Nième ligne et Mième colonne est notée :
A[N-1][M-1] avec 0≤N<L et 0≤M<C.

2.5. Affichage et saisie

Lors du travail avec les tableaux à deux dimensions, il faut utiliser deux indices pour parcourir les
lignes et les colonnes des tableaux.

Exemple1
Ecrire un programme C qui permet de saisir les éléments d’un tableau de dimension 5*10 d’entiers.
#include <stdio.h>
main( ) {
int A[5][10];
int I,J;
// Parcourir les lignes
for (I=0; I<5; I++)
// Pour chaque ligne, parcourir les colonnes
for (J=0; J<10; J++) {
printf(“\n donner un element”);
scanf("%d", &A[I][J]);
}
return 0;
}

Exemple2
Ecrire un programme C qui permet d’afficher les éléments d’un tableau de dimension 5*10 d’entiers
supposé remplie par les valeurs suivantes : {{1,2,3,4},{6,7,8}}.
#include <stdio.h>
main( ) {
int A[5][10]={{1,2,3,4},{6,7,8}};
int I,J;
for (I=0; I<5; I++) {
for (J=0; J<10; J++)
printf("%7d \t", A[I][J]);
// Retour à la ligne
printf("\n");
}
return 0;
}

42
ANNEXE A : ENONCES DES TRAVAUX DIRIGES

43
Programmation C

TD / TP 1
(Types simples, opérateurs et expressions)

Exercice 1
Ecrire un programme C qui permet de lire les deux côtés (longueur et largeur) d’un rectangle et
d’afficher son périmètre et sa surface.

Exercice 2
Ecrire un programme qui lit trois valeurs entières et qui affiche leur somme, leur produit et leur
moyenne.

Exercice 3
Ecrire un programme qui lit les valeurs des notes N1,N2,N3 d’un étudiant et leurs coefficients
respectifs C1,C2,C3 et qui affiche :
a. La moyenne arithmétique des notes.
b. La moyenne pondérée des notes.

Exercice 4
Ecrire un programme C qui permet de lire la quantité de consommation d’électricité et le prix unitaire
et d’afficher le montant à payer de la facture.

Exercice 5
Ecrire un programme C qui permet de lire un nombre entier exprimant le temps en secondes et de le
convertir en heures, minutes et secondes.

Exercice 6
Ecrire un programme C qui permet de calculer le salaire net d’un employé selon le barème suivant :
- Une retenue de 15% sur son salaire de base pour la CNAM(Caisse Nationale Assurance
Maladie);
- La prime des enfants est fixée à 10 dinars par enfant;
- La prime d’ancienneté est fixée à 12 dinars par année.

Exercice 7
Ecrire un programme qui affiche l’aire d’un triangle dont il faut entrer les longueurs des trois côtés.
Utiliser la formule : S2=P(P-A)(P-B)(P-C)
Où A,B,C sont les longueurs des trois côtés et P le demi-périmètre du triangle.

Exercice 8
Ecrire un programme qui affiche les résistances en série et en parallèle équivalentes à trois résistances
R1, R2, R3 (type float) selon les formules suivantes :
- si les résistances sont branchées en série:
Rsér = R1+R2+R3
- si les résistances sont branchées en parallèle:
Rpar = (R1.R2.R3) / (R1.R2+R1.R3+R2.R3)

Exercice 9
Ecrire un programme C qui permet de lire le montant de la vente d’une facture et de calculer le
montant net à payer.
- Le montant net = le montant de la vente - la remise + la taxe.
- La taxe = 18 % * (le montant de la vente - la remise).
- La remise = 10 % * le montant de la vente.
44
Programmation C

Exercice 10
Ecrire un programme qui affiche le quotient et le reste de la division entière de deux nombres entiers
entrés au clavier ainsi que le quotient rationnel de ces nombres.

Exercice 11
Ecrire un programme qui calcule la somme de quatre nombres du type int entrés au clavier,
a) en se servant de 5 variables (mémorisation des valeurs entrées)
b) en se servant de 2 variables (perte des valeurs entrées)

Exercice 12
Ecrire un programme C qui permet de calculer la prime de rendement annuelle d’un employé de la
façon suivant :
Prime de rendement annuelle (PRA) = prime de présence (PP) + prime d’ancienneté (PA) + prime de
comportement (PC)
PP = (nombre de jours travaillés dans l’année / 310) * le salaire journalier (SJ);
PA = (nombre d’années d’ancienneté / 30) * le salaire mensuel (SM = SJ * 30);
PC = 5 % * SM;

Exercice 13
Ecrire un programme C qui permet de lire un nombre entier et d’afficher son carré, son cube et sa
racine carré.
EXP :
Donner un nombre : 9
Le carré de 9 est 81
Le cube de 9 est 729
La racine carrée de 9 est 3

Exercice 14
Ecrire un programme C qui permet de lire une liste de cinq nombres. Calculer et afficher la somme des
carrés de ces nombres.
EXP :
Liste de nombre : 5 2 3 1 4
La somme des carrés est 55

Exercice 15
Quels seront les résultats fournis par ce programme :
#include<stdio.h>
void main( ) {
int A=20,B=5,C=-10,D=2,X=12,Y=15,RES;
RES=(5*X)+2*((3*B)+4);
printf("RES=%d\tX=%d\tY=%d\n",RES,X,Y);
RES=A==(B=5);
printf("RES=%d\tA=%d\tB=%d\n",RES,A,B);
RES=A!=(C*=(-D));
printf("RES=%d\tA=%d\tC=%d\tD=%d\n",RES,A,C,D);
RES=A%=D++;
printf("RES=%d\tA=%d\tD=%d\n",RES,A,D);
A=20;D=2;C=-10;
RES=A%=++D;
printf("RES=%d\tA=%d\tD=%d\n",RES,A,D);
A=20;D=2;C=-10;
RES=A&&B||!0&&C&&!D;
printf("RES=%d\tA=%d\tB=%d\tC=%d\tD=%d\n",RES,A,B,C,D); }
45
Programmation C

Exercice 16
Quels seront les résultats fournis par ce programme :
#include<stdio.h>
void main ( ) {
int n, p, q, r;
n=5;p=2;q=5;
r = n = = (p = q) ;
printf (“A : n = %d p = %d q = %d r = %d\n”,n,p,q,r);
n = p = q = 10;
n += p += q;
printf (“B : n = %d p = %d q = %d \n”,n,p,q);
n=5;p=2;
q = n++ > p || p++ !=3;
printf (“C : n = %d p = %d q = %d\n”,n,p,q);
n = 5; p = 2 ;
q = n++ < p || p++ !=3;
printf (“D : n = %d p = %d q = %d \n”,n,p,q);
n = 5; p = 2 ;
q = ++n = =3 && ++p = =3;
printf (“E : n = %d p = %d q = %d \n”,n,p,q);
n = 5; p = 2 ;
q = ++n = =6 && ++p = =3;
printf (“F : n = %d p = %d q = %d \n”,n,p,q);
}

46
Programmation C

TD / TP 2
(Les structures conditionnelles)

Exercice 1
Ecrire un programme qui permet de calculer la prime de fin d’année selon le barème suivant :
- 7 % du salaire mensuel si l’indice de l’employé est inférieur à250.
- 15 D par enfants à charge.
- 12 D par année d’ancienneté à partir de la 3ème révolue : toute année commencée compte pour une
année complète.

Exercice 2
Le bénéfice B d’un représentant commercial dans une société est calculé selon le chiffre d’affaire CA
qu’il fait. En effet, B = TX*CA et :
- si CA < 1500 alors TX = 1 %.
- si 1500 <= CA < 2000 alors TX = 1.5 %.
- si CA>= 2000 alors TX = 2 %.
Ecrire un programme qui permet de saisir le chiffre d’affaire réalisé par le représentant et de
déterminer son bénéfice.

Exercice 3
Ecrire un programme qui permet de lire deux valeurs entières (A et B) au clavier et qui affiche le signe
du produit de A et B sans faire la multiplication.

Exercice 4
Ecrire un programme qui permet de calculer les solutions réelles d'une équation de second degré
ax2+bx+c = 0.

Exercice 5
Ecrire un programme qui permet de lire un nombre entier positif et de vérifier s’il est cubique ou non.
Un nombre cubique s’il est égal à la somme des cubes des chiffres qui le composent.
EXP : 153 = 13+53+33.

Exercice 6
Ecrire un programme qui permet de lire trois valeurs entières (A, B et C) au clavier et qui affiche la
plus petite des trois valeurs.

Exercice 7
Ecrire un programme qui permet de lire un numéro du mois et d’afficher en toutes lettres le mois et le
trimestre correspondants.

Exercice 8
Ecrire un programme qui permet d’additionner, soustraire, multiplier ou diviser deux valeurs entières
selon l’opérateur choisi par l’utilisateur.

47
Programmation C

TD / TP 3
(Les structures répétitives)

Exercice 1
Ecrire un programme qui lit N nombres entiers au clavier et qui affiche leur somme, leur produit et
leur moyenne. Choisissez un type approprié pour les valeurs à afficher. Le nombre N est à entrer au
clavier. Résolvez ce problème,
a) en utilisant while,
b) en utilisant do - while,
c) en utilisant for.
d) Laquelle des trois variantes est la plus naturelle pour ce problème?

Exercice 2
Compléter la meilleure des trois versions de l'exercice 1 :
Répéter l'introduction du nombre N jusqu'à ce que N ait une valeur entre 1 et 15.
Quelle structure répétitive utilisez-vous? Pourquoi?

Exercice 3
Calculer par des soustractions successives le quotient entier et le reste de la division entière de deux
entiers entrés au clavier.

Exercice 4
Calculer la factorielle N! = 123...(N-1)N d'un entier naturel N en respectant que 0!=1.
a) Utiliser while,
b) Utiliser for.

Exercice 5
Calculer par multiplications successives XN de deux entiers naturels X et N entrés au clavier.

Exercice 6
Afficher la table des produits pour N variant de 1 à 10 :
X*Y 0 1 2 3 4 5 6 7 8 9 10
--------------------------------------------------
0 0 0 0 0 0 0 0 0 0 0 0
1 0 1 2 3 4 5 6 7 8 9 10
2 0 2 4 6 8 10 12 14 16 18 20
3 0 3 6 9 12 15 18 21 24 27 30
4 0 4 8 12 16 20 24 28 32 36 40
5 0 5 10 15 20 25 30 35 40 45 50
6 0 6 12 18 24 30 36 42 48 54 60
7 0 7 14 21 28 35 42 49 56 63 70
8 0 8 16 24 32 40 48 56 64 72 80
9 0 9 18 27 36 45 54 63 72 81 90
10 0 10 20 30 40 50 60 70 80 90 100

48
Programmation C

TD / TP 4
(Les fonctions)

Exercice 1
Commenter les lignes déclaratives suivantes :
• int f1 (float) ;
• void f2 (int,float ) ;
• void f3 (int a) ;
• f4 (char) ;

Exercice 2
Ecrire la déclaration :
• D’une fonction nommé f5 qui accepte un réel et ne retourne rien.
• D’une fonction nommé f6 qui accepte un réel et retourne un réel.

Exercice 3
Décrire le résultat produit par le programme ci-dessous :
#include <stdio.h>
int a = 100, b = 200 ;
void main ( ) {
int compteur, c;
int fonc1(int c) ;
for (compteur = 1 ;compteur <=5 ; ++compteur) {
c = 4 * compteur * compteur ;
printf(“%d “, fonc1(c));
}
}
fonc1 ( int x ) {
int c ;
c = (x < 50) ? (a+x) : ( b - x) ;
return (c) ;
}

Exercice 4
Ecrire une fonction saisie qui lit deux nombres entiers positifs non nuls et appelle une fonction
longueur qui retourne le nombre de chiffres d’un nombre. La fonction saisie retourne au main :
• 1 si le premier nombre saisi est le plus long que le deuxième.
• 2 si le deuxième nombre saisi est le plus long que le premier.
• 0 si les deux nombres ont la même longueur.
Exercice 5
Ecrire une fonction qui permet de vérifier si un nombre est premier. Cette fonction est appelée par la
fonction main.

Exercice 6
Ecrire une fonction qui permet de retourner la valeur du plus grand chiffre d’un entier positif.

Exercice 7
Ecrire une fonction qui permet de vérifier si un nombre entier est symétrique ou non.

Exercice 8
a) Ecrire une fonction max_deux qui permet de déterminer le maximum entre deux entiers
b) Ecrire une fonction max_trois qui permet de déterminer le maximum entre trois entiers en
utilisant la fonction max_deux.

49
Programmation C

Exercice 9
Ecrire la fonction puissance de deux entiers sans l’utilisation de la fonction power.

Exercice 10
Ecrire une fonction récursive qui permet de convertir un nombre décimal N à une base B.

50
Programmation C

TD / TP 5
(Les tableaux)

Exercice 1
Ecrire un programme qui lit la dimension N d'un tableau T du type int (dimension maximale: 50
composantes), remplit le tableau par des valeurs entrées au clavier et affiche le tableau.
Calculer et afficher ensuite la somme des éléments du tableau. Utiliser des fonctions à votre choix.

Exercice 2
Ecrire un programme qui lit la dimension N d'un tableau T du type int (dimension maximale: 50
composantes), remplit le tableau par des valeurs entrées au clavier et affiche le tableau.
Ranger ensuite les éléments du tableau T dans l'ordre inverse sans utiliser de tableau d'aide. Afficher le
tableau résultant. Utiliser des fonctions à votre choix.

Exercice 3
Ecrire un programme qui calcule le produit scalaire de deux vecteurs d'entiers U et V (de même
dimension). Utiliser des fonctions à votre choix.

Exercice 4
Ecrire un programme qui détermine la plus grande et la plus petite valeur dans un tableau d'entiers A.
Afficher ensuite la valeur et la position du maximum et du minimum. Si le tableau contient plusieurs
maxima ou minima, le programme retiendra la position du premier maximum ou minimum rencontré.
Utiliser des fonctions à votre choix.

Exercice 5
Un tableau A de dimension N+1 contient N valeurs entières triées par ordre croissant; la (N+1)ième
valeur est indéfinie. Insérer une valeur VAL donnée au clavier dans le tableau A de manière à obtenir
un tableau de N+1 valeurs triées. Utiliser des fonctions à votre choix.

Exercice 6
Ecrire un programme qui met à zéro les éléments de la diagonale principale d'une matrice carrée A
donnée. Utiliser des fonctions à votre choix.

Exercice 7
Ecrire un programme qui réalise l'addition de deux matrices A et B de mêmes dimensions N et M.
Utiliser des fonctions à votre choix.

51