Département : Génie Informatique et Systèmes Intelligents

Tranc Commun : Informatique Appliquée (S1)

Module : Algorithmique I

Module : Programmation C I

Chapitre 2 : Notions et Instructions

Simples d’un Algorithme et Langage C

rPr. El mehdi Cherrat Année Universitaire : 2023/2024

 IA-1

Table des matières

I. Introduction :.............................................................................................................................................. 2
1. Notion d’un algorithme : ........................................................................................................................ 2
2. Résolution informatique d’un problème : ...................................................................................... 2
3. Langages informatiques :....................................................................................................................... 3
3.1. Langage machine : .................................................................................................................................... 3
3.2. Langage évolué :......................................................................................................................................... 3
Exemple : ................................................................................................................................................................. 3
3.3. Langage et traducteurs ........................................................................................................................... 4
a. Interpréteurs .............................................................................................................................................. 4
b. Compilateurs............................................................................................................................................... 4
b.1. Etapes de compilation en langage C : ................................................................................................ 5
II. Les instructions de base d’un algorithme et langage C .............................................................. 5
1. Les données : ............................................................................................................................................... 5
1.1. Nom de la donnée : ........................................................................................................................... 5
1.2. Nature de la donnée : ....................................................................................................................... 6
1.2.1. Notion de la constante : .......................................................................................................... 6
1.2.2. Notion de la variable :.............................................................................................................. 6
1.3. Types des données : .......................................................................................................................... 6
1.4. Déclaration des données :.............................................................................................................. 7
2. Instruction simples d’un algorithme et langage C:...................................................................... 8
2.1. L’instruction d’affectation : .......................................................................................................... 8
2.2. L’instruction d’écriture................................................................................................................... 9
2.3. L’instruction de lecture : .............................................................................................................. 10
3. Expression et opérateurs :................................................................................................................... 11
3.1. Expression : ....................................................................................................................................... 11
3.2. Opérateur : ......................................................................................................................................... 11
3.2.1. Opérateurs numériques : ..................................................................................................... 11
3.2.2. Opérateurs logiques :............................................................................................................. 12
3.2.3. Opérateurs de comparaison : ............................................................................................. 13
4. Structure générale d’un algorithme et langage C : .................................................................... 13

Chapitre 2 : Notions et Instructions Simples d’un Algorithme et Langage C

1
 IA-1

I. Introduction :
Les algorithmes sont présents dans notre vie, nous les exécutons ou nous les faisons
exécuter tous les jours.
Avons-nous déjà essayé de faire fonctionner un appareil électronique à l’aide de son guide,
lu une recette de cuisine, ou guidé quelqu’un à retrouver un quartier ou une faculté ? Si oui et
sans le savoir, nous avons exécuté des algorithmes.
1. Notion d’un algorithme :

Un algorithme est une suite d’actions ou d’instructions élémentaires qui doivent se dérouler
dans un ordre bien précis afin de résoudre un problème (ou réaliser un travail).

Le mot algorithme provient du nom du mathématicien musulman Al-Khawarizmi (783-850)

qui a développé entre autre des méthodes pour résoudre des équations algébriques.

Un algorithme peut être spécifié de différentes manière :

• Langage naturel
• Pseudocode
• Organigramme
• Programme

En l’informatique, l’ordinateur exécute aussi des algorithmes sauf qu’il est une machine
non intelligente, c'est-à-dire qu’il n’est pas capable de résoudre des problèmes sans une
description détaillée des actions à faire.

La rédaction des algorithmes permet plusieurs choses :

• d'être compréhensible par tous informaticien même s'il ne connait pas le langage du
programme

• de vérifier la complexité du programme et donc de l'optimiser

• de faire ressortir de manière compréhensible les cas d'utilisations

2. Résolution informatique d’un problème :

La résolution informatique d’un tel problème comporte les étapes suivantes :

Etape 1 : Analyse du problème :

o Description des données connues (qu’est-ce que j’ai ?) et des résultats cherchés
(qu’est-ce que je veux ?).
o Identifier les relations entre les données.
o Décrire les traitements à effectuer (comment faire ?).
Dans cette étape, on dispose d'un processus informatique de résolution appelé algorithme.
Etape 2 : traduction de l’algorithme :
Cette étape consiste à traduire de l’algorithme dans un langage compréhensible par
l’ordinateur, appelé langage de programmation.
Etape 3 : Exécution:
L’exécution du programme par l’ordinateur.

Chapitre 2 : Notions et Instructions Simples d’un Algorithme et Langage C

2
 IA-1

3. Langages informatiques :
On distingue 2 catégories de langages.
3.1. Langage machine :
Ce sont des langages utilisant des mots formés uniquement de 0 et de 1. Ces langages
sont l’avantage d’être compréhensible par la machine et le fonctionnement interne de la
machine. Ils sont néanmoins, utilisés par des programmes nécessitant des exécutions
rapides.
3.2. Langage évolué :
Dans le but de faciliter l’accès de l’informatique à un plus grand nombre de personne, ils
ont été amenés à créer des langages dont les mots sont proches d’une langue parlée (souvent
Anglais).
Ces langages présentent l’avantage d’être universels dans la mesure où ils ne dépendent pas
de la machine qui les utilise. Ces langages évolués (langages de programmation) ont été
généralement crée en fonction d’une orientation donnée.

Exemple :
Le langage C créé entre 1969 et 1973 et il est un langage bas niveau. C’est donc a priori
plus difficile. Mais grâce à ces bases solides, vous serez ensuite capable d'apprendre beaucoup
plus rapidement un autre langage de programmation si vous le désirez. Et avec plus
d’autonomie ! Par ailleurs, le C est un langage très populaire. Il est utilisé pour programmer
une grande partie des logiciels que vous connaissez. C'est un des langages les plus connus et
les plus utilisés qui existent. Le langage C est à la base des plus grands systèmes d'exploitation
tels UNIX (et donc Linux et Mac OS) ou Windows.
Chapitre 2 : Notions et Instructions Simples d’un Algorithme et Langage C
3
 IA-1

3.3. Langage et traducteurs

Tout programme écrit en langage évolué doit être traduit en langage machine afin de
pouvoir être exécuté.
On distingue 2 catégories de traducteurs (programme spécial qui permet le passage du
langage évolué vers le langage machine).
a. Interpréteurs
Un interpréteur est un logiciel qui lit et exécute le code source ligne par ligne ou
instruction par instruction sans générer de fichier binaire intermédiaire.
L'interpréteur traduit le code source en code machine à la volée, ce qui signifie que le
programme est exécuté directement à partir du code source.
Les langages de programmation couramment associés à des interpréteurs comprennent
Python, JavaScript, Ruby, et d'autres langages de script.

b. Compilateurs
Un compilateur est un logiciel qui traduit tout le code source d'un programme en un
langage machine ou en code binaire avant de l'exécuter.
Le processus de compilation se déroule en deux étapes : d'abord, le code source est
analysé et vérifié pour les erreurs, puis il est traduit en code machine ou en code intermédiaire
(comme le bytecode dans le cas de langages comme Java). Le fichier résultant est appelé "code
compilé" ou "exécutable".
Après la compilation, le programme peut être exécuté plusieurs fois sans avoir besoin
d'une nouvelle phase de compilation, sauf si des modifications sont apportées au code source.
Les langages de programmation couramment associés à des compilateurs comprennent
C, C++, et d’autres.

Voici quelques différences clés entre les compilateurs et les interpréteurs :

Les compilateurs produisent un exécutable indépendant du code source, tandis que les
interpréteurs nécessitent le code source pour chaque exécution.

Les compilateurs ont tendance à optimiser le code lors de la compilation, ce qui peut
entraîner des performances supérieures, tandis que les interpréteurs exécutent généralement
le code moins rapidement, car ils traduisent le code à la volée.

Chapitre 2 : Notions et Instructions Simples d’un Algorithme et Langage C

4
 IA-1

Les erreurs de compilation sont détectées avant l'exécution pour les compilateurs, tandis que
les erreurs dans le code source peuvent être détectées au fur et à mesure de l'exécution pour
les interpréteurs.
b.1. Etapes de compilation en langage C :
Les étapes de compilation en langage C sont un processus en plusieurs étapes qui
permet de transformer un code source C en un programme exécutable. La figure suivante
illustre les étapes de la compilation en C :

II. Les instructions de base d’un algorithme et langage C

1. Les données :
Pour résoudre un problème informatique, un algorithme aura recours souvent à des
données portant des valeurs, qui doivent être traitées afin de fournir des résultats qui peuvent
eux ainsi êtres des données. Ainsi une donnée est caractérisée par :
▪ Son nom
▪ Sa nature
▪ Son type
1.1. Nom de la donnée :

Le nom de la donnée ou l’étiquette est utilisé pour identifier une donnée.

Ce nom est écrit principalement sous la forme d’une chaine de caractère constituée de
lettres non accentuée, de chiffres et du caractère « _ », et commence obligatoirement par un
alphabet.

Le nom de la donnée doit être le plus représentatif possible du contenu de celle-ci pour
faciliter la lecture de l’algorithme. En revanche, il ne doit pas non plus être trop long pour ne
pas nuire à la lisibilité de l’ensemble.

Exemples :
Le nom « ma_donnee » : est valide.
Le nom « ma-donnee » : n’est pas valide (contient le caractère « - »).
Le nom « madonnee » : est valide.
Chapitre 2 : Notions et Instructions Simples d’un Algorithme et Langage C
5
 IA-1

Le nom « ma@donnee » : n’est pas valide (contient le caractère «@»).

Le nom « madonnée » : n’est pas valide (contient une lettre accentuée).
Le nom « donnee1 » : est valide.
Le nom « don12nee » : est valide.
Le nom « 3donnee » : n’est pas valide (contient par un chiffre).

1.2. Nature de la donnée :

Les données sont nécessaires au déroulement d’un algorithme. On distingue deux catégories
simples : les constantes et les variables.

1.2.1. Notion de la constante :

Une constante est une donnée fixe qui ne varie pas durant l’exécution d’un algorithme. Une
constante est caractérisée par son nom et sa valeur fixe.

1.2.2. Notion de la variable :

Une variable est le nom d’un espace mémoire dont le contenu peut être modifié par une action
durant l’exécution d’un algorithme. Une variable est caractérisée par son nom et son type.

1.3. Types des données :

Une variable peut contenir différents types de données et de tailles différents de données.

La déclaration d’une donnée avec un type permet de réserver une place mémoire dont la taille
peut varier selon le type choisi.

Il existe plusieurs types de données, nous allons nous limiter ici aux types classiques de
données. Ainsi on distingue :

Type Entier : les données de type Entier peuvent contenir toutes les valeurs numériques
entières (positives et négatives).

Type Réel : les données de type Réel peuvent contenir toutes les valeurs numériques avec ou
sans virgule (positives et négatives).

Type Caractère : les données de type Caractère peuvent contenir tout caractère figurant sur
le clavier de votre ordinateur. Ces valeurs doivent être délimitées par des guillemets.

Type Chaîne de caractères : le type Chaîne de caractère peut contenir une suite de
caractères (un mot, une phrase ou même un texte). Ces valeurs doivent être délimitées par des
guillemets.

Type logique : ce type ne supporte que deux valeurs VRAI ou FAUX.

Chapitre 2 : Notions et Instructions Simples d’un Algorithme et Langage C

6
 IA-1

Exemples :

Type de données Langage c Exemples de valeurs

Entier int 13 ;-66 ;15515 ;-988…
Réel float 11.55 ; 0 ; 9/5 ; -48…
Caractère char ‘a’ ; ‘b’ ; ‘9’ ; ‘A’ ; ‘+’ ; ‘@’
Chaîne de caractères char ‘FSAAM’ ; ‘Hello word’ ;…
Logique bool VRAI ; FAUX

Voici un tableau donnant les types de données, taille en octet et plage de valeurs acceptée en
langage C :

Type de donnée Signification Taille (en octets) Plage de valeurs acceptée

short int Entier court 2 -32 768 à 32 767
unsigned short int Entier court non signé 2 0 à 65 535
int Entier 4 -2 147 483 648 à 2 147 483 647
unsigned int Entier non signé 4 0 à 4 294 967 295
long int Entier long 4 -2 147 483 648 à 2 147 483 647
unsigned long int Entier long non signé 4 0 à 4 294 967 295
float Flottant (réel) 4 3.4*10-38 à 3.4*1038
double Flottant double 8 1.7*10-308 à 1.7*10308
long double Flottant double long 10 3.4*10-4932 à 3.4*104932

1.4. Déclaration des données :

Comme on l’a déjà précisé, une donnée peut être de nature constante ou variable.

Pour déclarer une constante, on utilise la syntaxe suivante :

Syntaxe en algorithme :

Constante Nom _Constante Valeur

Ou
Constante Nom _Constante1 Val1, Nom _Constante1 Val2,…

Exemples :

Algorithme Langage c
Constante Pi 3,14 #define Pi 3.14 ou const float Pi=3.14
Constante e 2,71 #define e 2.71 ou const float e=2.71

Remarque :
Dans le langage c :
• #define et const (qualificateur de type) permettent de définir une constante

Chapitre 2 : Notions et Instructions Simples d’un Algorithme et Langage C

7
 IA-1

La déclaration des constantes dans l’algorithme fait sans préciser le type de données, alors que
la syntaxe de déclaration des variables nécessite une précision de type et est donnée par :

Syntaxe en algorithme :

Variable Nom_Variable : Type _Variable

Ou
Variable Nom_Var1, Nom_Var2,…….. : Type _Variable
Ou
Variable Nom_Var1, Nom_Var2,…….. : Type _Variable1
Nom_Var3, Nom_Var4,…….. : Type _Variable2
…. … …
Nom_Var5, Nom_Var6,…….. : Type _Variable3

Syntaxe en langage c:

Type _Variable Nom_Variable ;

En C il existe plusieurs types entiers, dépendant du nombre d'octets sur lesquels ils sont
codés ainsi que de leur format, c'est-à-dire s'ils sont signés (possédant le signe - ou +) ou non.
Par défaut les données sont signées.

Exemples :

Algorithme Langage c
Variable Nb_Eleves : entier int Nb_Eleves ;
Variable Note : réel float Note ;
Variable Operateur : caractère char Operateur ;
Variable Prenom : chaines de caractères char Prenom [20] ;

Variable A : booléen bool A ;

Remarque : Toute instruction en langage c se termine obligatoirement par un point-virgule ;

2. Instruction simples d’un algorithme et langage C:

Nous allons aborder dans ce paragraphe les instructions de base à utiliser dans un
algorithme, à savoir :

L’affectation
La lecture
L’écriture
2.1. L’instruction d’affectation :

L’affectation est une opération qui consiste à attribuer une valeur à une variable. Elle est
représentée par une flèche orientée à gauche  dans algorithme et = dans Langage c.

Chapitre 2 : Notions et Instructions Simples d’un Algorithme et Langage C

8
 IA-1

Syntaxe :

Algorithme Langage c
Nom_VariableValeur ou expression Nom_Variable=Valeur ou expression ;

Exemples :

Algorithme Langage c
Nb_Eleves 35 Nb_Eleves= 35 ;
Note17,89 Note=17.89 ;
Opérateur’C’ Opérateur=‘C’ ;
Prénom’ Ahmed’ Prénom[] = ‘Ahmed’ ;
ATrue A=True ;
AFalse A=False ;

On suppose X10

Algorithme Langage C Résultat

XX+10 X=X+10 ou X+=10 20
XX-10 X=X-10 ou X-=10 0
XX×10 X=X*10 ou X*=10 100
XX/10 X=X/10 ou X/=10 1
XX%10 X=X%10 ou X%=10 0

2.2. L’instruction d’écriture

L’instruction d’écriture permet au programmeur d’afficher une information à l’écran (afficher

un message ou encore des valeurs issues d’un calcul,). La syntaxe d’utilisation est la suivante :

Algorithme Langage c
Ecrire ("message") printf("message") ;

Ecrire (variable) ou Ecrire (Var1,Var2,…) printf(variable) ;

Ecrire ("message", variable) printf("message %formatVariable ", variable) ;

Exemples :

Algorithme Langage c Affiche à l’écran

Ecrire ("Bonjour") printf("Bonjour") ; Bonjour
A15 A=15 ;
15
Ecrire (A) printf(A) ;
Ecrire ("Le nombre saisie est ", A) printf("Le nombre saisie est %d ", A) ; Le nombre saisie est 15

Chapitre 2 : Notions et Instructions Simples d’un Algorithme et Langage C

9
 IA-1

Remarques :
• Le %d sera remplacé par la variable indiquée après la virgule, à savoir A.
• Le tableau suivant vous propose les principaux formats utilisables avec Langage c.

%d Une donnée entière de type int

%ld Une donnée entière de type long.
%f Une donnée décimale de type float.
%lf Une donnée décimale de type double.
%c Une donnée de type caractère.
%s Une donnée de type chaîne de caractères

• Les caractères spéciaux en langage C sont des lettres spéciales qui permettent d’indiquer
qu'on veut aller à la ligne, faire une tabulation, etc. Ils sont faciles à reconnaître : c’est
un ensemble de deux caractères. Le premier d’entre eux est toujours un anti-slash ( \ ),
et le second un nombre ou une lettre. Voici deux caractères spéciaux courants que vous
aurez probablement besoin d'utiliser, ainsi que leur signification :
\n : retour à la ligne « Entrée » ;
\t : tabulation.
• Lorsqu'un programme devient long, il est conseillé d’ajouter des lignes de commentaires
dans le programme, c’est-à-dire des lignes qui ont pour but de donner des indications
sur les instructions effectuées et d’expliquer le fonctionnement de programme sans que
le compilateur ne les prenne en compte. Les deux types de commentaires sont :

Commentaire sur une ligne : // un commentaire

Commentaire sur plusieurs lignes : /* commentaires */

2.3. L’instruction de lecture :

En général un algorithme doit échanger des données avec l’utilisateur. En fait, l’instruction
d’écriture déjà vu, permet d’afficher des messages et des valeurs à l’écran.

L’instruction de lecture quant à elle permet à l’utilisateur de fournir des valeurs à

l’algorithme en vue d’un éventuel traitement ou calcul. Dès que le programme rencontre une
instruction de lecture, l’exécution s’interrompe, attendant frappe d’une valeur au clavier.

La syntaxe d’utilisation est la suivante :

Algorithme Langage c
Lire (Variable) scanf (" %format Variable ", & Variable) ;

Lire (Variable) scanf (" % formatVar1 %format formatVar2 ", & Var1, & Var2 ) ;

Exemples :
• Lire(A) : Le programme donne la main à l’utilisation pour saisir une valeur (validation
par la touche « Entrée ») et l’affecte à la variable A.
• Lire(A,B) : Le programme donne la main à l’utilisateur pour saisir la première et la
deuxième valeur et les affecte successivement à la variable A et B.
Chapitre 2 : Notions et Instructions Simples d’un Algorithme et Langage C
10
 IA-1

Algorithme Langage c
Variable Nb: entier int Nb;
Lire (Nb) scanf ("%d",&Nb) ;
Variable note: réel float note;
Variable valide: caractère char valide;
Lire (note,valide) scanf ("%f%c",& note,&valide) ;

Attention : Lorsqu’il d’agit d’une chaîne de caractère il faut enlever l’adresse et mettre
directement la variable chaîne de caractère. Par exemple, scanf("%s",chaine) ;

3. Expression et opérateurs :
3.1. Expression :

Si on fait le point, on s’aperçoit que dans une instruction d’affectation, on trouve :

A gauche de la flèche, un nom de variable, et uniquement cela.

A droite de la flèche, ce qu’on appelle une expression.

Une expression est un ensemble de valeurs, reliées par des opérateurs, et équivalent à une seule
valeur.

3.2. Opérateur :

Un opérateur est un signe qui relie deux valeurs pour produire un résultat. Les opérateurs
possibles dépendent du type des valeurs qui sont en jeu.

3.2.1. Opérateurs numériques :

Ce sont les quatre opérateurs arithmétiques classiques, l’opérateur de puissance et de modulo.

Il s’agit :

Opérateur Opérations mathématiques Instruction C

+ Addition +

- Soustraction -

× Multiplication *

/ Division /

^ Puissance pow

% Reste de division (modulo) %

Remarques :

1. La fonctionnalité pow ou les autre principales fonctions usuelles mathématiques en

langage c sont disponibles sous bibliothèque 'math' (#include<math.h>)

Chapitre 2 : Notions et Instructions Simples d’un Algorithme et Langage C

11
 IA-1

2. Les opérateurs suivants sont ordonnés de plus prioritaire au moins prioritaire dans
l’évaluation d’une expression arithmétique :
Les parenthèses,
L’opérateur de puissance ^,
Les opérateurs de multiplication ×, de division / et de modulo %. Ces opérations ont la
même priorité et sont évaluées de gauche à droite.
Les opérateurs d’addition + et soustraction -. Ces opérations ont la même priorité et sont
évaluées de gauche à droite.
3. Opérateur ++ et -- comme préfixe et suffixe dans langage c
• Si vous utilisez l'opérateur ++ comme préfixe comme : ++var, la valeur de var est
incrémentée de 1 ; puis il renvoie la valeur.
• Si vous utilisez l'opérateur ++ comme suffixe comme : var++, la valeur d'origine de var est
renvoyée en premier ; alors var est incrémenté de 1.
• L'opérateur -- fonctionne de la même manière que l'opérateur ++ sauf que -- diminue la
valeur de 1.
• Exemple :

#include <stdio.h>
int main() {
int var1 = 5, var2 = 5;
printf("%d\n", var1++);
// 5 est affiché
// alors, var1 est incrémenté à 6.
printf("%d\n", ++var2);
// var2 est incrémenté à 6
// alors il est affiché.
return 0; }

3.2.2. Opérateurs logiques :

Une expression logique est la composée d’expressions de comparaisons par les opérateurs
logiques. Une expression logique donne un résultat booléen (Vrai ou Faux).

Opérations logique en algorithme Instruction C

et &&

ou ||

non !

Les opérateurs logiques sont utilisés en général pour combiner plusieurs conditions dans les
structures alternatives qu’on verra par la suite.

Soit A et B deux variables booléennes. Le tableau suivant illustre les différentes valeurs de
vérité que l’on obtient en combinant les valeurs de A et B à l’aide des opérateurs logiques.

Chapitre 2 : Notions et Instructions Simples d’un Algorithme et Langage C

12
 IA-1

A B A et B A ou B non A

Faux Faux Faux Faux Vrai

Faux Vrai Faux Vrai Vrai

Vrai Faux Faux Vrai Faux

Vrai Vrai Vrai Vrai Faux

3.2.3. Opérateurs de comparaison :

Ce sont les opérateurs qui permettent de comparer deux valeurs. Le résultat de comparaison
est une valeur logique (Vrai ou Faux). Le tableau ci-après donne les différents opérateurs de
comparaison.

Relations mathématiques Instruction en langage C

Egalité = ==
Différent ≠ !=
Inférieur strict < <
Supérieur strict > >
Inférieur ou égal ≤ <=
Supérieur ou égal ≥ >=

4. Structure générale d’un algorithme et langage C :

La structure d’un algorithme est composée de :
Entête : Porte le nom de l’algorithme éventuellement la déclaration des constantes et
des variables.
Corps de l’algorithme : Contient les instructions à exécuter.

Algorithme Nom_Algorithme → L’en-tête

Les variables et les constantes → La partie déclarative

Début

Instructions Le corps : les tâches à exécuter.

Fin

Chapitre 2 : Notions et Instructions Simples d’un Algorithme et Langage C

13
 IA-1

Exemple :

Algorithme Langage C
Exemple : #include <stdio.h>
Algorithme int main( ) {
Somme_Nombres float A, B, S;
Variable A, B, S : Réel printf("La valeur de A=") ;
Début
scanf ("%f", &A);
Ecrire("La valeur de A=" )
Lire (A) printf("La valeur de B=") ;
Ecrire("La valeur de B=" ) scanf ("%f", &B);
Lire (B) S=A+B ;
SA+B printf("La somme est " ,S) ;
Ecrire("La somme est",S ) return 0 ;
Fin }

Remarques :

• #include <stdio.h> (Standard Input and Output) est appelée directive de

préprocesseur. C’est une ligne qui sera lue par un programme appelé "préprocesseur",
un programme qui se lance au début de la compilation. On appelle ce fichier une
bibliothèque, et il contient du code tout prêt qui permet d'afficher du texte à l'écran.
• main () est un nom de fonction particulier qui signifie "principal". Il est la fonction
principale de votre programme, c'est toujours par la fonction main que le programme
commence.
• return 0 indique qu'on arrive à la fin de notre fonction main, et demande de renvoyer
la valeur 0. En pratique, 0 signifie tout s'est bien passé. Et n'importe quelle autre valeur
signifie qu’il y a une erreur.

Chapitre 2 : Notions et Instructions Simples d’un Algorithme et Langage C

14