REPUBLIQUE D’HAITI

MINISTÈRE DE L’ÉDUCATION NATIONALE ET DE LA FORMATION PROFESSIONNELLE

DIRECTION DE L’ENSEIGNEMENT SECONDAIRE

ème
Module 3 Année

Programmation

Langage C

1
 Plan du cours

1/ Introduction
1.1) Les données et les résultats
1.2) Le codage
1.3) Le compilateur
1.4) Comment exécuter un programme ?

2/ Les variables
2.1) Le nom
2.2) Le type
2.3) Instruction de déclaration d’une variable
2.4) Valeur d’une variable

3/ Communications entre le programme et l’utilisateur

4.1) Affichage à l’écran
4.2) Notions de précision d’affichage
4.3) Lecture au clavier

4/ Instructions et expressions
3.1) Les opérateurs mathématiques
3.2) Dépassement des limites du codage
3.3) Incrémentation et décrémentation unitaire
3.4) Particularités du type float
3.5) Expressions simples et expressions mixtes
3.6) Conversions forcées
3.7) Le type char

5/ Structures conditionnelles
5.1) Conditions composées

6/ Structures de répétition : les boucles

6.1) Boucles While et Do While
6.2) Boucle For

7/ Les tableaux
7.1) Introduction
7.2) Déclaration d’un tableau
7.3) Insertion des valeurs dans un tableau
7.4) Affichage des valeurs d’un tableau

8/ Les fonctions
8.1) Introduction
8.2) L’en-tête d’une fonction
8.3) Le corps d’une fonction
8.4) Le positionnement d’une fonction par rapport au programme qui doit l’appeler
8.5) Le prototype d’une fonction
8.6) L’appel d’une fonction
8.7) Retour d’une valeur
8.8) Passage d’un tableau en paramètre d’une fonction

9/ Notion de variable locale ou globale

2
10/ Les erreurs

11/ Quelques fonctions prédéfinies pour la manipulation des chaînes de

caractères.

3
 CHAPITRE 1

Introduction.
Programmation
La programmation est le moyen de créer sur un ordinateur une très grande variété d’outils
informatiques, c’est-à-dire des logiciels.

Programme
Un programme n’est rien d’autre qu’un enchaînement d’opérations élémentaires permettant
d’atteindre un résultat précis à partir de données précises. En d’autres termes on dit que c’est
un enchaînement ordonné d’instructions.

Pour réaliser un programme qui fonctionne correctement, il faut donc :

1- Déterminer les données du programme (c’est-à-dire les informations sur lesquelles le
programme va être exécuté)
2- Déterminer le résultat attendu (c’est-à-dire le but du programme)
3- Décider des opérations à utiliser et les ordonner afin que les données soit traitées de
telle manière qu’on obtienne systématiquement le résultat attendu (c’est le principe de
l’algorithme)
4- S’assurer que chaque instruction respecte rigoureusement sa syntaxe
5- Tester le programme et corriger toutes les erreurs de syntaxe et de logique

1.1) Les données et les résultats.

Une des premières difficultés que rencontre un débutant en programmation ou en

algorithmie, c’est de décider d’où vont provenir les données de départ, et que va-t-on faire des
résultats ?
Les données ont deux origines possibles : soit elles proviennent de l’utilisateur du
programme (notion de communication), soit elles proviennent d’une autre partie du
programme (notion d’archivage). Ces deux notions sont à maîtriser absolument.

Exemple : un professeur souhaite créer un programme qui calcule la moyenne de ses élèves en
fonction de leurs notes. Ici, le but recherché, c’est-à-dire le résultat, c’est la moyenne de
chaque élève. Quant aux données de départ, c’est-à-dire ce qui permettra de calculer cette
moyenne, ce sera les notes de chaque élève. Le professeur a donc deux possibilités pour
introduire les notes dans le programme :
Première possibilité : il donne les notes au programme en les tapant au clavier pendant que
celui-ci est en cours d’exécution. C’est la technique dite de « communication » (l’utilisateur
va communiquer les données au programme).
Deuxième possibilité : il enregistre préalablement les notes des élèves dans la mémoire ou sur
un disque de l’ordinateur, puis il exécute le programme qui va aller chercher ses données là où
elles ont été stockées. C’est la technique dite d’« archivage » (les données ont été archivées
dans la mémoire ou sur le disque).

Généralement, la technique de l’archivage est inévitablement utilisée quel que soit le

programme que l’on écrit. En effet, dès que l’on utilise la moindre variable, on fait de
4
l’archivage puisqu’on met une valeur dans la partie de la mémoire allouée à cette variable.
D’autre part, il est quasiment inévitable de faire suivre une communication d’un archivage,
car il faut bien conserver les données que l’utilisateur a données au programme.

A la base, l’archivage se fait avec des variables auxquelles on affecte une valeur, mais
on verra qu’il existe d’autres façons d’archiver des données, par exemple en les inscrivants
dans un fichier (c’est-à-dire non plus dans la mémoire de l’ordinateur, mais sur un disque).

Puis va venir la question concernant les résultats du programme : que va-t-on en faire ?
Là encore, la question se pose en terme de communication ou d’archivage : va-t-on
communiquer les données à l’utilisateur (en les affichant, par exemple) ? Va-t-on les
conserver dans un fichier pour une utilisation ultérieur ? Va-t-on les mettre à disposition pour
que d’autres programmes puissent s’en servir ?

1.2) Le codage.

On sait que l’ordinateur code toutes les données sous la forme d’enchaînement de
« 0 » et de « 1 ». Chaque valeur (0 ou 1) est placée dans une cellule de la mémoire qu’on
appelle un « bit ». En rassemblant les bits par 4, on forme des quartets, et par 8, on forme des
octets. Cette façon est la plus courante de comptabiliser l’espace mémoire occupée par une
donnée. Mais il y a une notion très importante à bien comprendre dans le codage de
l’ordinateur : un code seul représente une valeur, mais on ne sait pas quel est le type de cette
valeur (nombre entier, nombre flottant, caractère, booléen, image, son, instruction de
programme, etc. ?). C’est pour cette raison que la programmation nécessite une grande
attention dans la manipulation des types des données, qui est d’ailleurs une grande source
d’erreurs de logique.

D’autre part, il est bon de rappeler qu’un bit ne peut contenir que 0 OU 1. Il ne peut
contenir les deux en même temps et il ne peut pas ne rien contenir. Par conséquent, tout ce qui
fait référence à une partie de la mémoire ne peut pas être vide (une variable, par exemple,
contient obligatoirement une valeur, même si on ne lui a rien affecté, d’où un risque d’erreur
fréquent chez les débutants en programmation).

1.3) Le compilateur.

On appelle compilateur le logiciel qui traduit les algorithmes écrits en langage

machine. D’une certaine manière, on peut dire qu’il rend compréhensible pour l’ordinateur les
programmes écrits par un programmeur.
Généralement, on lance le compilateur sur un programme pour vérifier si l’ordinateur
le comprend ou s’il repère des erreurs. Attention, l’ordinateur n’est pas capable de repérer
toutes les erreurs d’un programme, mais il s’aperçoit toujours des erreurs de syntaxe, car ces
erreurs rendent le programme inexploitable pour lui. D’autre part, il peut également signaler
tous détails qui lui paraissent douteux au moment de la compilation. C’est ce qu’on appelle
des « warnings » (ou avertissements).

1.4) Comment exécuter un programme avec Dev-C+

+?

Voici une façon de faire :

5
 1- Lancer le logiciel Dev-C++
2- Ouvrir le fichier source d’un programme existant ou créer un nouveau fichier source et
y écrire un programme
Ici donner l’exemple du programme « hello world » :

HELLO_WORLD en langage algorithmique

programme HELLO_WORLD
| (* Notre premier programme en C *)
| écrire "hello, world"
fprogramme

HELLO_WORLD en C

#include <stdio.h>
main()
{
printf("hello, world");
}

3- Lancer le compilateur pour vérifier la présence d’éventuelles erreurs (s’il n’y a pas
d’erreur, le compilateur va créer un fichier exécutable de votre programme dans le
répertoire de votre fichier source)
4- Corriger les éventuelles erreurs
5- Dans le menu Start / Démarrer, lancer « Exécuter / Run »
6- Taper « command ou cmd» et cliquer sur « Ok », ce qui ouvrira une fenêtre DOS
7- Ouvrir le répertoire dans lequel votre fichier source a été enregistré, avec la commande
« cd »
8- Lancer l’exécutable créé à partir de votre fichier source : c’est là que votre programme
s’exécute réellement

CHAPITRE 2

Les variables.
Comme en algorithmie, tout le travail de la programmation s’articule autour des
notions de variable et de type.
Définition
Emplacement en mémoire stockant une donnée pouvant varier au cours de l’exécution d’un
programme.
Une variable est identifiée par son nom et définie par son type et sa valeur.

2.1) Le nom.

Il est laissé au choix du programmeur au moment de la déclaration, mais avec les contraintes
suivantes :

6
 1. Les caractères autorisés sont les suivants : toutes les lettres minuscules, toutes les
lettres majuscules, tous les chiffres et le symbole « _ ». Les lettres accentuées (é, è, à,
etc…) ou modifiées (ç, ï, etc…) ne sont pas admises.
2. le premier caractère ne doit pas être un chiffre.
3. un nom ne doit pas comporter plus de 32 caractères (si on le fait, le compilateur
l’accepte, mais sans tenir compte des caractères superflus, d’où un risque d’erreurs).
4. aucun espace n’est admis.
5. le langage C respecte la casse, c’est-à-dire que les lettres en minuscules sont
différentes des mêmes lettres en majuscules.

Exemples
Identificateurs
Identificateurs corrects:
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

2.2) Le type.

Le type d’une variable précise l’ensemble des valeurs qu’elle peut contenir, la taille de
son emplacement dans la mémoire de l’ordinateur, la manière dont l’information y est codée
et les opérations autorisées.

Les premiers types de variables disponibles en C sont les suivants :

- int : nombres entiers signés (autrement dit, ce sont les nombres relatifs)
- short : nombres entiers signés codés sur un nombre plus restreint de bits que le type
int
- long : nombres entiers signés codés sur un plus grand nombre de bits que le type int
- float : nombres à virgule flottante (approximation des nombres réels)
- double: nombres à virgule flottante codés sur un plus grand nombre de bits que le type
float
- long double : nombres à virgule flottante codés sur un plus grand nombre de bits que
le type double
- char : caractères

De plus, les types int, short et long peuvent être précédés du mot-clef « unsigned » qui
supprime la prise en charge des valeurs négatives. Ainsi, on dispose d’une marge deux fois
plus grande pour les valeurs positives.

Le type booléen
D’autre part, on peut remarquer qu’il n’y a pas de type booléen. En fait, en C, les
variables booléennes doivent être simulées avec une variable d’un autre type dont on ne
considérera que deux valeurs possibles. Sachez cependant que le type booléen a été introduit
dans les compilateurs C, mais il est préférable de savoir simuler ce type à l’aide d’une variable
d’un autre type.
7
N.B :
Le nombre de bits utilisés pour le codage dépend de la puissance de l’ordinateur utilisé
pour compiler et exécuter le programme, et il peut arriver que deux types proches comme
short et int ou comme float et double, disposent du même nombre de bits sur certaines
machines.

2.3) Instruction de déclaration d’une variable.

Comme en algorithmie, les instructions de déclaration précèdent les autres

instructions.

Syntaxe  : <type> <nom> ;

Exemple : int X ;

Ici, on a déclaré une variable de type « int » nommée X.

La plupart des instructions du langage C sont terminées par un point virgule. L’oublie
de ce symbole engendre inévitablement une erreur de syntaxe lors de la compilation. Par
contre, grâce à cette contrainte syntaxique, il est tout à fait possible de mettre autant
d’instructions que l’on veut sur la même ligne.

Egalement comme en algorithmie, il est tout à fait possible de déclarer plusieurs

variables de même type dans la même instruction en les séparant par une virgule. Exemple :
int X, Y, Z ;

2.4) Valeur d’une variable.

Une variable peut recevoir une valeur par :

a) Par initialisation
Syntaxe : <type> <nom> = <valeur d’initialisation> ;
Exemple : int X = 5 ;

b) par affectation
<nom de la variable> = <valeur> ;
Exemple : X=10 ;
N.B :
 En affectant une nouvelle valeur à une variable, la première est automatiquement
perdue.

 Il est tout à fait possible d’affecter une nouvelle valeur à une variable dans le corps
du programme.

 L’initialisation d’une variable ou l’affectation d’une valeur à une variable n’est pas
obligatoire avant de participer à une opération. Dans ce cas, on va travailler sur
une valeur aléatoire, ce qui fait que l’on obtiendra forcément un résultat également
aléatoire

8
 Chapitre 3

Communication entre le programme et

l’utilisateur.
Un programme est capable de communiquer à travers tous les périphériques dont
dispose un ordinateur de manière à obtenir les données dont il a besoin et à transmettre les
résultats qu’il trouve. Dans un premier temps, nous nous limiterons aux deux périphériques de
communication avec l’utilisateur les plus courants : l’écran et le clavier.

3.1) Affichage à l’écran.

L’affichage de texte et de valeurs se fait grâce à la fonction printf. Cette fonction est
légèrement plus complexe que la fonction « Afficher » utilisée en algorithmie, mais elle
présente le gros avantage d’accepter autant de paramètres qu’on le souhaite.

L’affichage d’un simple texte sans aucune variable utilise la syntaxe suivante :

printf (« <texte> ») ;

Par exemple, l’instruction suivante affiche le message « bonjour » :

printf (« Bonjour ») ;

Généralement, on appelle « libellé » le texte affiché avec la fonction printf.

L’affichage de valeurs des variables et des expressions se fait en deux temps : d’abord
indiquer l’emplacement et le type de la variable ou de l’expression dans la partie qu’on
appellera « format d’affichage », ensuite donner la variable ou l’expression elle-même dans la
partie qu’on appellera « liste ». Le type est indiqué grâce aux codes de format suivants :
- %d : types int, short et long
- %c : type char
- %e : types float, double et long double sous la forme exponentielle
- %f : types float, double et long double sous la forme décimale

Pour indiquer l’emplacement où sera affichée la valeur de la variable, il suffit de

placer le code de format correspondant à l’endroit voulu.

9
Exemples :

On souhaite afficher la valeur de la variable X de type int. Ici, l’emplacement ne

posera aucune difficulté puisque la variable n’est pas accompagnée de texte.
printf (« %d », X) ;

On souhaite afficher la valeur des variables X, Y et Z toutes de type int. Ici, pour ce
qui est de l’emplacement, on tient à afficher d’abord X, puis Y et enfin Z.
printf (« %d %d %d », X, Y, Z) ;

On souhaite afficher la valeur de la variable X de type int, précédée du texte « Voici la

valeur de X : ». Ici, pour ce qui est de l’emplacement, on souhaite que la valeur soit affichée à
un endroit précis pas rapport au texte.
printf (« Voici la valeur de X : %d », X) ;

La fonction printf permet également d’afficher le résultat d’une ou plusieurs

expressions. Dans ce cas, il faut bien déterminer le type de l’expression pour pouvoir décider
du code de format que l’on va utiliser. Exemple :

pritnf (« %d », X+ Y) ;

3.2) Notions de précision d’affichage.

Les valeurs de type float sont affichées par défaut avec 6 chiffres après la virgule. Il
est possible de modifier cette précision en indiquant le nombre de chiffres souhaités, précédé
d’un point, après le symbole « % ».

Exemples :

x = 1.2345 ;
printf (« %.2f », x) ; On obtient : «1.24»

Le symbole « \n » permet insérer des sauts de ligne, de manière à améliorer la

présentation des données affichées.

3.3) Lecture au clavier.

La lecture des valeurs tapées au clavier par l’utilisateur se fait avec la fonction scanf.
Son rôle est de recevoir la valeur venant du clavier, de la convertir dans le type voulu et de la
placer dans la variable qui lui a été assignée. Voici sa syntaxe :

scanf (« <type de la valeur lue> », &< variable d’accueil de la valeur lue>) ;

Exemple : scanf (« %d », &X) ; Cette instruction lit au clavier une valeur de type int et
l’affecte à la variable X.

Lorsqu’on veut lire plusieurs variables dans une seule instruction, il suffit de répéter la
syntaxe autant de fois que nécessaire. Exemple :

10
 scanf (« %d%d%d », &X, &Y, &Z) ; Cette instruction lit au clavier trois valeurs
de type int et les affecte successivement aux variables X, Y et Z.

Au moment de l’exécution du programme, si jamais l’utilisateur ne fournit pas

suffisamment de données, le programme restera en attente jusqu’à ce que toutes les données
attendues soient fournies par l’utilisateur. D’autre part, si l’utilisateur fournit trop de données,
les données en trop seront conservées pour la lecture suivante ou abandonnées si le
programme ne contient aucune autre instruction de lecture.

En ce qui concerne le symbole « & », il signifie que scanf n’attend pas le nom d’une
variable, mais son adresse mémoire. Cette notion sera étudiée plus tard, mais notons que ce
symbole est ici absolument obligatoire.

La lecture au clavier lors de l’exécution du programme est assez naturelle : l’utilisateur tape sa
valeur et la valide avec la touche « Entrée ». Tant qu’il ne l’a pas validée, il peut la modifier à
volonté. Lorsqu’il y a plusieurs valeurs à lire, l’utilisateur peut passer de l’une à l’autre avec
les touches « Entrée », « Espace » ou « Tabulation », mais la dernière doit forcément être
validée par la touche « Entrée ».

En ce qui concerne la lecture des valeurs de type flottant, les codes de format %e et %f
sont équivalents et les valeurs peuvent être lues sous n’importe quelle forme.

Pour la lecture des valeurs de type char, on rencontre certaines difficultés lorsque l’on
souhaite en lire plusieurs successivement : en effet, ici les caractères « Espace »,
« Tabulation » ou le saut de ligne sont considérés comme des séparateurs et en même temps
comme des caractères. Par conséquent, au moment de la lecture, lorsque l’utilisateur tape par
exemple la touche Entrée pour valider sa saisie, le caractère « saut de ligne » devient
disponible pour la lecture d’un caractère.

Exemple : scanf (« %c%c », &C1, &C2) ;

- 1er cas : l’utilisateur peut taper la réponse suivante : ab, puis valider par la touche
Entrée. Dans ce cas, C1 va recevoir ‘a’, C2 v recevoir ‘b’, mais le caractère « saut de
ligne » restera automatiquement disponible pour la prochaine lecture. Donc, si cette
prochaine lecture porte sur une variable de type numérique, il n’y aura pas de
problème car le saut de ligne sera considéré comme un délimiteur. Par contre, si cette
prochaine lecture porte sur une variable de type caractère, elle va directement recevoir
le caractère « saut de ligne » qui avait été mis à disposition lors de la lecture
précédente.

- 2nd cas : l’utilisateur peut taper la réponse suivante : a« espace »b, puis valider par la
touche Entrée. Dans ce cas, C1 va recevoir ‘a’, C2 v recevoir l’espace qui était sensé
servir de délimiteur et qui est finalement considéré comme un caractère à part entière.
Par conséquent, le ‘b’ et le « saut de ligne » resteront disponibles pour une prochaine
lecture.

Il est possible dans certains cas d’esquiver ce genre de problème en prévoyant

l’introduction d’un séparateur entre deux caractères à lire. Pour cela, il suffit d’introduire un
espace entre les codes de format.
Exemple : scanf (« %c %c %c », &x, &y, &z) ;

11
 CHAPITRE 4

4- Instructions et expressions.
 Une instruction est un ordre donné à l’ordinateur selon une syntaxe de programmation.

 Une expression a souvent un type et une valeur qu’il faut savoir déterminer pour
prévenir ou corriger les erreurs de calcul ou de conversion de type.

 Un programme est simplement un enchaînement ordonné d’instructions.

 Une instruction est composée d’opérateurs (+, -, *, / ) et d’opérandes (valeurs

constantes, variables ou expressions elles-mêmes composées d’opérateurs et
d’opérandes).

 Il est important de bien distinguer l’instruction complète des expressions qui la

composent.

Exemple : X = Y + 5 est une instruction d’affectation composée d’une variable (X), de

l’opérateur d’affectation (=) et d’une expression (Y + 5).
4.1) Les opérateurs mathématiques.

 Les opérations mathématiques de base s’effectuent avec les symboles suivants :

- addition : +
- soustraction et opposé : -
- multiplication : *
- division : /

 Le langage C propose également un autre opérateur appelé « modulo », correspondant

au reste de la division entière. Son symbole est : « % ».
Exemple : 11%4 vaut 3, car la division de 11 par 4 a pour reste 3.

Le symbole modulo n’est pas utilisable avec les valeurs de type Flottant / float.

12
  Lorsque plusieurs opérateurs mathématiques apparaissent dans la même expression,
les règles de priorité sont les même qu’en algèbre et les parenthèses peuvent être
utilisées de la même manière.
Exemple : dans l’opération A + B * C, on multiplie d’abord B par C, puis on ajoute A.
De plus, l’opérateur % a la même priorité que la multiplication.

Ordre de priorité :
* et / : la priorité se trouve dans l’ordre de placement des opérateurs
Ex : 10 * 2 / 4 = 5
20 / 4 * 2 = 10
+ et - : la priorité se trouve dans l’ordre de placement des opérateurs.
Ex : 10 + 2 - 4 = 8
14 - 2 + 1 = 13

« * » et « / » sont prioritaires par rapport à « + » et « - »

10 + 5 * 2 = 20
15 – 5 * 2 = 5
20 – 8 / 2 = 16

4.2) Incrémentation et décrémentation unitaire.

 Pour l’incrémentation et la décrémentation unitaire d’une variable de type numérique,

les instructions utilisées en algorithmie sont basées sur le schéma de l’exemple
suivant : X <-X + 1 ou X <- X – 1.
En C, il existe une instruction spéciale pour l’incrémentation et la décrémentation
unitaire, dont voici les différentes syntaxes :
Incrémentation : ++ <variable> ou <variable> ++ Ex : ++X, X++
Décrémentation : -- <variable> ou <variable> -- Ex : --X, X--

L’opération X++ ; est entièrement équivalente à celle-ci : X = X + 1 ;

 Ces deux syntaxes ne présentent aucune différence si on les utilise seules en tant
qu’instruction. Ainsi, les instructions X++ ; et ++X ; sont équivalentes. Par contre, si
on utilise ces syntaxes en tant qu’expression à l’intérieur d’une autre instruction, on
doit prendre en compte la distinction suivante :
- ++ <variable> ou -- <variable> : la valeur de cette expression est celle de la variable
après l’incrémentation ou la décrémentation.
- <variable> ++ ou <variable> -- : la valeur de cette expression est celle de la variable
avant l’incrémentation ou la décrémentation.

 De la même manière, il existe en C pour chaque opération mathématique, un opérateur

rassemblant l’affectation et l’opération mathématique. Exemples :

X = X + K ; peut être remplacé par X += K ;

Y = Y * X ; peut être remplacé par Y *= X ;

-
4.3) Expressions simples et expressions mixtes.

13
  Une expression simple est une opération ne contenant qu’un seul type de valeurs ou de
variables.
Exemple : l’instruction X = X * 2 ; où X est une variable de type int, est une
expression simple).

 Par opposition, les expressions mixtes sont des opérations dans lesquelles on fait
intervenir des valeurs de type différent, en particulier int et float.

 Il est important de tenir compte des conversions de type, car elles peuvent être à
l’origine d’une perte de données au niveau du résultat.

 De façon générale, on parle du type d’une expression pour désigner le type du résultat
d’une opération.

 Exercice : soient X et Y de type int, et A et B de type float. Donner le type des

expressions suivantes :

- X+Y
- A*B
- X/Y
- X+A
- X+B*A
- X+Y*B
- X+5
- X + 2.3
- Y*3
- B/2

 Une conversion de type a également lieue lors d’une affectation si la valeur affectée
est de type différent que la variable qui la reçoit. Là encore, il faut donc y être attentif,
car cela peut produire des effets inattendus si la conversion est faite involontairement.

4.4) Conversions forcées.

 Il est tout à fait possible de forcer la conversion d’une variable à l’intérieur d’une
expression de manière à éviter de perdre des données. Il existe un opérateur de
conversion forcée (appelé opérateur de « cast ») pour chaque type. En voici la
syntaxe : <variable d’accueil>= (<Type>) <expression ou variable> ;

 Par exemple, dans le programme suivant, la division est de type int et on risque donc
d’obtenir un résultat imprécis :

{
int n=5, p=9;
float x;

x = p / n;
printf ("%f\n",x); /* Ici, on obtiendra donc 1 comme résultat */
}

14
 Pour éviter cette perte de données, on va forcer le type de l’expression en float en
ajoutant ce type entre parenthèses à l’intérieur de l’expression elle-même :

{
int n=5, p=9;
float x;

x = (float) p / n;
printf ("%f\n",x); /* Ici, on obtiendra 1.8 comme résultat */
}

4.5) Le type char.

 Ce type correspond au type « car » utilisé en algorithmie pour les caractères. Les
valeurs constantes doivent impérativement être placées entre les symboles ‘ et ’ faute
de quoi elles seraient considérées par le compilateur comme des variables et non
comme des valeurs de type char.

 Exemple : lorsqu’on écrit l’instruction « a = ‘e’; » , cela signifie que la variable a
reçoit la valeur « e », alors que l’instruction « a = e ; » signifie que la variable a reçoit
la valeur de la variable e.
Conversion int / char et char / int :

 On peut remarquer que chaque lettre de l’alphabet possède une correspondance de

type int. Ainsi, il est tout à fait possible d’effectuer des opérations arithmétiques sur
des valeurs ou des variables de type char qui seront d’abord converties au type int.

Exercices

1- Ecrire un programme qui demande deux nombres entiers quelconques, puis qui affiche
leur somme.

2- Ecrire un programme qui lit au clavier deux nombres entiers et un nombre décimal et
qui affiche leur somme, puis leur produit.

3- Ecrire un programme demande deux nombres entiers (X et Y) et qui affiche le quotient

de X par Y.

4- Ecrire un programme qui demande deux nombres entiers et qui affiche, le premier
après son incrémentation unitaire et le second après sa décrémentation unitaire.

5- Ecrire un programme qui demande deux nombres entiers, qui incrémente le premier de
trois (3) et le second de cinq (5), puis qui affiche leur somme.

6- Ecrire un programme qui lit un nombre décimal et qui affiche uniquement la partie
entière.

7- Ecrire un programme qui lit au clavier deux valeurs de type caractère, qui affiche leurs
correspondances numériques, puis leur somme.
15
 8- Ecrire un programme qui lit au clavier trois valeurs de type caractère, qui affiche leurs
correspondances numériques sous la forme décimale, avec deux chiffres après la
virgule, puis leur produit.

16
 Chapitre 5

5/ Structures conditionnelles.
 Pour conditionner l’exécution de certaines instructions sur un test, il existe en C
l’équivalent du « si, alors, sinon, fin si » de l’algorithmie. Voici sa syntaxe :
if (<Condition>)
{
bloc d’instructions 1
}
else
{
bloc d’instructions 2
}
Exemple :
if (x < y)
{
printf (« %d »,x) ;
}
else
{
printf (« %d »,y) ;
}

 Ce que l’on appelle « bloc d’instructions » est simplement un ensemble d’instructions

contenues entre { et }.

 Comme en algorithmie, un bloc d’instructions peut contenir d’autres structures

conditionnelles et donc d’autres blocs d’instructions.

 De plus, le bloc introduit par « else » peut tout à fait être ignoré, c’est-à-dire ce n’est
pas obligatoire d’avoir le bloc d’instruction « else »
 Le bloc d’instruction « else » ne peut être utilisé que si le résultat d’un test a
deux valeurs.
 Le bloc d’instruction « else » tient compte uniquement du « if » qui le précède.

 La condition peut porter aussi bien sur des valeurs numériques que des caractères, à
condition de bien distinguer la signification des opérateurs de comparaison dans
chaque cas. Voici les opérateurs que l’on peut utiliser, avec leurs différentes
significations :

Signification pour les valeurs

Opérateur Signification pour les caractères
numériques
== Egal identique
< strictement inférieur de code inférieur
> strictement supérieur de code supérieur
<= inférieur ou égal de code inférieur ou égal
17
 >= supérieur ou égal de code supérieur ou égal
!= non égal différent

 Tous ces opérateurs de comparaison sont moins prioritaires que les opérateurs
arithmétiques. Par conséquent, il est tout à fait possible de faire porter une condition
sur des expressions.

Exemple :

if (x / 3 = = y + 2)
{
…
}

 Remarque : il peut arriver qu’une comparaison utilisant l’opérateur « = = » sur des
valeurs flottantes donne un résultat inattendu dû au fait que les flottants ne sont que
des approximations des nombres réels.

5.1) Conditions composées.

Encore comme en algorithmie, il est possible d’utiliser des opérateurs logiques pour
introduire plusieurs tests à l’intérieur d’une condition. Voici la notation de ces
opérateurs :

Opérateur Signification
&& et
|| ou (inclusif)
! non

« && » et « || » sont moins prioritaires que les opérateurs de comparaisons, alors
que « ! » l’est plus.

Exercices
1- Ecrire un programme qui demande la moyenne d’un élève (sur 10) et qui affiche le
message « Admis » si sa moyenne est supérieure ou égale à cinq (5) ou « Echec » si sa
moyenne est inférieure à cinq (5)

2- Ecrire un programme qui lit au clavier un nombre entier quelconque et qui affiche le
message « le nombre est pair » si le nombre entré est pair ou « Le nombre est impair »
s’il est impair.

3- Ecrire un programme qui demande deux nombres entiers et qui affiche le plus grand
des deux s’ils sont inégaux et un message indiquant s’ils sont égaux dans le cas
contraire.

4- Même exercice que précédemment, mais en affichant le plus petit des deux.

5- Ecrire un programme qui demande deux nombres entiers et qui affiche leur différence.
(Eviter d’avoir un résultat négatif).
18
 6- Ecrire un programme qui lit au clavier un nombre entier quelconque et qui affiche le
message « le nombre est pair » si le nombre entré est pair ou « Le nombre est impair »
s’il est impair.

7- Ecrire un programme qui demande deux nombres entiers et qui affiche un message
indiquant si les deux nombres sont égaux ou non.

8- Ecrire un programme qui demande deux nombres entiers, qui compare leur somme et
leur produit et qui affiche le résultat correspondant par les suivants :
- « La somme est supérieur au produit »
- « Le produit est supérieur à la somme ».
- « La somme est égale au produit ».
La condition doit être portée sur des expressions.

9- Ecrire un programme qui demande deux nombres entiers et qui affiche u message
indiquant si le plus grand des deux est pair ou impair.

10- Ecrire un programme qui demande un nombre compris entre 1 et 25 et qui affiche le
message « Vous avez gagné » si le nombre se termine par un zéro (0) ou « vous avez
perdu » dans le cas contraire.

Devoir

11- L’UNEPH souhaite avoir un programme lui permettant d’afficher les résultats des
étudiants qui ne sont pas en règle avec l’administration de la manière suivante :
- « Reprise » si la note de l’Etudiant est comprise entre 59 et 65
- « Echec ou succès » dans le cas contraire.
Alors écrire un programme qui demande la note d’un étudiant (sur 100) et qui affiche
un message correspondant à sa note.
N.B : réalisez cet exercice de deux manières différentes en utilisant d’une part
l’opérateur logique « && » et d’autre part l’opérateur logique « || ».

19
 Chapitre 6

6/ Structures de répétition : les boucles.

6.1) Boucles While et Do While..

L’équivalent en C de la boucle « Tant que » de l’algorithmie utilise la syntaxe suivante :

while (<Condition>)
{
<Bloc d’instructions>
}

L’équivalent en C de la boucle « Faire tant que » de l’algorithmie utilise la syntaxe suivante :

do
{
<Bloc d’instructions>
}
while (<Condition>) ;

Ces boucles s’utilisent en C exactement comme en algorithmie et comme dans la

grande majorité des langages de programmation.

6.2) Boucle For.

L’équivalent en C de la boucle « Pour » de l’algorithmie utilise la syntaxe suivante :

for (<affectation de départ> ; <test d’arrivée> ; <instruction d’incrémentation>)

{
<Bloc d’instructions>
}

Attention, contrairement à l’algorithmie, la limite de la boucle for n’est pas une

« valeur d’arrivée », mais un « test d’arrivée ».

Exemple de boucle « for » utilisant comme compteur la variable comp de type int :

for (comp = 0 ; comp < 10 ; comp ++)

{
printf(« %d », comp) ;
}

20
 Chapitre 7

7/ Les tableaux.
Introduction
Dans ce chapitre, nous allons essentiellement étudier les tableaux statiques à une
dimension. Le principe des tableaux en C est le même qu’en algorithmie, avec les mêmes
notions de dimension, de taille, de cellule et d’indice.

Cellule
C’est le plus petit élément constitutif d’un tableau

Dimension
C’est le nombre de cellules que contient un tableau.

Taille
C’est le nombre de cellules pleines dans un tableau

Indice
C’est un numéro qui identifie chaque cellulle d’un tableau.

N.B: En C, la première cellule d’un tableau est forcément d’indice 0.

Déclaration d’un tableau

Syntaxe : <type> <nom> [<dimension>] ;

Exemple  : int Tab [5] ;

C’est la déclaration d’un tableau de type int et de dimension 5

Insertion des valeurs dans un tableau

Les valeurs peuvent être inésrées dans un tableau de trois facons différentes :
 
1- Par l’initialisation
Syntaxe : <type> <nom> [<dimension>] = {<liste des valeurs séparées par des virgules>} ;
Exemple  : int Tab [5] = {1,5,3,4,7}
Exemple de déclaration du même tableau que précédemment, mais en lui donnant des valeurs
d’initialisation.

N.B : L’initialisation peut ne remplir qu’une partie du tableau si on affecte moins de valeur
qu’il ne peut en contenir. Evidement, ce sont les premières cellules qui recevront ces valeurs.

Exemple : int Tab [5] = {1, 5, 3}

2- Par affectation
Syntaxe  : <nom du tableau> [<indice>] = <la valeur> ;
21
Exemple : tab[1]=9 ;

3- Par l’utilisateur
Syntaxe : scanf(« symbole du type du tableau », &<Nom du tableau> [<indice>]) ;

Technique classique pour le remplissage d’un tableau par l’utilisateur technique

aussi  appelée « lecture d’un tableau  au clavier ») :

for (<compteur> = 0 ; <compteur> < <Dimension> ; <compteur> ++)

{
printf (« Donnez la valeur de la cellule %d, SVP\n », <compteur>) ;
scanf (« <Symbole du type du tableau> », &<Nom du tableau> [<compteur>]) ;
}

Exemple :

int Tab [10] ;

for (c = 0 ; c < 10 ; c++)
{
printf (« Donnez la valeur de la cellule %d, SVP\n », c) ;
scanf (« %d\n », &Tab [c]) ;
}

Affichage des valeurs d’un tableau

Syntaxe : printf(« symbole du type du tableau », <Nom du tableau> [<indice>]) ;

Techniques classiques pour affichage du contenu d’un tableaux.

for (<compteur> = 0 ; <compteur> <= <Dimension> ; <compteur> ++)

{
printf (« <Symbole du type du tableau>\n », <Nom du tableau> [<compteur>]) ;
}

Exemple :
int Tab [10] = {1,2,3,4,5,6,7,8,9,10};
for (c = 0 ; c < 10 ; c++)
{
printf (« %d\n », Tab [c]) ;
}

22
 Chapitre 8

8/ Les fonctions.
8.1 Introduction

 Les fonctions en C reprennent le même principe qu’en algorithmie, mais il faut

prendre ici en compte l’organisation des fonctions par rapport aux programmes qui les
appellent. Il existe deux situations principales : l’appel d’une fonction prédéfinie et la
définition d’une fonction particulière en vue d’un appel ultérieur.

 Les fonctions prédéfinies sont stockées dans des fichiers biliothèques qui possèdent
l’extension « .h ». L’appel d’une telle fonction nécessite donc que l’on sache à quelle
bibliothèque elle appartient et que l’on introduise cette bibliothèque au programme.
Pour cela, on utilise l’instruction « #include » au tout début du programme avec la
syntaxe suivante : #include < <chemin d’accès de la bibliothèque> >

Exemple : pour pouvoir utiliser les fonctions prédéfinies printf et scanf, on fait
appel à la bibliothèque stdio.h :

#include <stdio.h>

 En ce qui concerne les fonctions particulières définies uniquement dans le cadre du

développement d’un programme, elles font généralement partie du programme et sont
donc placées directement dans le fichier source du programme.

Pour tout ce qui concerne la déclaration, la définition et l’utilisation (appel) d’une fonction,
toutes les notions suivantes sont à connaître et à maîtriser :

8.2) L’en-tête de la fonction.

Syntaxe : <Type de la valeur retournée> <Nom de la fonction> (<Paramètres>)

Exemple  : int Test (int x, float y, char z)

N.B :
 On utilise le mot-clef « void » pour signaler l’absence de valeur de retour ou de
paramètre.
Exemples :
 void Test (int x, int y)
 int Test_2 (void)

 Attention, il n’est pas possible en C de rassembler les paramètres de même

type en indiquant une seule fois le type. C’est-à-dire que pour chaque
paramètre, il faut indiquer le type, même si le paramètre précédent est de même
type.

23
 Exemple  : int Test (int x, int y, float z)

8.3) Le corps de la fonction

L’ensemble du corps de la fonction doit être encadré par des accolades comme pour
tout bloc d’instructions.

8.4) Le positionnement d’une fonction par rapport au

programme qui doit l’appeler.

Il existe deux façons de faire :

- on place la fonction avant le programme qui va l’appeler.
- Ou on la place après le programme qui va l’appeler et on introduit dans ce dernier le
prototype de la fonction.

Dans les deux cas, l’idée est la même : faire en sorte que le programme qui doit appeler
une fonction la connaisse ou ait au moins une référence à celle-ci. D’ailleurs, lorsqu’on place
au début d’un fichier source l’instruction « include » avec le nom d’une bibliothèque, on
donne aux programmes de ce fichier source une référence aux fonctions qu’ils sont
susceptibles d’appeler.

8.5) Le prototype d’une fonction.

Syntaxe : <Type de la valeur retournée> <Nom de la fonction> (<Type des paramètres>) ;

Exemple : int Test (int, float, char)
Attention, ici, on n’indique pas le nom des paramètres, mais seulement le type de
chacun d’entre eux (en répétant le type si plusieurs paramètres de même type se suivent).

Exemple : int Test (int, int) ;

8.6) L’appel d’une fonction.

Deux cas peuvent se présenter :

 Si la fonction ne retourne aucune valeur.
Syntaxe : <nom de la fonction> (<paramètre (s)>) ;
Exemple : Test (x, y, z) ;
 Si la fonction retourne une valeur.
Syntaxe : <variable d’accueil de la valeur> = <nom de la fonction> <paramètre (s)>

Exemple : r = Test (x, y, z) ;

la valeur de chaque paramètre doit être fournir dans l’ordre prévu dans la définition de la
fonction.
La valeur d’un paramètre peut être une varaiable, une constante, une expression ou le retour
d’une fonction.

24
Exemples :

8.7) Retour d’une valeur.

Une fonction peut en plus retourner une valeur du type défini dans son en-tête.

Syntaxe : return <valeur de retour> ;

Ou : return (<valeur de retour>) ;

 Contrairement à l’algorithmie, la valeur à retourner n’a pas forcément besoin d’être

placée entre parenthèses. Il peut s’agir là encore d’une constante, d’une variable ou de
n’importe quelle expression.

 Par contre, le principe du retour est exactement le même qu’en algorithmie : lorsqu’on
exécute l’instruction return, on sort immédiatement de l’exécution de la fonction en
cours, ce qui empêche le retour simultané de plusieurs valeurs pour une même
fonction.

8.8) Passage d’un tableau en paramètre d’une

fonction.

Comme en algorithmie, on peut indiquer ou pas la dimension du tableau selon les

besoins de la fonction, mais c’est toujours la présence des crochets qui indique qu’on a à faire
à un tableau et non à une variable classique. Il en va d’ailleurs de même pour le prototype
d’une fonction prenant un tableau.

Exemple de prototype d’une telle fonction : int Test (int [ ], int) ;

Lorsqu’on passe un tableau en paramètre, on le transmet sous la forme d’une adresse, ce qui
apporte comme avantage que le tableau n’a pas besoin d’être retourné : toute modification
faite sur le tableau à l’intérieur de la fonction appelée modifie le tableau qui a été fourni en
paramètre à cette fonction.

Chapitre 9

9/ Notions de variable locale et globale.

Variable locale
Une variable « locale » est une variable déclarée à l’intérieur d’une fonction. Sa valeur
ne peut être considérée que lors de l’appel de la fonction et elle est indisponible pour tout
autre fonction, y compris pour le « main ». De plus elle perd sa valeur sa valeur dès que l’on
sort de la fonction et elle ne peut en recevoir une qu’au moment de l’appel de la fonction.

25
Variable globale
Une variable « globale » est une variable déclarée au début d’un fichier source et en
dehors de toute fonction. Elle n’appartient pas à une fonction particulière et est disponible
pour toutes les fonctions du fichier, y compris pour le main. De plus, lorsqu’on passe d’une
fonction à une autre lors d’un appel ou lorsqu’une fonction a fini de s’exécuter, les variables
globales conservent leur valeur actuelle. Enfin, une variable globale qui n’est pas initialisée
lors de sa déclaration reçoit automatiquement la valeur 0 contrairement aux variables locales
qui reçoivent une valeur aléatoire lorsqu’elles ne sont pas initialisées.

Du fait de leur disponibilité très large, les variables globales risquent souvent de créer
des conflits. C’est pour cette raison qu’il faut limiter au maximum l’utilisation de ces
variables et privilégier l’utilisation des paramètres et des retours de fonction pour échanger
des valeurs entre les fonctions.

De plus, une variable globale peut être cachée : cela se produit lorsqu’une variable
locale d’une fonction possède le même nom qu’une variable globale. Dans ce cas, la variable
globale n’est plus accessible pour cette fonction.

Chapitre 10 OK

10/ Les erreurs.

Lors de l’écriture d’un programme, il y a de fortes chances pour qu’on rencontre des
erreurs de différents types que l’on devra corriger pour que le programme fonctionne
correctement. Ces corrections supposent que l’on soit capable de distinguer les différents
types d’erreur et de diagnostiquer chacune d’entre elle (c’est-à-dire de repérer en quoi elles
consistent et où est-ce qu’elles se situent dans le programme).

Les types d’erreur.

On distingue les différents types d’erreur par la façon dont elles se manifestent :

 Erreurs de syntaxe : ce type d’erreur apparaît lors de la compilation, et c’est

le compilateur qui va indiquer chacune d’entre elles, généralement dans une fenêtre
prévue à cet effet. Ce type d’erreur bloque la compilation et empêche la création ou la
mise à jour du fichier exécutable. Elles consistent en une mauvaise mise en place des
instructions qui ne respectent pas la syntaxe du langage C. Les cas les plus courants :
fautes d’orthographe dans les noms de fonction, omission d’un point-virgule, d’une
parenthèse, des accolades, ect…
 N.B : La compilation d’un fichier source dont l’exécutable est en cours d’exécution
vous affiche un message également.

 Erreurs de logique : ce type d’erreur apparaît lors de l’exécution, mais pas

sous la forme d’un message d’erreur. Elle se traduit par l’apparition d’un résultat
incohérent par rapport aux données sur lesquelles on a exécuté le programme. C’est
pour cette raison qu’il faut toujours tester un programme dans toutes les situations

26
 possibles (en particulier sur les cas particuliers) pour vérifier s’il ne contiendrait pas ce
genre d’erreur.
Les cas les plus courants : Se tromper de variable lors d’un affichage, se tromper de
code de format, se tromper dans l’utilisation des opérateurs ( +,-, *, /, ( = et = = dans
les conditions)), etc.…

 Erreurs de mémoire : ces erreurs sont des erreurs de logique qui peuvent se
manifester d’une façon particulière. Soit elles vont apparaître comme une simple
erreur de logique par un résultat incohérent, soit c’est le système d’exploitation qui va
arrêter l’exécution du programme et afficher un message d’erreur « système ». En
effet, les erreurs de mémoires sont appelées ainsi car elles sont issues d’une mauvaise
gestion de la mémoire de l’ordinateur contrôlée par le système d’exploitation. Les
causes de ces erreurs sont généralement liées à une mauvaise manipulation d’un
tableau ou d’un pointeur.
Les cas les plus courants sont les suivants : omission du symbole « & » dans un
« scanf », tentative d’accès à une cellule d’indice supérieur à la dimension d’un tableau
et tentative d’accès à une donnée d’un pointeur qui ne pointe sur rien ou sur NULL.

Chapitre 11

11/ Quelques fonctions prédéfinies pour la

manipulation des chaînes de caractères.

Rappel : la plupart de ces fonctions permettent de modifier une chaîne de caractères. Or, une
chaîne de caractères est avant tout un tableau et on a vu que pour les fonctions qui prennent un
tableau en paramètre, le langage C permet (grâce au formalisme des pointeurs qu’on étudiera
en Programmation 2) de ne pas avoir besoin de retourner un tel tableau. Par conséquent, pour
la plupart des fonctions sur les chaînes, on n’a pas besoin de se préoccuper du retour.

Chacune de ces fonctions est présentée par son en-tête.

Saisie (ou lecture) d’une chaîne de caractères : char* gets (char *S)
Cette fonction réalise la même opération que le fameux « scanf », mais uniquement sur
une chaîne. Le paramètre S représente la chaîne qui va recevoir ce que l’utilisateur va taper au
clavier.
Exemple : gets (mot) ; /* mot a été déclaré comme un tableau de type char */

Affichage d’une chaîne de caractères : char* puts (char *S)

Cette fonction réalise la même opération que le fameux « printf », mais uniquement
sur une chaîne. Le paramètre S représente la chaîne qu’on va afficher et qui sera
automatiquement suivie d’un saut de ligne.
Exemple : puts (mot) ; /* mot a été déclaré comme un tableau de type char */

27
Les fonctions suivantes appartiennent à la librairie « string.h ».

Comparaison de deux chaînes : int strcmp (char* ct, char* cs)

Cette fonction compare la chaîne représentée par ct avec la chaîne représentée par cs et
retourne le résultat suivant : si les deux chaînes sont identiques, elle retourne 0. Si ct est avant
cs dans l’ordre alphabêtique (selon la norme utilisée par le langage C), elle retourne une
valeur négative. Si ct est après cs dans l’ordre alphabêtique (selon la norme utilisée par le
langage C), elle retourne une valeur positive.

Exemple : x = strcmp (mot, « bonjour ») ; /* x a été déclaré comme une variable de type int
et mot a été déclaré comme
un tableau de type char */

Comparaison des premiers caractères de deux chaînes : int

strncmp (char* ct, char* cs, int N)
Cette fonction compare les N premiers caractères de la chaîne représentée par ct avec
les N premiers caractères de la chaîne représentée par cs et retourne le résultat suivant : si les
deux chaînes sont identiques, elle retourne 0. Si ct est avant cs dans l’ordre alphabétique
(selon la norme utilisée par le langage C), elle retourne une valeur négative. Si ct est après cs
dans l’ordre alphabétique (selon la norme utilisée par le langage C), elle retourne une valeur
positive.

Exemple : x = strncmp (mot, « bonjour », 4) ; /* x a été déclaré comme une variable de
type int et mot a été déclaré comme un tableau de type char */

28