Université Cheikh Anta Diop de DAKAR

Faculté des Sciences et technique

Département Mathématiques et Informatique

Initiation à l’algorithmique et la
programmation en Langage C
Dr. Mamadou THIONGANE
[Link]@[Link]
L1BCGS
Année: 2024-2025

FST DMI L1BCGS 2023-2024

Ce cours est une initiation à l’algorithmique et
à la programmation avec le langage C

Objectif:

AApprendre à écrire des algorithmes pour résoudre un

problème donné.

A Apprendre à programmer les algorithmes avec le

Langage C.

FST DMI L1BCGS 2023-2024

.
Informations
A les Supports de cours, les fiches TD/TP sont disponibles
sur:
[Link]

A Logiciel à installer pour programmer en C:

A CodeBlocks (Windows, Mac, Unix)
A Mobile C (Téléphone, Tablette Android ou Iphone)
A Compilateur en ligne disponible sur [Link]
A Des tutoriels ou bien des liens pour la prise en main des
logiciels sont disponibles sur [Link]

A Des solutions aux exercices non corrigés durant les séances

TD/TP seront proposées sur [Link]

AUn Forum de discussion est déjà ouvert:

FST DMI L1BCGS 2023-2024
[Link]
.
Évaluation
A QCM . Il y aura 20 questions
Quelle est la solution du système d’équation suivant:
(x-2)(x-6)=0
A: S={2,6} B: S={1,5} C: S={7,8} D: S={1,6}

A Épreuve qui contient les 20 question et les réponses

proposées pour chaque question.
A Grille de réponse (copie d’examen)

AScanne des grilles et correction automatique par la plateforme

AUn fichier Excel des notes est généré après correction

A Saisie automatique des notes au niveau de la plateforme de

délibération
FST DMI L1BCGS 2023-2024
 Statistiques Session1 de l’année 2023-2024
- Sur 1749 étudiants, 942 ont obtenu une note supérieure ou
égale 10

- Soit un taux de réussite de 53%

- 262 notes sont supérieures ou égale à 15 (15%)

- 675 notes sont supérieures ou égale 12 (38%)

FST DMI L1BCGS 2023-2024

 Plan du cours
— Introduction à l'algorithmique et à la
programmation
— Concepts de base de l'algorithmique
— Concepts de base du langage C
— Structures de contrôle
— Les types de données composés
— Sous programmes
— La récursivité
FST DMI L1BCGS 2023-2024
Chapitre 1 : Introduction à l’algorithmique et à la
programmation

FST DMI L1BCGS 2023-2024

 La notion d’algorithme
— Pour résoudre un problème de manière informatique il y a un
cheminement méthodique à respecter :

FST DMI L1BCGS 2023-2024

 La notion d’algorithme
— Définition (Notion d’algorithme)
§ description formelle d’un procédé de traitement qui permet, à partir d’un
ensemble d’informations initiales, d’obtenir des informations déduites ;
§ succession finie et non ambigüe d’opérations;
§ se termine toujours (Note : semi-algorithme).

— Définition (Notion de Programme)

§ suite d’instructions définies dans un langage donné;
§ décrit un algorithme.

FST DMI L1BCGS 2023-2024

 Définitions
— Un algorithme est la description des étapes à suivre pour
résoudre un problème en un nombre fini d’étapes.

— « Ensemble de règles opératoires dont l'application permet de

résoudre un problème donné au moyen d'un nombre fini
d'opérations ».

— L’algorithmique est la science qui consiste à trouver des

méthodes formelles et certifiées pour résoudre de manière
automatique et le plus efficacement possible des problèmes
donnés.

— Un algorithme est une procédure de calcul bien définie qui prend

en entrée une valeur, ou un ensemble de valeurs, et qui donne en
sortieFSTune valeur,
DMI
ou un2023-2024
L1BCGS
ensemble de valeurs.
Propriétés d’un algorithme
— Un nombre fini d’étapes
— Un nombre fini d’opérations par étape
— Chaque opération est
— non ambiguë
— Effective
— Fournit un résultat
— Un algorithme doit être indépendant du langage de
programmation utilisé.
— Un langage de programmation n’étant qu’une façon d’exprimer
un algorithme pour être compris et exécuté par l’ordinateur .

FST DMI L1BCGS 2023-2024

 La notion de programme
— Tout traitement demandé à la machine, par l’utilisateur, est effectué par
l’exécution séquencée d’opérations appelées instructions.
— Une suite d’instructions est appelée un programme.
— Retenir
— Un programme est une suite d’instructions permettant à un système
informatique d’exécuter une tâche donnée
— écrit dans un langage de programmation compréhensible(directement ou indirectement)
par un ordinateur.

FST DMI L1BCGS 2023-2024

 Qu’est-ce que la programmation ?
— Retenir
— Écriture d’un programme dans un langage de programmation donnée.
— Langage de programmation : ensemble de règle de vocabulaire et de
grammaire compréhensible par un ordinateur.

FST DMI L1BCGS 2023-2024

Étapes de la construction d’un programme

FST DMI L1BCGS 2023-2024

 Langage de programmation (1/2)
— Pour être compris et exécuté par un ordinateur, un algorithme doit
être traduit dans un langage spécifique, qu’on appelle langage de
programmation.
— On obtient ainsi ce qu’on appelle un programme informatique qui
contient l’ensemble des actions consécutives que l’ordinateur doit
exécuter.
— Ces actions sont appelées instructions.
— Le langage utilisé par le processeur de l’ordinateur est appelé
langage machine.
— C’est le seul langage que l’ordinateur connaît.
— Un programme en langage machine est uniquement constitué d’une
suite de 0 et de 1 (du binaire).

FST DMI L1BCGS 2023-2024

 Langage de programmation(2/2)
— Il est plus pratique de réaliser un programme dans un
langage plus compréhensible par l'homme et de le traduire
ensuite en langage machine.

— Selon la méthode de traduction, on distingue:

— les langages compilés et
— les langages interprétés.

FST DMI L1BCGS 2023-2024

 Langage compilé

— Dans le cas d’un langage compilé (exemples: C, C++,

Pascal...), le programme réalisé, appelé programme source,
est traduit complètement par ce qu’on appelle un compilateur
avant de pouvoir être exécuté.
— La compilation génère un programme dit exécutable.
— Ce programme généré est autonome, c’est-à-dire qu’il n’a pas
besoin d'un autre programme pour s’exécuter.
— Mais à chaque modification du fichier source (le programme
source) il faudra le recompiler pour que les modifications
prennent effet.

FST DMI L1BCGS 2023-2024

 Langage compilé

FST DMI L1BCGS 2023-2024

 Langage interprété.

— Au contraire, un programme écrit dans un langage interprété

(exemples: Perl, Lisp, Prolog...) a besoin, pour chaque
exécution, d'un programme annexe appelé interpréteur qui
va lire le code source pour traduire et faire exécuter une à
une, chacune des instructions.

— Dans ce cas, il n’y a pas de génération de programme

exécutable.

FST DMI L1BCGS 2023-2024

 Compilation et interprétation

FST DMI L1BCGS 2023-2024

 FIN

FST DMI L1BCGS 2023-2024

 Université Cheikh Anta Diop de DAKAR
Faculté des Sciences et technique
Département Mathématique et Informatique

Chapitre 2 – CONCEPTS DE BASE

DE L'ALGORITHMIQUE

Dr. THIONGANE
[Link]@[Link]
L1BCGS
Année: 2023-2024

1 FST DMI L1BCGS 2023-2024

 Notions de variable et de constante
— Les variables
— Données manipulées par le programme lors de son exécution.
— Elles correspondent à des emplacements situés dans la mémoire vive
de l’ordinateur
— Permettent de stocker des valeurs.
— Une variable est caractérisée par:
— Son identifiant : nom de la variable
— L’endroit où elle se trouve en mémoire : adresse,
— La nature de l’information (nombre, caractère, …) : son type
— Son contenu : sa valeur.
— La valeur d’ une variable peut être modifiée durant
l'exécution du programme.
— Constante
— Une constante est, comme une variable, a un emplacement
mémoire mais sa valeur ne peut pas changer au cours de l'exécution
du programme.
2 FST DMI L1BCGS 2023-2024
 Types de données de base

— En algorithmique, on distingue 5 types de base:

— Caractère (lettre, chiffre, ponctuation, espace, retour
chariot,… et plus généralement toutes les touches que l'on
peut trouver sur une machine à écrire)
— Chaîne de caractères (suite de 0 ou plusieurs caractères)
— Entier (les nombres entiers positifs ou négatifs)
— Réel (les nombres réels positifs ou négatifs)
— Booléen (les variables booléennes n’ont que deux valeurs
possibles: soit VRAI, soit FAUX)

3 FST DMI L1BCGS 2023-2024

 Structure générale d’un algorithme

Algorithme nom de l’algorithme

Type
Définition de types
Constante
Déclaration de constantes
Variable
Déclaration de variables

Définition de sous-programmes
Début
instructions du programme
Fin

4 FST DMI L1BCGS 2023-2024

 Structure générale d’un algorithme
— Un algorithme commence par le mot Algorithme suivi de son
identificateur (le nom du programme).
— Ensuite viennent la définition de types annoncée par le mot Type,
la déclaration de constantes, annoncée par le mot Constante puis
celle de variables, annoncée par le mot Variable et la définition
de sous programmes.
— Le corps du programme commence par Début et se termine par
Fin.
— On peut insérer des commentaires, soit entre les balises /* */,
soit après // jusqu'à la fin de la ligne.
— Remarque:
Les types de base font partie du langage et n'ont pas à être
définis par le programmeur.

5 FST DMI L1BCGS 2023-2024

 Déclaration des variables et des
constantes
— Déclaration d'une variable
— Toute variable doit être déclarée avant sa première
utilisation.
— La déclaration d’une variable consiste à la réservation d’un
emplacement mémoire, auquel on donne un nom unique
appelé identificateur et par lequel on peut accéder à sa
valeur.
— La syntaxe de déclaration d’une variable est:
— identificateur : type
— Exemple a : entier
x, y, z: entier

6 FST DMI L1BCGS 2023-2024

 Déclaration des variables et des
constantes
— Déclaration d'une constante

— La déclaration d’une constante est toujours associée à son

initialisation (première valeur).
La syntaxe de déclaration d’une constante est:

identificateur = valeur

Exemple

MAX = 32767

7 FST DMI L1BCGS 2023-2024

 Les opérations de l’algorithmique

8 FST DMI L1BCGS 2023-2024

 Les opérations de l’algorithmique
— Pour les entiers, la division est notée div. Elle est nommée division entière et ne
donne que le chiffre avant la virgule du résultat (elle renvoie un entier).
— Les entiers supportent une opération supplémentaire appelée modulo, notée
mod et qui renvoie le reste de la division entière.
— Exemple:
— 7 div 2 donne 3
— 7 mod 2 donne 1

— Une valeur de type caractère doit être ente apostrophes (sinon le compilateur
pourrait le confondre avec un nom de variable).
— Une valeur de type chaîne doit être entre guillemets (sinon le compilateur pourrait
le confondre avec un nom de variable).
— Les caractères sont comparés selon l’ordre du code ASCII. C’est ainsi qu’on
peut comparer tous les caractères entre eux. Par exemple le caractère 'Z'
(majuscule), de code ASCII 90 est inférieure au caractère 'a' (minuscule) de code
ASCII 97.

9 FST DMI L1BCGS 2023-2024

 Les opérations de l’algorithmique
— Soit la variable c de type caractère:
— succ(c) permet d’obtenir le caractère qui suit le caractère c selon le code ASCII
— pred(c) permet d’obtenir le caractère qui précède le caractère c selon le code
ASCII
— ord(c) permet d’obtenir code ASCII du caractère c.
— car(n) permet d’obtenir le caractère correspondant au code ASCII n.
— Par exemple :
— ord(‘A’) vaut 65
— succ(‘A’) vaut ‘B’
— pred(‘A’) vaut @
— car(65) donne ‘A’
— Pour le type chaîne, L’opérateur + sert à concaténer des chaînes de caractère, ce
qui signifie transformer plusieurs chaînes en une seule en les ajoutant les unes à la
suite des autres.
— Exemples :
— ‘’Bonjour ‘’ + ‘’à tous ‘’ donne ‘’Bonjour à tous ‘’
— longueur(‘’Bonjour’’) donne le nombre de caractères de la chaîne
‘’Bonjour’’, c’est à dire 7.
10 FST DMI L1BCGS 2023-2024
 Opération sur les booléennes
— Pour le type booléen, les deux seules valeurs possibles sont
Vrai et FAUX. Les opérateurs de base ET, OU, NON sont
définies par la table de vérité suivante (étant données deux
variables A et B de type booléen) :

11 FST DMI L1BCGS 2023-2024

 Les expressions
— Une expression est:
— soit une variable ou une constante,
— soit une valeur littérale (écrite telle qu'elle dans le programme,
par exemple : "bonjour", 45),
— soit une combinaison de variables, de constantes, de valeurs
littérales et d'opérateurs, par exemple : 2 * r * 3.14)
— Elle est évaluée durant l’exécution du programme, et
possède une valeur (son évaluation) et un type.
— Par exemple: Supposons que rayon soit une variable de valeur
5. Alors l'expression 2 * rayon * 3.14 vaut 31.4

12 FST DMI L1BCGS 2023-2024

 Les expressions conditionnelles
— Une expression conditionnelle (ou expression logique, ou
expression booléenne ou condition) est une expression dont la
valeur est soit VRAI soit FAUX. On peut donc affecter une
expression conditionnelle à une variable booléenne. Il existe
plusieurs types d’expressions conditionnelles.
— Les conditions simples
— Une condition simple est une comparaison de deux
expressions de même type.
— Exemples
— a<0
— op = =‘s’
— (a + b - 3) * c = = (5 * y –2) / 3

13 FST DMI L1BCGS 2023-2024

 Les expressions
— Les conditions complexes: Les conditions (ou
expressions conditionnelles) peuvent aussi être complexes,
c'est à dire formées de plusieurs conditions simples ou
variables booléennes reliées entre elles par les opérateurs
logiques ET, OU, NON.
— Exemples
(a < 0) ET (b < 0)
( (a +3 = = b) ET (c < 0) ) OU ( (a = = c *2) ET (b!= c) )

14 FST DMI L1BCGS 2023-2024

 Les expressions
— Une condition composée de deux conditions simples reliées par ET est
vraie si les deux conditions sont vraies.
— (a < 0 ) ET (b < 0) est vraie si a < 0 est vraie et si b < 0 est vraie

— Une condition composée de deux conditions simples séparées par OU

est vraie si au moins l'une des conditions simples est vraie.
— (a <0) OU (b < 0) est vraie si a < 0 ou si b < 0 ou si a et b sont
négatifs.
— Une condition précédée par NON est vraie si la condition simple est
fausse et inversement.
— NON (a < 0) est vraie si a >=0

— L'usage des parenthèses permet de régler d'éventuels problèmes de

priorité des opérateurs logiques.

15 FST DMI L1BCGS 2023-2024

 Les instructions de base
— Les instructions élémentaires les plus
courantes sont :
— l'affectation: le fait de donner une valeur
à une variable
— la lecture au clavier
— l'écriture à l'écran

16 FST DMI L1BCGS 2023-2024

 L’affectation
— L’affectation consiste à mettre une valeur dans une variable (ce qui
revient à changer le contenu de cette variable). La nouvelle valeur est
évaluée à partir d'une expression.
— En algorithmique, pour représenter l’opération d’affectation, on va
utiliser le symbole =
— Les instructions d’affectation sont formées de deux parties :
— A gauche du symbole =, on trouve toujours le nom d’une variable
destinée à recevoir une valeur.
— A droite, on trouve l’expression qui va donner la valeur qu’on veut
affecter à la variable en question.
— L’instruction d’affectation agit en deux temps :
— d’abord elle détermine la valeur de l’expression située à droite du
symbole =
— puis elle range le résultat dans la variable située à gauche.

17 FST DMI L1BCGS 2023-2024

 L’affectation
Remarques
— On ne peut affecter de valeur qu’à une variable. Il est
impossible d’affecter une valeur à une expression. Ainsi, par
exemple, l’instruction a + 5 = b n’a pas de sens
— Il est possible de retrouver la même variable à droite et à
gauche de l’expression. Ainsi, par exemple, l’instruction a
= a + 3 a un sens en programmation. Cela signifie que l’on
évalue a + 3 avec l'ancienne valeur de a et qu’on range le
résultat dans a. La valeur de a sera donc augmentée de 3 par
cette opération.

18 FST DMI L1BCGS 2023-2024

 La Lecture
— L’instruction de lecture permet au programme de lire des
données entrées au clavier par l'utilisateur. Cette instruction
affecte les valeurs entrées au clavier à des variables du
programme..
— Syntaxe
— Lire(variable1 , variable2, …)
Exemples
— Lire(x)
— Cette instruction lit la valeur entrée au clavier et l'affecte à la
variable x
— Lire(x, y)
— Cette instruction lit la première valeur entrée au clavier et
l'affecte à x, puis lit la deuxième valeur et l'affecte à y
19 FST DMI L1BCGS 2023-2024
 L'écriture

— L'instruction d'écriture permet d'afficher des expressions à

l'écran.
— Syntaxe
— Ecrire(expression1, expression2, ...)

— Exemples
— Ecrire(ch)
— Cette instruction permet d'afficher la valeur de la variable ch à l'écran
Si ch est une chaîne qui vaut "toto", cette instruction affichera toto à
l'écran
— Ecrire("Bonjour!")
o Celle-ci permet d'afficher la chaîne littérale Bonjour! à l'écran

20 FST DMI L1BCGS 2023-2024

 Exemple 1 : Algorithme Addition de deux entier
Algorithme AdditionEntier

Variables
a , b, resultat: entier

Début
Ecrire(²Donnez la premiere valeur ²)
Lire(a)
Ecrire(² Donnez la deuxieme valeur ²)
Lire(b)
resultat =a+b
Ecrire (² la somme de ² ,a, ²et de ² ,b , ²donne ² ,resultat)
Fin

21 FST DMI L1BCGS 2023-2024

 Exemple 2 : Algorithme salutation
Algorithme AfficheSalutation

Variable
nom, salutation :chaine de caractere // Déclaration de variables

Début

Écrire ("Quel est votre nom ?" ) // Affichage d'une chaîne

Lire (nom) // Lecture d'une valeur

salutation = "Bonjour " + nom ; // Affectation

Écrire (salutation) // Affichage d'une chaîne

Fin

22 FST DMI L1BCGS 2023-2024

 FIN
23 FST DMI L1BCGS 2023-2024
 Université Cheikh Anta Diop de DAKAR
Faculté des Sciences et technique
Département Mathématique et Informatique

Chapitre 3 – CONCEPTS DE BASE DU LANGAGE C

Dr. THIONGANE
[Link]@[Link]
L1BCGS
Année: 2023-2024

1 L1BGCS Année: 2023-2024

 PLAN
A Structure d'un programme C
A Les types de base du langage C
A Déclaration des variables et des constantes
A Les opérateurs du langage C
A Les instructions élémentaires

2 L1BGCS Année: 2023-2024

 Historique
— Le langage C a été créé par Brian Kernighan et Dennis Ritchie
au début des années 70.
— C’est un langage compilé qui a les caractéristiques suivantes:
— C’est un langage typé: tout objet doit avoir un type (caractère,
entier, réel...)
— C’est un langage déclaratif: tout objet doit être déclaré avant
son utilisation.
— Le langage C propose un certain nombre de fonctions
prédéfinies dans des bibliothèques

3 L1BGCS Année: 2023-2024

 Structure d'un programme C (1/2)
— Un programme en C se compose:

1. d'un programme principal

2. (éventuellement) de sous programmes.
3. Il est écrit dans un fichier portant l'extension .c
Ce fichier, appelé fichier source du programme.

4 L1BGCS Année: 2023-2024

 Structure d'un programme C (2/2)
Le fichier source du programme contient généralement les parties
suivantes:
1. Les directives de compilation: une directive commence toujours
par le symbole # suivi de la directive.
Pour utiliser une fonction qui a été prédéfinie dans la bibliothèque
stdio.h, il faut mettre la directive suivante :
#include <stdio.h>
2. La définition des structures et des types (s'il y en a)
3. La déclaration des variables globales (s'il y en a
4. Les fonctions
5. Le programme principal (fonction main)
5 L1BGCS Année: 2023-2024
 Un premier programme
L1 /*
L2 Mon premier programme C.
L3 */
L4 #include<stdio.h>
L5 int main( )
L6 {
L7 printf("Bonjour tout le monde \n");
L8 return 0;
L9 }

6 L1BGCS Année: 2023-2024

 Un premier programme
— [L1, L2, L3] Commentaire sur plusieurs lignes.
— [L4] #include pour pouvoir utiliser la fonction printf qui est une
fonction de la librairie stdio.h (STandarD Input/Output).
— [L5] Fonction principale, point d'entrée du programme.
— [L6] Accolade ouvrante, débute le code de la fonction.
— [L7] La fonction printf permet d'afficher un message à l'écran. Les
guillemets délimitent la chaîne de caractère. Le caractère \n signifie un
saut de ligne suivi d'un retour chariot. Le point-virgule à la fin de
chaque phrase est indispensable.
— [L8] Le programme renvoie la valeur 0 au shell appelant à la fin de son
exécution.
— [L9] Accolade fermante, fin de bloc de la fonction principale

7 L1BGCS Année: 2023-2024

 Les directives de compilation

1. Elles indiquent au compilateur de procéder à des

opérations préalables au début de la compilation.

2. Elles se situent en tout début du programme source.

Nous utilisons en général les deux directive suivante:

- La directive #include
- La directive #define

8 L1BGCS Année: 2023-2024

 La directive #include

— Cette directive permet l'inclusion de librairies dont les

éléments seront utilisés dans le programme source.
— Le compilateur C fournit un ensemble de librairies mais le
programmeur peut aussi créer ses propres librairies.
— Syntaxe de cette directive :
— #include <fichier> ou #include "fichier"
— Exemples :
— #include <stdio.h>
— #include "C:\MesProgrammes\definitions.h"

9 L1BGCS Année: 2023-2024

 La directive #define
— Cette directive permet de remplacer dans le programme
toutes les occurrences d’une suite de caractères par un nom
de substitution.
— Syntaxe de cette directive :
— #define nom_de_substitution suite_de_caractères
— nom_de_substitution sera utilisé tout au long du programme source
pour représenter la suite de caractères suite_de_caractères.
— Exemple:
— #define VRAI 1
— Le mot VRAI sera utilisé pour représenter le chiffre 1 dans
le programme source. Mais rien ne vous empêche d'utiliser
le chiffre 1.
10 L1BGCS Année: 2023-2024
 Les types de base du Langage C
— En langage C, chaque variable doit être associée à un
type, qui permet de spécifier la taille de l’espace
occupé en mémoire (nombre d’octets).

type Description taille Valeurs possibles Format

void Ensemble vide
2 ou 4 de -32768 à 32767 %d
int Entier standard de -2147483648 à 2147483647
short Entier court 2 de -32768 à 32767 %d
long Entier long 4 de -2147483648 à 2147483647 %ld
float Réel 4 %f
double Réel double 8 %lf
précision
11 char
L1BGCS Caractère
Année: 2023-2024 1 de -128 à 127 %c
 Les caractères non imprimables
— Les caractères non imprimables possèdent une
représentation conventionnelle utilisant le caractère \
nommé antislash.
— Exemples de caractères non imprimables :

— \n retour chariot avec saut de ligne

— \r retour chariot sans saut de ligne
— \t tabulation horizontale
— \v tabulation verticale

12 L1BGCS Année: 2023-2024

 Déclaration d'une variable
— En C, toute variable doit être déclarée avant sa première
utilisation.
— La syntaxe de déclaration d’une variable est:
type identificateur;
— Exemple:
— L’instruction int a ;
— permet de réserver un emplacement mémoire pour le
stockage d’un entier (type int) qui sera nommé a dans la
suite du programme.
— Une déclaration peut se faire seule, ou accompagnée d’une
initialisation (première valeur), exemple: int b=3;
13 L1BGCS Année: 2023-2024
 Déclaration d'une constante

— La syntaxe de déclaration d’une constante est:

const type identificateur valeur;
— Exemple :
— const int MAX=32767;
— On peut utiliser la directive de compilation #define pour
définir une constante selon la syntaxe suivante:
— #define identificateur valeur
— #define MAX 32767
— Mais dans ce cas, il n’y a pas de réservation d’emplacement
mémoire.
14 L1BGCS Année: 2023-2024
 Mots réservés (mots-clés)
auto const double float int short struct unsigned

break continue else for long signed switch void

case default enum goto register sizeof typedef volatile

char do extern if return static union while

15 L1BGCS Année: 2023-2024

 Conventions d’écritures d’un programme C
— Avant d’aller plus loin, il convient d’établir un certain nombre
de régles de présentation que devra suivre tout bon
programmeur qui souhaite écrire des programmes C lisibles
— Ne jamais placer plusieurs instructions sur une même ligne ;
— Utiliser des identificateurs significatifs ;
— grâce à l’indentation des lignes, faire ressortir la structure
syntaxique du programme ;
— Laisser une ligne blanche entre la dernière ligne des déclarations
et la première ligne des instructions ;
— Aérer les lignes de programme en entourant par exemple les
opérateurs avec des espaces ;
— Bien commenter les listings tout en évitant les commentaires
triviaux.
16 L1BGCS Année: 2023-2024
 Les opérateurs arithmétiques
Opérateur Signification
+ Addition
- Soustraction
* Multiplication
/ Division

Reste de la division entière

%
(entre deux entiers)

17 L1BGCS Année: 2023-2024

 Les opérateurs relationnels
Opérateur Signification
> Supérieur

>= Supérieur ou égal

< Inférieur

<= Inférieur ou égal

== Egal
!= Différent

18 L1BGCS Année: 2023-2024

 Les opérateurs logiques
Opérateur Signification
&& Et logique

|| Ou logique

! Négation logique

19 L1BGCS Année: 2023-2024

 Opérateurs unaires
— Ce sont des opérateurs qui ne s’appliquent qu’a un
seul opérande.

Pré-incrémentation i=++j j=j+1 ; i=j

Post-incrémentation i=j++ i=j ; j=j+1

Pré-décrémentation
— int i,j,k; i=--j j=j-1 ; i=j

Post-décrémentation i=j-- i=j ; j=j-1

20 L1BGCS Année: 2023-2024

 Combinaison d’opérateurs

— Il est possible de combiner les opérateurs selon la

forme générale suivante :
— x op= i équivalent à x = x op i
— On peut alors avoir les formes suivantes : +=, -=, *=,
/=, %=
— Exemple
— i += 20; equiv i = i + 20;
— i -= 1; equiv i = i--; equiv i=i-1

21 L1BGCS Année: 2023-2024

 Les instructions élémentaires

22 L1BGCS Année: 2023-2024

 1. L’affectation
— Cette instruction permet de donner la valeur de l’expression de
droite à la variable de gauche.
— Le langage C utilise le symbole = pour l’ affectation.

Exemples :
— x = 5; // La variable x prend pour valeur 5

— i = i + 1; // La variable i prend pour valeur son ancienne valeur

augmentée de 1

— C = 'a’; // La variable C prend pour valeur le caractère 'a'.

23 L1BGCS Année: 2023-2024

 2. L'affichage
— La fonction printf permet d’afficher des informations à
l’écran
— Syntaxe : printf ( " chaîne de caractères " , variable1, variable2, … )
— Cette fonction, contenue dans la bibliothèque standard stdio.h,
attend comme premier paramètre la chaîne de caractère à
afficher avec éventuellement la description des formats
d’affichage des variables à afficher
— Exemple:
— printf ("la valeur de x est %d et celle de y e st %d", x, y );
— printf ("%d", y – x);
— Cette instruction affiche 5 si y=10 et x=5

24 L1BGCS Année: 2023-2024

 3. La lecture
— L’instruction scanf permet au programme de lire des
informations saisies au clavier par l’utilisateur.
— Syntaxe : scanf ( " chaîne de formatage " , &variable1 , &variable2, . . . )

— Cette fonction, également contenue dans la bibliothèque

standard stdio.h, attend comme premier paramètre la chaîne
décrivant les formats de lecture des variables à lire au clavier.
Les paramètres suivants sont, dans l’ordre, l’adresse des
variables dont on souhaite lire la valeur.
— Le & permet d’accéder à l’adresse des variables.(A omettre
dans le cas de la lecture d’une chaîne de caractères).
— Exemple : scanf(" %d %d",&X, &Y) ;

25 L1BGCS Année: 2023-2024

 4. Lecture et affichage de caractères(1/2)

Les fonctions getchar et putchar de la bibliothèque stdio.h

permettent respectivement au programme de lire au clavier et
d’afficher à l’écran des caractères. Il s’agit de fonctions d’entrées-
sorties non formatées.

Exemple:
Lecture du caractère c
c=getchar();
Affichage du caractère c
putchar(c);

26 L1BGCS Année: 2023-2024

 5. Lecture et affichage de
caractères(2/2)
— Certains compilateurs proposent une bibliothèque appelée
conio.h qui contient une fonction de lecture et une
d'écriture de caractère.

— Il s’agit de:
getch pour la lecture de caractère
putch pour la l’écriture de caractère
Exemple :
c = getch( ) ; putch(c) ;

27 L1BGCS Année: 2023-2024

 Exemple de programme
Ecrire un programme qui demande de donner deux
nombre entier et affiche à l’écran la valeur des
nombre saisies

#include <stdio.h>
int main(){
int a, b;
printf(" donner deux nombres entier ");
scanf(" %d %d",&a, &b) ;
printf(" vous avez saisie a= %d , b = %d", a,b);
return 0.
}
28 L1BGCS Année: 2023-2024
28
 Exemple de programme somme de
deux entier

#include <stdio.h>
int main(){
int a, b, res;

printf(" donner la première valeur ");

scanf(" %d",&a) ;
printf(" donner la première valeur ");
scanf(" %d ", &b) ;
res=a+b;
printf(" La somme de %d et de %d est %d ", a,b,res);
return 0.
}
29 L1BGCS Année: 2023-2024
29
 Exemple de programme somme de
deux entier

#include <stdio.h>
int main(){
int a, b, res;

printf(" donner la première valeur ");

scanf(" %d",&a) ;
printf(" donner la première valeur ");
scanf(" %d ", &b) ;
res=a+b;
printf(" La somme de %d et de %d est %d ", a,b,res);
return 0.
}
30 L1BGCS Année: 2023-2024
30
 UNIVERSITÉ CHEIKH ANTA DIOP DE DAKAR
FACULTÉ DES SCIENCES ET TECHNIQUE
DÉPARTEMENT MATHÉMATIQUE ET INFORMATIQUE

Chapitre 4 - STRUCTURES DE
CONTRÔLE

Dr. THIONGANE
[Link]@[Link]
L1BCGS
Année: 2023-2024

L1BCGS 2023-2024
Introduction
— Les structures de contrôle permettent d’agir sur l’ordre ou
la fréquence d’exécution des instructions d’un programme.
— Il existe deux grands types de structures de contrôle:
— les structures conditionnelles
— les structures répétitives, encore appelées boucles.

L1BCGS 2023-2024
 I. Structures conditionnelles
Les structures conditionnelles permettent d'exécuter des
instructions différentes en fonction de certaines conditions

L1BCGS 2023-2024
 La Structure Si

q permet de conditionner l’exécution d’un ensemble d'instructions à

la valeur d’une condition (expression booléenne).

q La syntaxe générale de cette structure est la suivante:

Si (condition) Alors
traitement1
Sinon
traitement2
FinSi

L1BCGS 2023-2024
La structure Si

• Les traitements apparaissant après les mots Alors et Sinon peuvent être
constitués d'une instruction simple ou d'un ensemble d'instructions (bloc
d'instructions).

• La condition est d'abord évaluée

Ø Si elle est vraie, traitement1 est exécuté puis le contrôle passe à l’instruction qui suit le
FinSi.
Ø Si elle est fausse, traitement2 est exécuté puis le contrôle passe à l’instruction qui suit
le FinSi.

L1BCGS 2023-2024
Exemple 1 La Structure Si
Algorithme SigneValeurSaisie

Variable
n : entier
Début

Ecrire("entrez un nombre")

Lire(n)

Si (n > 0) Alors //dans le cas où la condition n>0 est vraie

Ecrire("valeur positive")

Sinon //dans le cas où la condition n>0 est fausse

Ecrire ("valeur négative ou nulle")

L1BCGS
FinSi 2023-2024
FIN
La Structure Si
Exemple 2:
Algorithme Operation

Variable
nb1,nb2, res: entier
op : caractère

Début

Ecrire("Entrez deux nombres")

Lire(nb1, nb2)
Ecrire("entrez la première lettre de l'opération voulue: somme ou produit")
Lire(op)
Si (op = = 's') Alors
res = nb1 + nb2
Ecrire("la somme est", res)
Sinon
res = nb1 * nb2
Ecrire("le produit est", res)
FinSi
Fin
L1BCGS 2023-2024
 La Structure Si

L1BCGS 2023-2024
La Structure Si : Traduction en C
if(condition1)
{
traitement1
}
else if (condition2)
{
traitement2
}
...
else if (conditionN)
{
traitementN
}
else
{
traitement
}
NB : conditions doivent être entre parenthèses.
Si un traitement comporte une seule instruction, on peut omettre les accolades.

L1BCGS 2023-2024
 La Structure Si en C : if
Exemple 1

#include<stdio.h>
Int main()
{ int n;

printf("entrez un nombre");
scanf("%d", &n);

if (n > 0)
printf("valeur positive");
else
printf("valeur négative ou nulle");

return 0;
} L1BCGS 2023-2024
La condition Si en C : if
Exemple 2
#include <stdio.h>
int main( )
{
int nb1,nb2, res;
char op;
printf("Entrez deux nombres");
scanf("%d%d", &nb1, &nb2);
printf("entrez la première lettre de l'opération voulue: somme ou produit");
fflush (stdin);
op = getchar( );
if (op = = 's')
{
res = nb1 + nb2;
printf("la somme est %d", res);
}
else
{
res = nb1 * nb2;
printf("le produit est %d", res);
}
return 0;
} L1BCGS 2023-2024
 La structure Selon
q La structure Selon permet de choisir le traitement à effectuer en fonction de
la valeur d'une variable ou d'une expression.
q Cette structure permet parfois de remplacer avantageusement une
structure Si.
La syntaxe de cette structure est :

Selon (expression) Faire

valeur1 : traitement1
valeur2 : traitement2
…
valeurN : traitementN
Sinon traitement
FinSelon
Où expression est nécessairement une expression de type scalaire (entier,
caractère, booléen ou énuméré).

L1BCGS 2023-2024
La structure Selon
qL’expression est évaluée, puis sa valeur est successivement
comparée à chacune des valeurs.

q Dès qu’il y a correspondance, les comparaisons sont arrêtées

et le traitement associé est exécuté.

qSi aucune valeur ne correspond à la valeur de l’expression,

alors le traitement associé au Sinon, s’il existe, est exécuté.

L1BCGS 2023-2024
 La structure Selon
Exemple
Programme qui affiche le mois en toute lettre selon son numéro.
Le numéro du mois est mémorisé dans la variable mois.
...
Ecrire("Donner le numéro du mois")
Lire(mois)
Selon (mois) Faire
1 : Ecrire("Janvier")
2 : Ecrire("Février")
3 : Ecrire("Mars")
4 : Ecrire("Avril")
…
11: Ecrire("Novembre")
12: Ecrire("Décembre")
Sinon Ecrire("Un numéro de mois doit être compris entre 1 et 12")
FinSelon
L1BCGS 2023-2024
La structure Selon
Remarque: Avec une structure Si, on aurait :
Ecrire(Donner le numéro du mois)
Lire(mois)
Si (mois = = 1) Alors
Ecrire("Janvier")
Sinon Si (mois = = 2) Alors
Ecrire("Février")
Sinon Si (mois = = 3) Alors
Ecrire("Mars")
Sinon Si (mois = = 4) Alors
Ecrire("Avril")
…
Sinon Si (mois = = 11) Alors
Ecrire("Novembre")
Sinon Si (mois = = 12) Alors
Ecrire("Décembre")
Sinon
Ecrire("Un numéro de mois doit être compris entre 1 et 12")
FinSi
L1BCGS 2023-2024
……
 La structure Selon
q Si on a le choix entre plusieurs traitements à effectuer suivant la valeur d'une
expression entière on peut alors utiliser la structure switch à la place de la structure if.
q Syntaxe :
switch (expression)
{
case valeur1 :
traitement1;
break;
case valeur2 :
traitement1;
break;
...
case valeurN :
traitementN;
break;
default :

L1BCGS
traitement;
2023-2024
}
 La structure Selon
Exemple
…
printf("Donner le numéro du mois")
scanf("%d", &mois)
switch (mois)
{
case 1 : printf("Janvier"); break;
case 2 : printf("Février"); break;
...
case 12 : printf("Décembre"); break;
default : printf("Un numéro de mois doit être compris entre 1 et 12"); break;
}
...

L1BCGS 2023-2024
 II. Structures répétitives
Les structures répétitives, appelées aussi boucles,
permettent de répéter un traitement autant de fois
qu'il est nécessaire:
q soit un nombre déterminé de fois,
q soit tant qu'une condition est vraie.

L1BCGS 2023-2024
La boucle Tant que
q La boucle Tant que permet de répéter un traitement tant qu'une conition est
vraie.
q Si, dès le début, la condition est fausse, alors le traitement ne sera pas exécuté.

q Syntaxe:
Tant que (condition) Faire
traitement
FinTQ

L1BCGS 2023-2024
La boucle Tant que
Exemple:
Programme qui calcule le cube des nombres non nuls saisis par l'utilisateur.
Tant que le nombre saisi par l'utilisateur n'est pas nul, on affiche son cube et on recommence.
Programme cube
Variable
x : Entier
Début
Ecrire("Ce programme calcul le cube des nombres que vous entrez. Pour arrêter tapez 0.")
Ecrire("Entrez un nombre")
Lire(x)
Tant que (x ≠ 0) Faire
Ecrire("le cube de " , x , " est ", x*x*x)
Ecrire("Entrez un nombre ou 0 pour arrêter")
Lire(x)
FinTQ
Ecrire("Fin")
Fin
L1BCGS 2023-2024
 Traduction en langage C: boucle While
Syntaxe:

while (condition)
{
traitement
}

q Les conditions doivent être entre parenthèses.

q Si un traitement comporte une seule instruction, on peut omettre les accolades

L1BCGS 2023-2024
La boucle pour
q La boucle Pour permet de répéter une instruction un nombre connu de fois.
q Syntaxe:

Pour compteur = valeur_initiale à valeur_finale par pas de increment Faire

traitement
FinPour

q La variable compteur est de type entier. Elle est initialisée à la valeur valeur_initiale.
q Le compteur augmente (implicitement) de la valeur increment à chaque exécution du
traitement.
q Lorsque la variable compteur vaut la valeur valeur_finale, le traitement est exécuté
une dernière fois puis le programme sort de la boucle.
q Par défaut, l’incrément est de 1

L1BCGS 2023-2024
 La boucle Pour
Exemple 1: Cet exemple permet d'afficher à l'écran les nombres pairs de 0 à 20.
….
Pour x = 0 à 20 par pas de 2 Faire
Ecrire(x)
FinPour
…
Exemple 2: Cet exemple permet d'afficher à l'écran les nombres pairs de 20 à 0.
…
Pour x = 20 à 0 par pas de -2 Faire
Ecrire(x)
FinPour
…
Exemple 3: Cet exemple permet d'afficher à l'écran tous les nombres de 0 à 20
…
Pour x = 0 à 20 Faire
Ecrire(x)
FinPour
L1BCGS 2023-2024
…
La boucle Pour
Remarque
q La boucle Pour permet de faire la même chose que la boucle Tant que mais de façon plus rapide, du
moins lorsque le nombre de répétitions est connu.
q En effet, avec une boucle tant que, on pourrait faire la même chose que l'exemple 3 ci-dessus, mais il
faudrait initialiser la variable compteur et l'incrémenter explicitement.

…
x=1
Tant que (x <= 20) Faire
Ecrire(x)
x = x+1 // incrémentation explicite
FinTQ
…

L1BCGS 2023-2024
Traduction en langage C: boucle for
Syntaxe :
for(instruction1;condition;instruction2)
{
traitement;
}
Le déroulement se fait ainsi:
- instruction1 est exécutée une seule fois.
- Puis il y a l'enchaînement suivant:
La condition est évaluée.
Si elle est fausse, on sort de la boucle.
Si elle est vraie, le traitement de la boucle est exécuté, puis instruction2 est exécutée et on
recommence en évaluant à nouveau la condition, etc …
En général
instruction1 permet d'initialiser une variable compteur
instruction2 permet d'incrémenter ou de décrémenter une variable compteur

L1BCGS 2023-2024
Traduction en langage C: boucle for
Exemple

for(x = 0; x <= 20; x = x+1)

{
printf("%d", x);
}

A la sortie de la boucle, x vaut 21.

L1BCGS 2023-2024
 La boucle Faire…Tant que

q Cette boucle sert à répéter une instruction tant qu'une condition est vraie. Son
formalisme est le suivant:
Faire
traitement
Tant que (condition)

q Le traitement est exécuté une première fois, puis la condition est vérifiée. Si elle
est vraie, on retourne au début de la boucle et le traitement est répété. Si la
condition est fausse, on sort de la boucle.

q A chaque fois que le traitement est exécuté, la condition est de nouveau vérifiée à la
fin.

L1BCGS 2023-2024
 La boucle Faire…Tant que
Exemple
Programme qui l'aire d'un cercle dont le rayon est saisi par l'utilisateur et qui permet
de recommencer plusieurs fois.
Programme Aire
Variable
rayon : réel
réponse : caractère
Début
Ecrire("Calcul de l'aire d'un cercle")
Faire
Ecrire("Entrez le rayon d'un cercle en cm")
Lire(rayon)
Ecrire("L'aire de ce cercle est ", rayon*rayon *3.14, "cm2")
Ecrire("Voulez-vous l'aire d'un autre cercle? (o/n)")
Lire(réponse)
Tant que (réponse = = 'o')
Ecrire("Au revoir!")
L1BCGS 2023-2024
Fin
 Traduction en langage C: boucle do .. while

Syntaxe
do
{
traitement
} while (condition);

L1BCGS 2023-2024
 Imbrication de structures de contrôles
q Dans les parties traitement des structures de contrôle qu’on a vues, il peut y avoir d’autres
structures de contrôle. On parle alors d’imbrication de structures (c'est-à-dire
que les structures sont incluses les unes dans les autres).
q Dans le cas de structures Si imbriquées, le premier FinSi rencontré dans
l'algorithme indique toujours la fin de la structure la plus imbriquée.
Exemple 1:
Si (condition1) Alors
……
Si (conditionN) Alors
……..
FinSi
……
Finsi

L1BCGS 2023-2024
Imbrication de structures de contrôles
q Lorsque l'on imbrique des boucles Pour, il faut utiliser des compteurs differents pour chaque
boucle.
Exemple 2:
Pour j = 1 à 3 Faire
Pour i = 1 à 5 Faire
Ecrire("*")
FinPour
FinPour

q Tous les types de boucles peuvent s'imbriquer entre eux. La seule règle à respecter est que les
boucles ne doivent pas se chevaucher: elles doivent s'emboîter

L1BCGS 2023-2024
 Instructions de rupture de séquence en langage C
L'instruction break
q L'instruction break peut être employée à l'intérieur de n'importe quelle boucle.
q Elle permet d'interrompre le déroulement de la boucle, et passe à la première instruction qui
suit la boucle. En cas de boucles imbriquées, break fait sortir de la boucle la plus interne.
Par exemple, le programme suivant:
int main()
{ Affiche à l'écran:
i=0
int i;
i=1
for (i = 0; i < 5; i++) i=2
{ i=3
printf("i = %d\n",i); valeur de i a la sortie
de la boucle = 3
if (i == 3)
break; }
printf("valeur de i a la sortie de la boucle = %d\n",i);
return 0;
}
L1BCGS 2023-2024
 Instructions de rupture de séquence en langage C
L'instruction continue
L'instruction continue permet de passer directement à l'étape suivante d'une boucle
sans exécuter les autres instructions de la boucle qui la suivent.
Par exemple, le programme suivant:
int main()
{ Affiche à l'écran:
int i; i=0
for (i = 0; i < 5; i++) i=1
i=2
{
i=4
if (i == 3) valeur de i a la sortie
continue; de la boucle = 5
printf("i = %d\n",i);
}
printf("valeur de i a la sortie de la boucle = %d\n",i);
return 0;
} L1BCGS 2023-2024
Fin du Chapitre 4

L1BCGS 2023-2024
 UNIVERSITÉ CHEIKH ANTA DIOP DE DAKAR
FACULTÉ DES SCIENCES ET TECHNIQUE
DÉPARTEMENT MATHÉMATIQUE ET INFORMATIQUE

Chapitre 5 - TYPES DE DONNÉES

COMPOSÉS

Dr. THIONGANE
[Link]@[Link]
L1BCGS
Année: 2023-2024

Cours ALGO & C

PLAN
èLes énumérations
èLes tableaux

èLes structures

Cours ALGO & C

2
Les énumérations
l Une énumération est un type de données dont les
valeurs sont des constantes nommées.
l Elles permettant de définir un ensemble de
constantes, parmi lesquelles les variables de ce
type prendront leur valeur.
l La syntaxe de définition d’un type énuméré est la
suivante :
• type
• nom_type = { constante1, constante2, …, constanteN }
Cours ALGO & C
3
 Définition des types énumérés
où nom_type est l’identificateur du nouveau type
constante1, constante2, …, constanteN est une liste d’identificateurs
donnant l’ensemble des valeurs de ce type.
Exemple:
type
// définition du type couleur
couleur = {bleu, blanc, rouge, vert, jaune, noir}
// définition du type jour
jour = {lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche}

Cours ALGO & C 4

Déclaration d’une variable de type énuméré
l Après avoir défini un type énuméré, on peut l'utiliser comme un type
normal pour déclarer une ou plusieurs variables de ce type.
l Exemple :
l …
l variable
l c : couleur // déclaration de la variable c de type couleur
l Début
l …
l c = bleu // utilisation de la variable c
l …
l Fin

Cours ALGO & C

5
 Les énumérations en C
l En C, on définit un type énuméré en utilisant le
mot-clé enum selon la syntaxe suivante :
l enum nom_énumération { nom1, nom2 ... };

Exemple
enum JourDeSemaine { Lundi, Mardi, Mercredi,
Jeudi, Vendredi, Samedi, Dimanche };
enum couleur {bleu, blanc, rouge, vert, jaune,
noir} ;
Cours ALGO & C
6
Les énumérations en C
l Chaque constante est associée à un entier (son numéro d’ordre
en partant de 0 pour le premier). Mais on peut aussi spécifier
la valeur associée.
l Exemple:
• Enum
jour{Lundi=1,Mardi,Mercredi=5,Jeudi,Vendredi,Samedi,Dimanche};
l Mardi prend la valeur 2, Jeudi la valeur 6,…
l Les valeurs associées aux constantes ne sont pas modifiables
dans le programme.
l Après avoir défini un type énuméré, on peut l'utiliser pour
déclarer une ou plusieurs variables de ce type. Exemples:
• enum jour j1;
• enum jour j2 = Mardi;

7
Exemple
#include <stdio.h>
#include <conio.h>
enum jour {Lundi=1,Mardi,Mercredi=5,Jeudi,Vendredi,Samedi,Dimanche};
int main() {
enum jour un_jour;
printf("Donnez un numéro de jour entre 1 et 7") ;
scanf("%d", &un_jour) ;
switch(un_jour ) {
case Lundi :
printf("C’est Lundi"); break ;
case Mardi :
printf("C’est Mardi"); break ;
case Mercredi :
printf("C’est Mercredi"); break ;
default :
printf("Ce n’est ni Lundi ni Mardi ni Mercredi"); }
return 0;;
} 8
Les tableaux
l Un tableau est un outil qui permet de regrouper sous le
même nom un ensemble de variables de même type.
l On appelle tableau une variable composée de données de
même type, stockée de manière contiguë en mémoire (les
unes à la suite des autres).
l Un tableau est donc une suite de cases (espace mémoire)
de même taille. La taille de chacune des cases est
conditionnée par le type de donnée que le tableau contient.

Cours ALGO & C

9
Les tableaux unidimensionnels
l Un tableau à une dimension peut être vu comme une liste
d'éléments.
l On le représente souvent comme une suite de cases
contenant chacune une valeur.
l Exemple: Tableau notes
15 13 9 17 5 10
1ère case 4ème case

l Un tableau possède un nom (ici notes) et un nombre

d'éléments (de cases) qui représente sa taille (ici 6).

Cours ALGO & C

10
Déclaration d’un tableau à une dimension
l Pour déclarer un tableau dont les éléments ont un
type de base :
• partir de la déclaration de variable ayant un type de
base ;
• ajouter entre crochets le nombre d'éléments du
tableau après le nom.
l En algorithme, la syntaxe de la définition
d'un tableau unidimensionnel est la suivante :
• nom_tableau: tableau [N] de type
Cours ALGO & C
11
Déclaration d’un tableau à une dimension
l type définit le type d'élément que contient le tableau, c'est-
à-dire qu'il définit la taille d'une case du tableau en
mémoire
l nom_tableau est le nom que l'on décide de donner au
tableau, le nom du tableau suit les mêmes règles qu'un
nom de variable
l N est un nombre entier qui détermine le nombre de cases
que le tableau doit comporter
l Exemple
• variable
• salaires : tableau[6] de réel
• étudiants: tableau [25] de chaîne
• notes : tableau[8] d’entier
12
Accéder aux éléments
l Pour accéder à un élément du tableau, le nom que l'on a
donné à celui-ci ne suffit pas car il comporte plusieurs
éléments. Ainsi, on définit un nombre appelé indice qui,
combiné avec le nom du tableau, permet de décrire
exactement chaque élément.
l Pour accéder à un élément du tableau, il suffit donc de
donner le nom du tableau, suivi de l'indice de l'élément
entre crochets :
l Nom_du_tableau[indice]

Cours ALGO & C

13
Accéder aux éléments
l Un élément particulier du tableau est désigné en précisant
son indice (son numéro).
l Le premier élément du tableau correspond à l’indice 0 et
est désigné par nom_tableau[0].
l Le deuxième élément du tableau correspond à l’indice 1 et
est désigné par nom_tableau[1].
l Le dernier élément du tableau correspond à l’indice N-1 et
est désigné nom_tableau[N-1].
l Quelque soit sa forme, la valeur de l'indice doit être
entière et comprise entre les valeurs minimale et maximale
déterminées à la déclaration du tableau.
Cours ALGO & C
14
Manipulation d’un tableau à 1 dimension
l Les éléments d'un tableau sont des variables appelées
variables indicées qui s'utilisent exactement comme
n'importe quelle autre variable classique. Autrement dit,
elles peuvent faire l'objet d'une affectation, elles peuvent
figurer dans une expression arithmétique, dans une
comparaison, elles peuvent être affichées et saisies…
l On ne peut pas manipuler un tableau de manière globale(
affectation à un autre tableau, affichage, saisie…). Il faut
le manipuler élément par élément (en le parcourant avec
une boucle Pour par exemple).

Cours ALGO & C

15
Les tableaux multidimensionnels
l Les tableaux multidimensionnels sont des tableaux qui
contiennent des tableaux.
l Par exemple le tableau bidimensionnel (3 lignes, 4
colonnes) suivant, est en fait un tableau comportant 3
éléments, chacun d'entre eux étant un tableau de 4
éléments :
a b c d
e f g h
i j k l

Cours ALGO & C

16
Les tableaux multidimensionnels
l Un tableau à plusieurs dimensions se déclare en ajoutant
une paire de crochets et une taille pour chaque dimension.
l Par exemple, pour un tableau à deux dimensions, la
syntaxe est la suivante:
• variable
• nom_tableau: tableau[N1][N2] de type
l Un tableau à deux dimensions est aussi appelé matrice.
l Exemple :
l tab : Tableau[3][2] de Réel // matrice de 3 lignes et
deux colonnes

Cours ALGO & C

17
Les tableaux multidimensionnels
l L’accès à un élément se fait en précisant un indice entre
crochets pour chaque dimension.
l Le premier indice de chaque dimension est 0.
• tab[0][0] désigne l'élément du tableau tab situé à l ligne 0 et à la
colonne 0
• tab[2][1] désigne l'élément du tableau tab situé à l ligne 2 et à la
colonne 1
l Remarque :
l Pour parcourir tous les éléments d’un tableau à deux
dimensions, on peut utiliser deux boucles Pour
imbriquées : la première boucle pour une dimension et la
deuxième pour l’autre dimension.
18
Les tableaux en C
l En C, la syntaxe de la déclaration d'une variable tableau
est la suivante:
l type nom_tableau [ N ]; où
l nom_tableau est l’identificateur du tableau
l N est la taille du tableau et doit être une constante entière
et positive.
l Exemple :
• int tab[10] ; //déclare une variable tableau de 10 entiers appelée tab.
• tab[0] désigne le premier élément du tableau tab
• tab[9] désigne le dernier élément du tableau tab

Cours ALGO & C

19
Initialisation d'un tableau
l Il est possible d'initialiser un tableau avec une liste
d'expressions constantes séparées par des virgules, et
entourée des signes { et }. Exemple :
• #define N 5
• int t[N] = {1, 2, 3, 4, 5};
l On peut donner moins d'expressions constantes que le
tableau ne comporte d'éléments.
l Dans ce cas, les premiers éléments du tableau seront
initialisés avec les valeurs indiquées, les autres seront
initialisés à zéro.
• #define N 10
• int t[N] = {1, 2};
Cours ALGO & C 20
Cas particulier des tableaux de caractères
l Un tableau de caractères peut être initialisé par une liste de
constantes caractères.
l Exemple : char ch[3] = {'a', 'b', 'c'}; C'est évidemment une
méthode très lourde.
l Un tableau de caractères peut être initialisé par une chaîne
littérale. Exemple :
• char ch[8] = "exemple";
l On se rappelle que le compilateur complète toute chaîne
littérale avec un caractère null, il faut donc que le tableau
ait au moins un élément de plus que le nombre de
caractères de la chaîne littérale.
Cours ALGO & C 21
Cas particulier des tableaux de caractères
l Il est admissible que la taille déclarée pour le tableau soit
supérieure à la taille de la chaîne littérale. Exemple :
l char ch[100] = "exemple"; dans ce cas, seuls les 8
premiers caractères de ch seront initialisés.
l Il est également possible de ne pas indiquer la taille du
tableau et dans ce cas, le compilateur a le bon goût de
compter le nombre de caractères de la chaîne littérale et de
donner la taille adéquate au tableau (sans oublier le
null). Exemple :
• char ch[] = "ch aura 22 caractères";

Cours ALGO & C

22
Fonctions de manipulation de chaînes
l La bibliothèque standard string.h fournit des fonctions de
manipulations des chaînes de caractères.
• Après la déclaration, l’affectation d’une chaîne se fera par la fonction
strcpy.
• Exemple : strcpy(ch, ''hello'') ;
• La longueur (le nombre de caractères) d’une chaîne est donnée par la
fonction strlen.
• Cette fonction ne prend pas en compte le caractère \0.
• Exemple : strlen(''bonjour'') retourne 7.
• La concaténation de deux chaînes se fait par la fonction strcat.
• Exemple : strcat(ch, '' world'') ; la chaîne contient alors ''hello world''

Cours ALGO & C

23
Fonctions de manipulation de chaînes
l La comparaison de deux chaînes se fait par
la fonction strcmp.
• Exemple : n = strcmp(ch1, ch2) ;
• n vaudra :
• un nombre négatif si ch1 < ch2 au sens syntaxique
• 0 si ch1 et ch2 sont identiques
• un nombre positif si ch1 > ch2

Cours ALGO & C

24
Notion de structure
l Il est habituel en programmation d'avoir besoin d'un
mécanisme permettant de grouper un certain nombre de
variables de types différents au sein d'une même entité.
l On travaille par exemple sur un fichier de personnes et on
voudrait regrouper une variable de type chaîne de
caractères pour le nom, une variable de type entier pour le
numéro d'employé, etc.
l La réponse à ce besoin est le concept d'enregistrement : un
enregistrement est un ensemble d'éléments de types
différents repérés par un nom.
l Les éléments d'un enregistrement sont appelés des
champs.
Cours ALGO & C
25
Déclaration d’un type structure
l La syntaxe de déclaration d’un type énuméré est la
suivante :
• type
• nom_type = Structure
• champ1 : type1
• ...
• champN : typeN
• FinStructure
l nom_type est l’identificateur du nouveau type
l type1, …, typeN sont les types respectifs des champs
champ1, …, champN

Cours ALGO & C

26
Déclaration d’un type structure
type
date = Structure
jour : entier
mois : chaîne
année : entier
FinStructure
variable
d : date // d est une variable de type date.

Cours ALGO & C

27
Les opérations sur les structures
l On accède aux différents champs d'une structure grâce à
l'opérateur point, noté ''.''.
l Par exemple, le champ appelé champ1 d’une variable
structure x est désigné par l'expression x.champ1
l On peut effectuer sur le champ d'une structure toutes les
opérations valides sur des variables de même type que ce
champ.
l On peut appliquer l'opérateur d'affectation à une structure
(à la différence d’un tableau). Cela permet de copier tous
les champs de la structure.

Cours ALGO & C

28
Les structures en langage C
l En C, on définit un type structure en utilisant le mot-clé
struct selon la syntaxe suivante :
struct nom_type
{Type1 nom_champ1;
...
• TypeN nom_champN;
• };

Cours ALGO & C

29
Exemple
struct complexe
{ float réelle;
float imaginaire;
};
struct complexe c1,c2;
qui déclare deux variables de type struct complexe de noms
c1 et c2;
c1.réelle=4;
[Link]=90;

30
Utilisation du mot clé typedef
l Pour alléger l'écriture des programmes, on peut donner un
nouvel identificateur à un type existant à l'aide du mot clé
typedef.
l Pour les types de base ainsi que les énumérations et les
structures, la syntaxe est la suivante :
l typedef type synonyme;
• enum couleur {bleu, blanc, rouge, vert, jaune, noir} ;
• typedef enum couleur couleur ;
• main(){
• couleur c ; // c est une variable de type couleur
• …
• }
Cours ALGO & C
31
 FIN
Cours ALGO & C
32
 Université Cheikh Anta Diop de DAKAR
Faculté des Sciences et technique
Département Mathématique et Informatique

Chapitre 6 - Procédure et Fonction

Cours d’algorithmique et programmation en

LANGAGE C
L1BCGS
2020-2021

1 FST L1BCGS
 Notion de procédure et de fonction
— Bien souvent, lorsqu’on commence à écrire de long programme,
on se rend rapidement compte que certains blocs d’instructions
se répètent.
— Une procédure ou fonction est un bloc d’instructions, ayant un
début et une fin, et identifié par un nom.
— En langage C, des sous programmes regroupés dans des
bibliothèques standards peuvent être utilisés directement dans
n'importe quel programme. Par exemple, printf, scanf, clrscr,
sqrt, …
— Mais le programmeur est souvent amené à écrire ses propres
sous-programmes.

2 FST L1BCGS
 Portée d’une variable
— La portée d’une variable est l’ensemble des sous-
programmes où cette variable est connue
— Une variable déclarée en dehors de tout sous-programme
est appelée variable globale. Sa portée est totale : le
programme principal et tous les sous-programmes peuvent
utiliser cette variable.
— Une variable déclarée au sein d’un sous programme est
appelée variable locale. Sa portée est uniquement le sous-
programme où elle est déclarée.
— Lorsque, dans un sous programme, le nom d’une variable
locale est identique à celui d'une variable globale, la
variable globale est localement masquée.
3
FST L1BCGS
 Durée de vie d’une variable
— La durée de vie d’une variable est le temps pendant lequel
la variable existe, c’est-à-dire pendant lequel elle peut être
utilisée.
— Elle commence par la réservation de sa place en mémoire
et s’arrête lorsque cette place est libérée.
— Ainsi, une variable globale a la même durée que le
programme principal : elle est créée quand le programme
est lancé et est « détruite » quand le programme s’arrête.
— Une variable locale à un sous-programme est créée quand
le sous-programme est appelé. Quand le sous-programme
est terminé, elle est détruite et la place qu’elle occupait est
récupérée.
4
FST L1BCGS
 Communication entre programme
et sous-programmes
— Contrairement à un programme, un sous-
programme ne peut pas s'exécuter
indépendamment d'un autre programme. Le
programme qui utilise un sous-programme est
appelé programme appelant.
— Un sous-programme peut être appelé soit par un
programme, soit par un autre sous-programme (qui
lui même a été appelé).

5 FST L1BCGS
 Paramètre formel et paramètre
effectif

— Un paramètre est une variable particulière qui sert à la

communication entre programme appelant et sous -
programme.
— Il est primordial de bien distinguer les paramètres qui se
trouvent dans l'en-tête d'un sous programme, lors de sa
définition et les paramètres (ou arguments) qui se trouvent
placés entre parenthèses lors de l'appel.
— Les paramètres placés dans la définition d’un sous
programme sont les paramètres formels . Ils servent à
décrire le traitement à réaliser par le sous programme
indépendamment des valeurs traitées
6 FST L1BCGS
 Paramètre formel et paramètre
effectif

— Les paramètres avec lesquels le sous programme est

effectivement appelé sont les paramètres effectifs ou
réels.
— Lorsqu'il y a plusieurs paramètres dans la définition d’un
sous programme (paramètres formels) , il faut absolument
qu'il y en ait le même nombre à l'appel (paramètres
effectifs) et que l'ordre soit respecté.
— Chaque paramètre effectif doit être de même type que le
paramètre formel auquel il correspond.

7 FST L1BCGS
 Passage de paramètres

— Dans l’appel d’un sous programme, le programme

appelant fournit des paramètres effectifs
correspondants aux paramètres du sous programme
(paramètres formels). Il y a alors ce qu’on appelle un
passage de paramètres.
— Le passage d’un paramètre peut se faire suivant deux
modes.

8 FST L1BCGS
 Passage de paramètre en entrée
— Lors de l'appel du sous programme, la valeur du
paramètre effectif (passé en argument) est copiée
dans le paramètre formel. Le sous programme
effectue alors le traitement avec le paramètre
formel et n'utilise pas directement le paramètre
effectif.
— Les instructions du sous-programme ne peuvent
donc pas modifier le paramètre fourni par le
programme appelant (paramètre effectif).

9 FST L1BCGS
 Passage de paramètre en entrée-
sortie
— Ce mode de passage de paramètre est à utiliser lorsque
le sous-programme doit pouvoir utiliser et/ou modifier
la valeur du paramètre fourni par le programme
appelant.
— Pour ce mode de passage on ne peut pas utiliser de
constante ou de valeur comme paramètre effectif.

10 FST L1BCGS
 Les fonctions
— Les fonctions sont des sous-programmes qui retournent un
et un seul résultat au programme appelant à travers une
valeur de retour.
— Une fonction possède un type : c’est le type de la valeur
retournée.
— Les paramètres sont en nombre fixe (>=0).
— Le passage de paramètres est uniquement en entrée : c’est
pour cela qu’il n’est pas précisé.
— La valeur de retour est spécifiée par l’instruction
Retourner

11 FST L1BCGS
 Syntaxe de définition d’une
fonction :
— Fonction nom_fonction (paramètre1 : type1, paramètre2 :
type2, …, paramètreN : typeN) : type_ valeur_retournée
— variable
— // déclaration des variables locales
— Début
— // traitement
— …
— Retourner expression
— FinFonction

12 FST L1BCGS
 Exemple
Fonction factoriel(n: entier) : entier
variable
i : entier
fact : entier ………….
Début début
fact =1 Ecrire("Calcul du factoriel d’un entier :")
Si (n != 0) Alors Ecrire("Entrez un entier :")
Pour i = 1à n Faire Lire(x)
fact = fact * i Ecrire("Le factoriel de ",x," est ",factoriel(x))
FinPour fin
FinSi
Retourner fact
FinFonction

13 FST L1BCGS
 Les procédures
— Une procédure est un sous programme qui n’a pas de
valeur de retour mais elle peut renvoyer plusieurs résultats
au programme appelant à travers des paramètres en entrée-
sortie. Elle peut aussi modifier la valeur d'un
paramètre passé en entrée-sortie.
— Les procédures admettent des paramètres avec des
passages :
— en entrée, préfixés par Entrée (ou E)
— en entrée-sortie, préfixés par Entrée-Sortie (ou E-S)

14 FST L1BCGS
 Déclaration

— On déclare une procédure de la façon suivante :

—
— Procédure nom de la procédure ( E paramètre(s) en
entrée, E-S paramètre(s) en entrée-sortie )
— Variable Procédure echanger (E-S a : Entier, b : Entier;)
— // déclaration des variables locales
Variable
tmp : Entier
— Début Début
— // traitement tmp = a
a=b
— … b = tmp
FinProcédure
— FinProcédure
15 FST L1BCGS
 Syntaxe de définition d’une
fonction en Langage C
type nomFonction ( type1 paramètre1 , type2 paramètre2 , . . . , typeN
paramètreN)
{
// déclaration des variables locales
// traitement
…
return expression ;

}
int addition (int a, int b)
{
int somme; //déclaration de la variable locale
somme
somme = a + b;
return(somme);
}
16 FST L1BCGS
 Remarques
— 1) Il n’y a pas de procédure en C.
— Pour traduire une procédure, on écrit une fonction qui a
comme type de retour le type void.
— Cela permet de spécifier que la fonction ne renvoie aucun
résultat. Dans ce cas, pour terminer l'exécution de la
fonction, on peut utiliser le mot-clé return seul ou plus
simplement atteindre la fin des instructions.
— 2) Le programme principal en C est une fonction dont le
nom est main. Il peut avoir des paramètres ou non.

17 FST L1BCGS
 Passage de paramètres
— Lors de l'appel d’une fonction, la valeur de chaque
paramètre effectif (paramètre passé en argument) est
recopiée dans le paramètre formel de la fonction qui va
travailler avec cette copie. La fonction ne va donc pas
modifier le paramètre effectif. On parle de passage de
paramètre par valeur.
— Pour qu’une fonction modifie la valeur d’une variable, il
faut passer à la fonction non pas la variable elle même mais
son adresse en mémoire. On parle de passage de paramètre
par adresse.

18 FST L1BCGS
 FIN
19 FST L1BCGS