Table des matières

1 Introduction 2

2 Démarche de la programmation 2
2.1 Définition du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2.2 Le formalisme du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2.2.1 Définition d’un algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2.3 La programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2.4 Compilation du programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.5 Exécution et test du programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

3 Généralités sur C 3

4 Structure générale d’un algorithme et d’un pg. en C 3

4.1 Structure générale d’un algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
4.2 Structure générale d’un programme C . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

5 Fichiers « include » 4

6 Les commentaires 4

7 Les types de bases 4

7.1 Le type entier ( int ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
7.2 Le type flottant ( float ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
7.3 Le type caractère ( char ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

8 Les constantes 6
8.1 Les constantes entières . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
8.2 Les constantes à virgules flottantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
8.3 Les constantes de types caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
8.4 Les constantes de type chaîne de caractères . . . . . . . . . . . . . . . . . . . . . . . 6
8.5 Les caractères de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

9 Les variables 7

10 Les opérateurs 7
10.1 Les opérateurs arithmétiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
10.2 Les opérateurs de comparaison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
10.3 Les opérateurs logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
10.4 L’opérateur d’affectation = en algo (←) . . . . . . . . . . . . . . . . . . . . . . . . . 8
10.5 Les opérateurs d’incrémentation et de décrémentation . . . . . . . . . . . . . . . . . . 9
10.5.1 Postfixe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
10.5.2 Préfixe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

11 Les entrées-sorties 10
11.1 Écriture formatée de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
11.2 Lecture formatée de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
11.3 La macro « getchar » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
11.4 La macro « putchar » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

1
 Ecole Polytechnique Sousse
Département d’Informatique
Section : Génie Informatique, AU : 2021-2022
Niveau : 3emeAnnée
CH1 : Introduction au langage C

1 Introduction
— Écrire un programme, ce n’est pas seulement connaître le langage de dialogue entre l’ordinateur
et vous.
— Un programme est un discours adressé à l’ordinateur, et comme tout discours, il présente deux
aspects : un contenu et une forme.
— La tâche la plus importante dans l’informatisation d’un problème réel est la phase de trans-
formation des objets réels en objet logique.

2 Démarche de la programmation
2.1 Définition du problème
Pour résoudre et automatiser un problème à l’aide d’un ordinateur, il est nécessaire de le définir
et de préciser les données qu’on dispose et les objectifs qu’on souhaite atteindre.
D’une manière générale, la définition d’un problème consiste à prévoir des réponses à tous les cas
envisageables.

2.2 Le formalisme du problème

— C’est la phase algorithmique.
— Elle fournit la méthode et la démarche que l’ordinateur va suivre pour résoudre le problème
posé.
— La phase la plus difficile de la résolution d’un problème n’est pas la traduction de l’algorithme
dans n’importe quel langage, mais c’est la conception de l’algorithme lui-même. Cette étape
est connue sous le nom d’analyse.

2.2.1 Définition d’un algorithme

Un algorithme est une suite finie d’instructions indiquant de façon précise l’ordre dans lequel doit
être effectué un ensemble d’opérations pour obtenir la solution d’un problème.

2.3 La programmation
C’est le passage du modèle logique qui est un algorithme au modèle directement exploitable
par l’ordinateur. Pour cela, il faut traduire l’algorithme en un programme écrit dans un langage de
3eme GI Langage C

programmation choisi par l’utilisateur.

Exemple : LANGAGE C, PYTHON, JAVA......

2.4 Compilation du programme

La compilation consiste à traduire le programme source écrit dans un langage de haut niveau en
un programme exécutable écrit dans un langage binaire de bas niveau.

Au cours de cette traduction, le compilateur détecte des éventuelles erreurs (lexicales et/ou syn-
taxiques)

2.5 Exécution et test du programme

Le concepteur de l’algorithme doit s’assurer que le programme donne un résultat correct dans
tous les cas et dans toutes les éventualités. Il faut ainsi valider et tester le programme construit.
Pour ce faire, on procède de la sorte :
— On construit des jeux d’essai, c-a-d des échantillons de données de base correspondant aux
différents cas,
— On exécute le programme pas à pas sur l’ordinateur,
— On vérifie l’exactitude des résultats fournis par le programme,
— Si tous les résultats sont valides
— accepter le programme (Jusqu’à preuve du contraire)
— le documenter.
— Si non
— réviser l’algorithme et le modifier

3 Généralités sur C
— Le langage C a été créé dans les années 1970 par Dennis Rithcie.
— Un programme en langage C est une suite d’instructions.
— Un programme en C est un ensemble de fonctions, parmi ces fonctions, il existe une fonction
de démarrage dont le nom est "main".

4 Structure générale d’un algorithme et d’un pg. en C

4.1 Structure générale d’un algorithme
ALGORITHME nom_algorithme
CONST
L i s t e d es c o n s t a n t e s avec l e u r s v a l e u r s
TYPE
L i s t e d es t y p e s d é f i n i s par l ’ u t i l i s a t e u r
VAR
L i s t e d es v a r i a b l e s s u i v i e s de l e u r s t y p e s
DÉBUT
L i s t e d es a c t i o n s ou l i s t e d ’ i n s t r u c t i o n s
FIN

Kais Ben Salah 3

3eme GI Langage C

4.2 Structure générale d’un programme C

#i n c l u d e . . . . . . . . . . .
v o i d main ( )
{
< D é c l a r a t i o n s >;
< I n s t r u c t i o n s >;
}
Remarque : Chaque programme en C doit renfermer une fonction du nom de "main"(Fonction
principale de chaque programme C).

5 Fichiers « include »
— Se trouvent dans un répertoire nommé "include",
— Ils possèdent l’extension h,
— Ils renferment les déclarations des fonctions du système.
Exemple :
#i n c l u d e <s t d i o . h> ( Fi ch ier s d ’ entrée , s o r t i e ) .
#i n c l u d e <math . h> ( F i c h i e r s Mathématiques ) .
#i n c l u d e <s t r i n g . h> ( F o n c t i o n s s u r l e s c h a i n e s de c a r a c t è r e s ) .
Exemple :

#i n c l u d e <s t d i o . h>
v o i d main ( )
{
p r i n t f ( " Bonjour " ) ;
}

6 Les commentaires
Un commentaire est une suite de caractères placés entre les délimiteurs.
Exemple :
/*Les commentaires documentent les programmes */
Ajoutons un commentaire au programme précédant :
#i n c l u d e <s t d i o . h>
v o i d main ( )
{
p r i n t f ( " Bonjour " ) ; /∗ A f f i c h a g e d ’ un message ∗/
}

7 Les types de bases

Les différents types de bases sont :
— Les nombres entiers int ( entier en algo)
— Les nombres flottants float ou double( réel en algo)
— Les caractères char ( caractère en algo.)
— Les chaines de caractères.
— Le type bool ( booléen en algo.)

Kais Ben Salah 4

3eme GI Langage C

7.1 Le type entier ( int )

Ils existent plusieurs types :
Type Désignation Occupation Plage de valeurs
mémoire
entier court short int (short) 2 octets -32768 à 32767
entier court non signé unsigned short 2 octets 0 à 65535
Entier (type standard) int 4 octets -32768 à 32767
entier non signé unsigned int 4 octets 0 à 65535
entier long long int (long) 4 octets -2 147 483 648 à 2 147 483 647
entier long non signé unsigned long 4 octets 0 à 4 294 967 295

7.2 Le type flottant ( float )

Un nombre réel en C est dit nombre à virgule flottante. C’est un nombre dans lequel la position
de la virgule en tant que séparateur entre partie entière et partie décimale n’est pas fixe.
Exemple :
Nombre = 14.8
— Représentation 1 : 1.48 ∗ 101
— Représentation 2 : 0.148 ∗ 102
— Représentation 3 : 148.0 ∗ 10−1

Type Désignation Nombre Occupation Plage de valeurs

de chiffres mémoire
significa-
tifs de la
mantisse
Réel simple float 6 4 octet 3.4 ∗ 10−38 à 3.4 ∗ 1038
précision
Réel double double 15 8 octet 1.7∗10−308 à 1.7∗10308
précision
Réel avec long double 19 10 octets 3.4 ∗ 10−4932 à3.4 ∗
précision 104932
étendue

7.3 Le type caractère ( char )

— Il est utilisé pour représenter un caractère.
— Le type char (du mot anglais character, "caractère") et utilisé pour représenter un caractère,
plus précisément la valeur entière d’un élément de l’ensemble des caractères représentables.
Ce nombre entier est le code ASCII du caractère.
Exemple :
Le caractère ’A’ est stocké sous forme char. L’ordinateur n’écrit pas le signe A, mais le nombre 65
(code ASCII de ’A’) sur 1 octet = 01000001.
Ils existent 2 types différents :

Type Désignation Occupation Plage de valeurs

mémoire
caractère char 1 octet -128 à 127
caractère non signé unsigned char 1 octet 0 à 255

Kais Ben Salah 5

3eme GI Langage C

8 Les constantes
Les constantes sont utilisées pour calculer des valeurs, pour initialiser des variables, etc.

8.1 Les constantes entières

Exemples :
-9, 0, 199

8.2 Les constantes à virgules flottantes

Exemples :
21E-4, -4005E3, 3.141, 314.1E-2

8.3 Les constantes de types caractères

Exemples :
’a’, ’A’, ’ ?’, ’1’.
— code ASCII(’A’)=65
— code ASCII(’a’)=97
— code ASCII(’0’)=48

8.4 Les constantes de type chaîne de caractères

— Une chaîne peut ne comporter aucun caractère : "" (appelée la chaîne vide).
— Le compilateur insert automatiquement un caractère nul 0 \ 00 à la fin de chaque chaîne de
caractères : une chaîne de caractères est ainsi une séquence ordonnée de caractères qui se
termine par 0 \ 00 .
Remarque Il existe plusieurs types de constantes, dont les plus importants sont les constantes non
typées (appelées aussi constantes préprocesseur) et typées.

a)Les constantes non typées

Avec la commande "#define", il est possible de donner un nom symbolique à une constante littérale
définies dans les fichiers d’entête ou dans le texte du programme (de préférence au début).
Syntaxe :
#define <NomConstante> <Valeur>
Exemple :
#define MAX 100
#define PI 3.14
#define car ’i’

b)Les constantes typées

Ces constantes sont déclarées avec le modificateur "const". Ce sont des variables dont la valeur
n’est pas modifiable, sauf au niveau de leurs déclarations. Pour déclarer une telle constante, il suffit
d’ajouter le mot réservé "const" avant son type.
Syntaxe :
const <TypeVariable> < NomVariable > = <ValeurVariable> ;
Exemple :
const float e = 2.71 ;
const int MAX=100 ;

Kais Ben Salah 6

3eme GI Langage C

8.5 Les caractères de contrôle

Séquence Signification
\n Génère une nouvelle ligne
\t Pose une tabulation horizontale
\f Provoque un saut de page
\a Déclenche un signal sonore
\r ramène le curseur au début de la ligne courante.

Exemples
1. Saut de ligne : ( \n)
printf("Voici \n un \n programme C.") ;
Résultat : Voici un programme C.
2. Tabulations : (\t) printf("Voici \t un \t programme C.") ;
Résultat : Voici un programme C.
3. Retour-chariot : ( \r) printf("Voici un programme C.\r Voici un programme C.") ;
Résultat : Voici un programme C.

9 Les variables
Une variable :
— possède un nom,
— possède un type,
— possède un contenu,
— est modifiable,
— est rangée en mémoire à partir d’une certaine adresse.
Syntaxe
Type NomVar1, NomVar2............, NomVarN ;
Type NomVar1= val1, NomVar2= Val2........, NomVar N= ValN ;
Exemples
— char c ;
— int X, Y ;
— float Z = 4.5 ;
— double W ;
— int t_presse

10 Les opérateurs
10.1 Les opérateurs arithmétiques
— +, -, /( en algo : division entière : DIV, division réelle : /),*
— % Modulo ( MOD en algo) : reste de la division entière.
Remarque :
— Si les deux arguments de / sont des entiers alors le résultat est un entier.
— Le résultat de x= 3/2 est 1, même si x est déclaré de type float.
— Le résultat de x= 3.0/2 ( ou 3/2.0 ) est 1.5.
— Pas d’opérateur d’évaluation en puissance, (On utilise la fonction P ower(x, y) = xy ).

Kais Ben Salah 7

3eme GI Langage C

10.2 Les opérateurs de comparaison

— <, <=, >, >=,
— = = ( en algo =) :égal à, != ( en algo : 6=) : diffèrent de.
— Le résultat d’une comparaison est un entier
* 0 ( an algo : faux) si le résultat est faux
* 1 ( an algo : Vrai)si le résultat est vrai.
— La comparaison devient une expression de type entier.
Remarque : La comparaison peut retourner true or false en C en utilisant la biblihotèque (stdbool.h
et le type : bool)

10.3 Les opérateurs logiques

— δδ =⇒ Et(en algorithme)
— || =⇒ Ou(en algorithme)
— ! =⇒ N on(en algorithme)
Exemples
— (a < b)δδ(c < d)
Prend la valeur 1(vrai) si les deux expressions a < b et c < d sont toutes deux vraies et la
valeur 0 dans le cas contraire.
Remarque
— !(a==b) est différent de !a==b
— if (n) ⇐⇒ if (n !=0)
— if( !n) ⇐⇒ if (n==0)

10.4 L’opérateur d’affectation = en algo (←)

— Les opérateurs d’affectation mettent dans leur opérande de gauche la valeur de leur opérande
de droite.
— L’opérande de gauche est appelé une Lvalue
— Les affectations sont évaluées de la droite vers la gauche.
Affectation simple
Exemple 1
int x ;
x =1 ;
La variable x du membre droit de l’affectation reçoit la valeur 1 .
Exemple 2
int x , y ;
x= y= 1 ;
Affecte la valeur 1 aux deux variables (x=1 et y=1).
Affectation combinée :
Les affectations combinées mélangent une opération d’affectation avec une opération arithmétique
ou logique.
Exemple X+ = Y ⇐⇒ X = X + Y
X− = Y ⇐⇒ X = X − Y
X∗ = Y ⇐⇒ X = X ∗ Y
X/ = Y ⇐⇒ X = X/Y
X% = Y ⇐⇒ X = X%Y

Kais Ben Salah 8

3eme GI Langage C

10.5 Les opérateurs d’incrémentation et de décrémentation

Les opérateurs d’incrémentation et de décrémentation unaires ++ et – augmentent (incrémentent)
ou diminuent (décrémentent) la valeur d’une variable de la quantité 1.
* x + + ⇐⇒ + + x ⇐⇒ x = x + 1
* x − − ⇐⇒ − − x ⇐⇒ x = x − 1

10.5.1 Postfixe
Un opérateur de post-incrémentation ou de post-décrémentation entraîne que son opérande est
d’abord utilisé, puis incrémenté ou décrémenté.
Exemple 1

int x = 1, y ;
y = x++;

Résultat :
1. La variable y est affectée la valeur de la variable x, avant que celle-ci ne soit incrémentée, donc
y=1,
2. x augmente de 1 (x=2).

10.5.2 Préfixe
Un opérateur de pré-incrémentation ou de pré-décrémentation entraîne que son opérande est
incrémenté ou décrémenté avant d’être utilisé.
Exemple 1

int x=1,y;
y= ++x;

Résultat :
1. x augmente de 1 ( x = 2 ),
2. y ne prend pas la valeur d’origine de x, mais la valeur accrue de 1 (y= 2).
Remarque :
1- L’opérateur de cast qui permet de convertir explicitement le type d’une donnée en un autre type
(conversion forcée).

Exemple :
i n t n = 5 , p=2;
float x ;
x = ( f l o a t ) n/p ;
— n/p donne un entier (2)
— le quotient réel de la division sera obtenu après conversion de n en réel par la conversion forcée,
puis (n/p) sera affecté à x dont la valeur sera 2.5

2- l’opérateur sizeof(type) renvoie le nombre d’octets réservés en mémoire pour chaque type d’objet.
Exemple : n = sizeof(int) ; /* n vaut 4 */

Kais Ben Salah 9

3eme GI Langage C

11 Les entrées-sorties
La bibliothèque standard <stdio> contient un ensemble de fonctions qui assurent la communica-
tion de la machine avec le monde extérieur. Dans ce chapitre ; nous allons nous en discuter des plus
importantes :
— printf () (Écrire en algo) : écriture formatée de données
— scanf () (Lire en algo) : lecture formatée de données
— putchar() : écriture d’un caractère
— getchar() : lecture d’un caractère

11.1 Écriture formatée de données

a) Syntaxe :

printf("<format>", <expr 1>, <expr 2>,....... , <expr n>)

b) Rôle :
Elle permet d’afficher sur l’écran, du texte, des valeurs de variables ou des résultats d’expressions
dans le format choisi.
Le format est une chaîne de caractères qui peut contenir des séquences d’échappement et des codes de
format, à raison d’un code par expression. Les codes de format commencent toujours par le symbole
% et se terminent par un ou plusieurs caractères qui indiquent le format d’affichage
Symboles de conversion :
Il indique la nature de la conversion de type à effectuer.

Symbole Objet de donnée

d, i Entier relatif
u Entier naturel (unsigned)
o Entier exprimé en octal
x,X Entier exprimé en hexadécimal
c caractère
f Réel en notation décimale
e, E Réel en notation exponentielle
s Chaîne de caractères

Exemple 1
1. printf ("%d",5) ;
Résultat : 5
2. i n t i = 5 ;
p r i n t f ("%d " , i ) ;
Résultat : 5
3. i n t i = 5 ;
p r i n t f ("%d p l u s %d donne : %d " , 1 0 0 0 , i , i +1000);
Résultat : 1000 plus 5 donne : 1005.
Remarque :
Par défaut, les nombres sont affichés avec le nombre de caractères nécessaires.
Format : % nb d
Si nb > nombre de caractères =⇒ Ajout de blanc

Exemple2

Kais Ben Salah 10

3eme GI Langage C

printf("%3d",N);
N = 3 --> ~~3
N= -5200 --> -5200
~ : représente un blanc

Exemple 3

printf ("%f",x);
x = 1.2345 --> 1.234500
x = 12.3456789 --> 12.345679

Exemple 4

printf ("%10f",x);
x= 1.2345 --> ~~1.234500

Exemple 5

printf("%e",x);
x = 1.2345 --> 1.234500e+000
x = 123.45 --> 1.234500e+002

1 chiffre avant la virgule, 6 chiffres après la virgule et 3 chiffres après le "e"

11.2 Lecture formatée de données

a) Syntaxe :

scanf("<format>", <&var1>, <&var 2>, ........ , <&var n>)

b) Rôle :
Elle permet de lire des données à partir du clavier, dans le format spécifié. Les valeurs lues par scanf()
sont rangées dans les adresses spécifiées. L’adresse (adr) d’une variable est indiquée par le nom de la
variable précédé du signe (&).
Symbole de conversion :
Mêmes symboles que ceux de printf().
Exemple 1 :
int x ;
s c a n f ("%d" ,& x ) ;
L’opérateur d’adressage & applique au nom de la variable, il informe donc la fonction « scanf » de
l’emplacement de stockage de la valeur saisie.

Figure 1 – Valeur et adresse d’une variable « int » en mémoire

Exemple 2 :
Lors de l’entrée des données, une suite de signes d’espacement (espaces, tabulateurs, interlignes) est
évaluée comme un seul espace.
Pour la suite d’instructions :

Kais Ben Salah 11

3eme GI Langage C

i n t j o u r , mois , annee ;
s c a n f ("%d%d%d" ,& j o u r , &mois , &annee ) ;
Les entrées suivantes sont correctes et équivalentes :
— 22 10 2013
— 22 10 2013
— 22
10
2013

11.3 La macro « getchar »

— Une macro est un nom qui représente une ou plusieurs instructions ou expressions.
— La macro « getchar » lit un caractère isolé depuis le clavier et le met à la disposition du
programme.
Exemple :
# i n c l u d e <s t d i o . h>
v o i d main ( )
{ char c a r l u ;
p r i n t f ( " Entrez un c a r a c t è r e . \n " ) ;
c a r l u= g e t c h a r ( ) ; /∗ L e c t u r e d ’ un c a r a c t è r e v i a « g e t c h a r »
/∗ e t a f f e c t a t i o n du c a r a c t è r e a l a v a r i a b l e c a r l u ∗/
p r i n t f ( " \ n l e c a r a c t è r e s a i s i e s t %c : " , c a r l u ) ;
}

11.4 La macro « putchar »

— La macro « putchar » affiche un caractère non formaté sur l’écran.
— La donnée à afficher est écrite sous forme de paramètre entre les parenthèses de la macro.
Exemple
#i n c l u d e <s t d i o . h>
v o i d main ( )
{ char c a r l u ;
p r i n t f ( " Entrez une l e t t r e \n " ) ;
carlu = getchar ( ) ;
pu tcha r ( c a r l u ) ;
}

Kais Ben Salah 12