Cours de Programmation Procédurale DAWM-ASRS

L1 : DAWM-ASRS Année Académique 2020-2021
Chapitre 1 : les bases de la programmation en langage C
Prérequis : il faut plusieurs qualités pour arriver à tenir jusqu’au bout de la

programmation en C : la motivation, la logique, la patience, la rigueur et la passion
1. Historique
C est un langage de programmation impératif généraliste, de bas niveau. Inventé au

début des années 1970 par Dennis Ritchie, pour réécrire le SE UNIX, C est devenu
un des langages les plus utilisés, encore de nos jours. De nombreux langages plus
modernes comme C++, C#, Java et PHP ou Javascript ont repris une syntaxe similaire
au C et reprennent en partie sa logique. C offre au développeur une marge de contrôle
importante sur la machine (notamment sur la gestion de la mémoire) et est de ce fait
utilisé pour réaliser les « fondations » (compilateurs, interpréteurs…) de ces langages
plus modernes.
2. Définitions
La programmation est une branche de l’informatique qui sert à créer des programmes.
Tout ce que vous possédez sur votre ordinateur est un programme : votre navigateur
Internet, Windows, votre lecteur MP3 donne des instructions à l’ordinateur pour
écouter de la musique, …
Un programme est une séquence d’instructions, d’ordres, donnés à l’ordinateur afin

qu’il exécute des actions. Ces instructions de base sont : addition, multiplication,
soustraction, division, comparer, trier.
Pour programmer, il faut un langage de programmation qui joue le rôle d’intermédiaire

entre l’homme et la machine. Il permet de faire effectuer des tâches à une machine
programmable en utilisant des concepts proches de la pensée humaine.
08/05/2021
Cours de programmation procédurale Chargé du cours : M. Eléazar

1
Schéma explicatif
Ex.
a. Pourquoi programmer en c
 Sa popularité : il fait partie des langages de programmation les plus utilisés.

Disponibilité de doc et forum
 Sa rapidité : le C est connu pour être un langage très rapide, ce qui en fait un
langage de choix pour tout programme.
 Sa légèreté : le C est léger, ce qui le rend utile pour les programmes embarqués
où la mémoire disponible est faible.
 Sa portabilité : cela veut dire qu’un programme développé en C marche
théoriquement sur n’importe quelle plateforme. Il faut savoir que le C a été
conçu pour la programmation système (drivers, systèmes d'exploitation,
matériel embarqué, etc).
08/05/2021
b. Différence entre C, C++ et C#

2
C est un langage de programmation procédurale et ne prend pas en charge les classe

et les objets alors que C++ est une combinaison de langage de programmation
procédurale et orientée objet.
La principale différence entre C# et C++ réside dans ses applications ou C# peut être
utilisé pour développer des applications web professionnelles, tandis que le C++ est
utile lorsque le programmeur souhaite créer quelque chose qui nécessite une
interaction étroite avec le matériel.
Processus de compilation d’un programme en C++
Le code en langage intermédiaire (CIL) correspond au programme que vous allez

distribuer. Sous Windows, il prend l'apparence d'un .exe comme les programmes
habituels, mais il ne contient en revanche pas de binaire. Lorsqu'on exécute le
programme CIL, celui-ci est lu par un autre programme (une machine à analyser les
programmes, appelée CLR) qui le compile cette fois en vrai programme binaire.
3. Classement de quelques langages
Le schéma ci-dessous représente quelques langages de programmation classés par

« niveau » (figure suivante).
08/05/2021

3
4. Les logiciels nécessaires pour programmer
Les outils nécessaires pour programmer en C sont entre autres :
 Un éditeur de texte : ce logiciel va servir à écrire le code source ;

 un compilateur : c’est le logiciel qui permet de transformer le code que l’on écrit
en un fichier exécutable compréhensible par le processeur ;
 un débugger / débogueur: fondamentalement, il n’est pas indispensable, mais
ce logiciel est très utile pour chasser les bugs et vérifier le comportement de
son programme.
Remarques : on peut prendre séparément ces logiciels et compiler par soi-même, ou

on peut utiliser un logiciel qui réunit les trois : un IDE (« Environnement de
Développement Intégré » en français).
Ex. IDE : code ::blocks ; visual C++, Visual C++ Express
5. Types de programme en C
Avant de commencer à programmer, il faut définir ce que vous allez programmer,

autrement dit le type de programme que vous allez réaliser. Il existe 2 types de
programmes : les programmes graphiques et les programmes console :
08/05/2021
 Les programmes graphiques affichent des fenêtres. Ils génèrent à l'écran des
fenêtres que l'on peut ouvrir, réduire, fermer, agrandir…

4
 Les programmes en console sont plus fréquents sous Linux que sous Windows
et Mac OS X. Ils sont constitués de simples textes qui s'affichent à l'écran, le
plus souvent en blanc sur fond noir.
a. Code minimal d’un IDE
Code :: Blocks a donc généré le minimum de code en langage C que voici :
Code : C
#include <stdio.h>
#include <stdlib.h>
int main()
{
printf("Hello world!\n");
return 0;
}
b. Explication du code source
#include <stdio.h> et #include <stdlib.h>: sont des en-tête du fichier source sont
appelées directives de préprocesseur (bibliothèque/librairie) ou un programme qui se
lance au début de la compilation. Le mot include en anglais signifie « inclure » en
français. Ces fichiers (stdio.h et stdlib.h) contiennent du code tout prêt qui permet
d'afficher du texte à l'écran, récupérer des informations, quitter le programme, lire un
fichier, etc
Fichier d'en-tête : stdio.h, qui signifie « Standard input output », soit « Entréesortie
standard ». Ce fichier d'en-tête va nous permettre de communiquer avec l'utilisateur
en affichant des messages à l'écran et en récupérant des informations.
À l’intérieur des parenthèses, il y a le mot « void ». Ce mot-clé signifie « Je ne veux

pas de paramètres ». Il est en effet possible de donner des paramètres à la fonction
main, mais ce n'est pas de notre niveau.
int main() { printf("Hello world!\n"); return 0; } : Une fonction « main ou principal »

08/05/2021
est la fonction principale du programme qui permet en grosso modo de rassembler

plusieurs commandes à l'ordinateur. C’est toujours par la fonction « main » que le

5
programme commence. Une fonction a un début et une fin, délimités par des
accolades {et}. Les lignes à l'intérieur d'une fonction sont des instructions. La première
ligne : printf("Hello world!\n"); demande à afficher le message « Hello world! » à
l'écran. Quand votre programme arrivera à cette ligne, il va donc afficher un message
à l'écran, puis passer à l'instruction suivante : return 0; qui indique qu'on arrive à la fin
de notre fonction main et demande de renvoyer la valeur 0 (0 veut dire tout s'est bien
passé et n'importe quelle autre valeur signifie « erreur »). Noter que toute instruction
se termine obligatoirement par un point-virgule « ; ».
printf est une fonction toute prête qui permet d'afficher un message à l'écran dans une
console. printf se trouve dans une bibliothèque (<stdio.h>et <stdlib.h>:) où l'on
retrouve de nombreuses autres fonctions prêtes à l'emploi. stdio.h en particulier
contient des fonctions permettant d'afficher des choses à l'écran (comme printf).
c. Schéma récap
6. Écrire un message à l'écran avec commentaires
Votre tâche est d’afficher un message « Bonjour les débutants en langage c » à l'écran
(dans la console) puis le curseur revient à la ligne.
Code : C
/* Ci-dessous, ce sont des directives de préprocesseur. Ces lignes permettent d'ajouter
des fichiers au projet, fichiers que l'on appelle bibliothèques. Grâce à ces
bibliothèques, on disposera de fonctions toutes prêtes pour afficher par exemple un
message à l'écran.*/
08/05/2021
#include <stdio.h>
#include <stdlib.h>

6
/*Ci-dessous, vous avez la fonction principale du programme, appelée main. C'est par
cette fonction que tous les programmes commencent. Ici, ma fonction se contente
d'afficher Bonjour à l'écran.*/
int main()
{
printf("Bonjour les débutants en langage c \n"); //Cette instruction affiche Bonjour à
l'écran
return 0; // Le programme renvoie le nombre 0 puis s'arrête
}
Remarques :
 la console de Windows ne gère pas les accents, par contre la console de Linux,
oui.
 deux caractères spéciaux :
- \n : retour à la ligne (= « Entrée ») ;
- \t : tabulation.
Dans notre cas, pour faire une entrée, il suffit de taper \n pour créer un retour à la ligne.
Si je veux donc faire un retour à la ligne juste après le mot « Bonjour », je devrais taper
: printf("Bonjour\n");
7. Utilisation de la mémoire
En théorie, un ordinateur est capable de stocker tout type d’information. Mais comment
est-il possible de réaliser un tel miracle alors qu’il ne s’agit finalement que d’un amas
de circuits électriques ? il faut commencer par comprendre comment notre ordinateur
fait pour stocker des données.
a. Codage des informations
Le problème ici consiste à transformer une information en nombre (0 et 1) pour que

l’ordinateur puisse la traiter, autrement dit la numériser. Pour cela, nous utilisons la
08/05/2021
Table de correspondance.

7
La base correspond au nombre de chiffres disponibles pour représenter un nombre.

En base 10, nous disposons de dix chiffres : zéro, un, deux, trois, quatre, cinq, six,
sept, huit et neuf. En base deux, nous en avons donc… deux : zéro et un. Ci-dessous
un petit tableau de correspondance entre la base deux et la base dix.
Remarques : Mais pourquoi utiliser la base deux et non la base dix ? Parce que les
données circulent sous forme de courants électriques. Or, la tension de ceux-ci n’étant
pas toujours stable, il est difficile de réaliser un système fiable sachant détecter dix
valeurs différentes. Par contre, c’est parfaitement possible avec deux valeurs : il y a
du courant ou il n’y en a pas.
b. La mémoire
Les bits sont stockés dans un composant électronique particulier de l’ordinateur : la

mémoire. La mémoire de l’ordinateur est segmentée en plusieurs sous-mémoires, de
taille et de vitesse différentes, utilisées chacune suivant les besoins (mémoire avec
08/05/2021
peu de données et rapide, mémoire avec plus de données et lente). Les types de
mémoires :

8
 les registres : une mémoire ultra-rapide intégrée directement dans le

processeur ; utilisées pour stocker des données temporaires.
 la mémoire cache : elle fait le lien entre les registres et la mémoire vive ;
 la mémoire vive : c'est la mémoire avec laquelle nous allons travailler le plus
souvent ; utilisée pour stocker les programmes en court d’exécution ainsi que
les données qu’ils manipulent ;
 le disque dur : mémoire de grande capacité pour stocker un système
d’exploitation ou des fichiers personnels. Elle assure la persistance des
données
b1. Bit et adresse mémoire
Dans la mémoire vive, les bits sont regroupés en « paquets » de quantité fixe : des «
cases mémoires », appelées multiplets (ou bytes en anglais). Les mémoires utilisent
des multiplets de huit bits, appelés octet. Un octet peut stocker 256 informations
différentes (vous pouvez faire le calcul vous-même : combien vaut 11111111 en base
deux ?). Pour stocker plus d’informations, il sera nécessaire d’utiliser plusieurs octets.
Chaque multiplet de la mémoire vive se voit attribuer un nombre unique appelé

adresse (référence), qui va permettre de le sélectionner et de l’identifier parmi tous les
autres.
08/05/2021

9
B2. Les représentations octales et hexadécimales
08/05/2021

10
L’avantage des représentations octale et hexadécimale est qu’il est facilement

possible de les convertir en binaire contrairement à la représentation décimale.
08/05/2021

11
B3. Les variables
Tout cela est bien sympathique, mais manipuler explicitement des références (des
adresses) est un vrai calvaire, de même que de s’évertuer à calculer en base deux.
Heureusement pour nous, les langages de programmation (et notamment le C), se
chargent d’effectuer les conversions pour nous et remplacent les références par des
variables. Une variable correspondra à une portion de mémoire, appelée objet, à
laquelle nous donnerons un nom. Ce nom permettra d’identifier notre variable, tout
comme une référence permet d’identifier une portion de mémoire parmi toutes les
autres. Nous allons ainsi pouvoir nommer les données que nous manipulons, chacun
de ces noms étant remplacés lors de la compilation par une référence (le plus souvent
une adresse).
8. Déclarer une variable
une variable est constituée de deux éléments obligatoires: un type et un identificateur

qui est en gros le «nom» de la variable.
Syntaxe : type identificateur ;
a. Les types
un type permet d’indiquer au compilateur quel genre de données nous souhaitons

stocker. Définir le type d’une variable permet donc de préciser son contenu potentiel.
Ce type va permettre de préciser :
— toutes les valeurs que peut prendre la variable ;
— les opérations qu’il est possible d’effectuer.
Le langage C fournit neuf types de base :

08/05/2021

12
Les types short int, int, long int et long long int sont des types signés et servent tous à
stocker des nombres entiers qui peuvent prendre des valeurs positives, négatives, ou
nulles.
Un type entier non signé (ex. _Bool, 0 ou 1) est un type entier qui n’accepte que des
valeurs positives ou nulles.
Les types float, double et long double permettent quant à eux de stocker des nombres
réels.
b. Capacité d’un type
Le nombre de multiplets occupés par une variable est limité aux valeurs suivant son
type.
08/05/2021

13
c. Les identificateurs
il y a quelques limitations du choix d’un identificateur :
— seuls les 26 lettres de l’alphabet latin (majuscules ou minuscules), le trait de

soulignement « _ » (underscore en anglais) et les chiffres sont acceptés. Pas
d’accents, pas de ponctuation ni d’espaces ;
— un identificateur ne peut pas commencer par un chiffre ;
— Les mots-clés sont des mots spéciaux, réservés par le compilateur, que l’on ne peut
pas utiliser comme on veut. Ils servent à déclarer des variables et certains concepts ;
il s’agit de :
08/05/2021

14
— deux variables ne peuvent avoir le même identificateur (le même nom).
— les identificateurs peuvent être aussi longs que l’on désire, toutefois le compilateur
ne tiendra compte que des 63 premiers caractères.
Ex. Voici quelques exemples pour bien comprendre.
À noter que le C fait la différence entre les majuscules et les minuscules (on dit qu’il
respecte la casse). Ainsi les trois identificateurs suivants sont différents.
variable
Variable
VaRiAbLe
08/05/2021

15
d. Les opérateurs
Les opérateurs sont des symboles à la base des expressions.
Les opérateurs peuvent être classés en C en 4 catégories :
les opérateurs arithmétiques : + ++ − −− ∗ / ;

les opérateurs d’affectation : = ;
les opérateurs logiques : ||, &&, ! ;
les opérateurs de comparaison : < > <= >= == ! = ;
Exemples de calculs de base avec les opérateurs
int resultat = 0;
resultat = 5 + 3;
printf("5 + 3 = %d", resultat); // 5 + 3 = 8
int resultat = 0;
resultat = 5 / 2;
printf ("5 / 2 = %d", resultat); // 5 / 2 = 2
solution :
double resultat = 0;
resultat = 5.0 / 2.0; printf ("5 / 2 = %f", resultat);// 5 / 2 = 2.500000
Voici quelques exemples de modulos : 5 % 2 = 1 ;

14 % 3 = 2 ;
4 % 2 = 0.
Calcul entre variables : écrire un un programme qui demande deux nombres à

l'utilisateur et affiche la somme de ces deux nombres.
int main()
{
int resultat = 0, nombre1 = 0, nombre2 = 0;
// On demande les nombres 1 et 2 à l'utilisateur :
printf("Entrez le nombre 1 : ");
scanf("%d", &nombre1);
08/05/2021
printf("Entrez le nombre 2 : ");

scanf("%d", &nombre2);
// On fait le calcul :
resultat = nombre1 + nombre2;

16
// Et on affiche l'addition à l'écran :

printf ("%d + %d = %d\n", nombre1, nombre2, resultat);
return 0;
}
Résultat
Entrez le nombre 1 : 30
Entrez le nombre 2 : 25
30 + 25 = 55
9. Utiliser #include <math.h> pour faire certains calculs

 fabs est une fonction qui retourne la valeur absolue d'un nombre :
double absolu = 0, nombre = -27;

absolu = fabs(nombre); // absolu vaudra 27
Cette fonction renvoie un double, donc votre variable absolue doit être de type double.
 ceil est une fonction qui renvoie (un double) le premier nombre entier après le
nombre décimal qu'on lui donne.
double dessus = 0, nombre = 52.71;

dessus = ceil(nombre); // dessus vaudra 53
 floor est l'inverse de la fonction précédente : Si vous lui donnez 37.91, la

fonction floor vous renverra donc 37.
 pow est une fonction qui permet de calculer la puissance d'un nombre.
Syntaxe : pow(nombre, puissance);
double resultat = 0, nombre = 2;

resultat = pow(nombre, 3); // résultat vaudra 2^3 = 8
 sqrt est une fonction qui calcule la racine carrée d'un nombre. Elle renvoie un
double
double resultat = 0, nombre = 100;

resultat = sqrt(nombre); // résultat vaudra 10
Exemple de déclarations des variables

08/05/2021
1 int main(void)
2{
3 _Bool booleen;
4 double taille;

17
5 unsigned int age;

6 char caractere;
7 short petite_valeur;
8
9 return 0;
10 }
Ex. de séparateurs
int x=0,y,rep;
int x = 0, y, rep;
int age, taille, nombre;
int annee, mois, jour;
int age, taille;
int x, y, z;
10. Initialiser une variable
C’est de lui attribuer une valeur.
Ex. type identificateur = valeur;
 _Bool booleen = 0;
 unsigned char age = 42;
 long score = -1;
 double pi = 3.14;
 double a = 5 mais double a = 5. (certains préfèrent double a = 5.0, cela revient
au même).
 double f = 1E-1; /* 1x10^-1 = 0.1 */
 char a = 'a';
 const double pi = 3.14159265; /* Rendre une variable constante avec const* /
11. Affecter une valeur à une variable

08/05/2021
Syntaxe : identificateur = nouvelle_valeur;
Ex.
age = 30;

18
taille = 177.5;
petite_valeur = 2;
Le code suivant est donc incorrect. : int age = 15; int age = 20;
12. Les raccourcis code

a. Incrémentation et décrémentation
Ce sont deux opérations qui, respectivement, ajoute ou enlève 1 à une variable. On

pourrait aussi utiliser ces raccourcis :
variable += 1;
variable -= 1;
//incrémentation ou décrémentation postfixée
variable++;// on ajoute 1
variable--;//on enlève 1
//incrémentation ou décrémentation pré fixée
++variable;
--variable;
Il y a une subtile différence entre les deux formes. Une [in/dé]crémentation préfixée
change la valeur de l’expression avant d'envoyer la valeur, alors qu’une
[in/dé]crémentation post-fixée renvoie la valeur et la modifie ensuite.
Exemple pour bien comprendre : si j'ai une variable a qui vaut 5, ++a incrémentera
08/05/2021
immédiatement la variable a, qui vaudra alors 6.
int a = 5 ;
int b = ++a ; /* ici, b vaudra 6 */

19
Par contre, a++ attendra avant d'incrémenter la variable : celle-ci sera incrémentée
après la prochaine "utilisation".
int a = 5 ;
int b = a++ ; /* ici, b vaudra 5, et a sera mis à 6 une fois que la valeur de a++ est
recopiée dans b */
13. Les conversions de type
La conversion de type est une opération qui consiste à changer le type d’une variable
en un autre.
Syntaxe : (<Type>) <Expression>
Ex. la conversion d’un double en int :
int a;
const double pi = 3.14;
a = (int) pi;
La valeur de pi reste inchangée, elle vaudra toujours 3.14 dans la suite du programme.
Par contre, a vaut maintenant 3, puisque le flottant a été converti en entier. Expliciter
une conversion peut nous servir quand on veut forcer le résultat d’une opération par
exemple. Imaginons que nous voulons faire une division, mais que les deux opérandes
soient de type int.
int a, b;
double c;
a = 5;
b = 9;
c = a / b;
Vu qu’on fait une division euclidienne, le résultat sera tronqué. Si on veut avoir un
résultat avec la partie décimale, il suffit de faire une conversion explicite d’un des deux
opérandes en double :
c = (double) a / b;
/* ou */
c = a / (double) b;
08/05/2021

20
Chapitre 2 : les entrées et les sorties
Les entrées permettent de recevoir une donnée en provenance de certains

périphériques. Les données fournies par ces entrées peuvent être une information
envoyée par le disque dur, la carte réseau, le clavier, la souris, un CD, un écran tactile.
À l’inverse, les sorties vont transmettre des données vers ces périphériques. On
pourrait citer l’exemple de l’écran : notre ordinateur lui envoie des informations pour
qu’elles soient affichées.
1. Les sorties
la fonction printf() permet d’afficher (de sortir) du texte dans la console ou à l’écran.
Ex.
#include <stdio.h>
int main(void)
{
printf("Bonjour tout le monde !\n");
return 0;
}
2. Les formats
Ce sont des repères au sein d’un texte qui indique à printf() que la valeur d’une variable
est attendue à cet endroit.
Exemple pour une variable de type int.
#include <stdio.h>
int main(void)
{
int variable = 20;
printf("%d\n", variable);
return 0;
}
08/05/2021
Un format commence toujours par le symbole % et est suivi par une ou plusieurs lettres
qui indiquent le type de données que nous souhaitons afficher. Cette suite de lettre est
appelée un indicateur de conversion. En voici une liste non exhaustive.

21
Ex.
#include <stdio.h>
int main(void)
{
char z = 'z';
char a = 10;
unsigned short b = 20;
int c = 30;
long d = 40;
float e = 50.;
double f = 60.0;
long double g = 70.0;
printf("%c\n", z);
printf("%d\n", a);
printf("%u\n", b);
printf("%o\n", b);
printf("%x\n", b);
printf("%d\n", c);
08/05/2021
printf("%li\n", d);
printf("%f\n", e);
printf("%e\n", f);
g = 80.0;

22
printf("%Lg\n", g);
return 0;
}
Remarque : Si vous souhaitez afficher le caractère % vous devez le doubler %%. A
noter que vous devez aussi préciser les nombres flottants :
double x = 42.42734;
printf("%.2f\n", x); //résultat 42.43
3. Les caractères spéciaux
le C permet de gérer les caractères spéciaux en utilisant une séquence

d’échappement. Il s’agit d’une suite de caractères commençant par le symbole \ et
suivie d’une lettre.
Ex.
#include <stdio.h>
int main(void)
{
printf("Quelques sauts de ligne\n\n\n");
printf("\tIl y a une tabulation avant moi !\n");
printf("Je voulais dire que...\r");
printf("Hey ! Vous pourriez me laisser parler !\n");
return 0;
}
08/05/2021
Ex. il est possible d’écrire un long texte sans appeler plusieurs fois la fonction printf().

23
#include <stdio.h>
int main(void)
{
printf("Texte écrit sur plusieurs "
"lignes dans le code source "
"mais sur une seule dans la console.\n");
return 0;
}
4. Interagir avec l’utilisateur (entrée)
La fonction scanf permet de récupérer des informations fournies par les périphériques
contrairement à la fonction printf qui affiche les informations.
Ex.
#include <stdio.h>
int main(void)
{
int age;
printf("Quel âge avez-vous ? ");
scanf("%d", &age);
printf("Vous avez %d an(s)\n", age);
return 0;
}
La fonction scanf() a besoin de connaitre l’emplacement en mémoire de nos variables
afin de les modifier. Afin d’effectuer cette opération, nous utilisons le symbole &.
L’opérateur & permet de transmettre l’adresse d’une variable à scanf().
Pour ce qui est des indicateurs de conversions, ils sont un peu différents de ceux de
printf().
08/05/2021

24
En passant, sachez qu’il est possible de lire plusieurs entrées en même temps, par
exemple comme ceci.
int x, y;
scanf("%d %d", &x, &y);
printf("x = %d | y = %d\n", x, y);
5. cas particulier
 L’utilisation de la fonction puts est plus simple puisqu’elle ne se contente
d'afficher que des chaînes de caractères simples.
Ex
puts("Salut les zeros !");
int var = 0;
puts("%d", var);
 La fonction putchar affiche tout simplement un caractère.
Ex.
putchar('c');
08/05/2021
char caractere = 'Z';

putchar(caractere);

25
Exercice
Essayez de coder une mini calculatrice qui : Dit bonjour ;
Demande deux nombres entiers à l’utilisateur ;
Les additionne, soustrait, multiplie et les divise (avec un arrondi au millième) ;
Dit au revoir.
Solution
#include <stdio.h>
int main(void)
{
int nombre_1, nombre_2;
printf("Bonjour !\n\n");
/* On demande a l'utilisateur deux nombres */
printf("Veuillez saisir le premier nombre : ");
scanf("%d", &nombre_1);
printf("Veuillez saisir le deuxième nombre : ");
scanf("%d", &nombre_2);
/* Puis on effectue des calculs */
printf("\nCalculs :\n\n");
printf("\t%d + %d = %d\n", nombre_1, nombre_2, nombre_1 +
nombre_2);
printf("\t%d - %d = %d\n", nombre_1, nombre_2, nombre_1 -
nombre_2);
printf("\t%d * %d = %d\n", nombre_1, nombre_2, nombre_1 *
nombre_2);
printf("\t%d / %d = %.3f\n", nombre_1, nombre_2, (double)
nombre_1 / nombre_2);
printf("\nAu revoir !");
return 0;
}
08/05/2021

26
Chapitre 3 : Structure de contrôle
Les programmes doivent être capables de prendre des décisions. Pour y parvenir, les
développeurs utilisent ce qu'on appelle des structures de contrôle :
 les conditions : elles permettent d'écrire dans le programme des règles comme
« Si ceci arrive, alors fais cela » ;
 les boucles : elles permettent de répéter plusieurs fois une série d'instructions.
1. Structure conditionnelle (les conditions)
Pour qu'un programme soit capable de prendre des décisions, on utilise dans le code
source des conditions. On parle de structures conditionnelles ou le programme réagi
différemment en fonction des circonstances.
Nous allons voir comment rédiger des conditions à l’aide de deux catégories
d’opérateurs :
— les opérateurs de comparaison, qui comparent deux nombres : ==, <=, >=, <,>, != ;
— les opérateurs logiques, qui permettent de combiner plusieurs conditions : true (vrai
ou 1) et false (faux ou 0).
a. L’opérateur «ET s’écrit &&» va manipuler deux conditions. Il va donner un si

elles sont vraies, et zéro sinon.
08/05/2021
Ex. pour combiner les comparaisons a >= 0 et a <= 1000, nous devons placer
l’opérateur && entre les deux, ce qui donne l’expression a >= 0 && a <= 1000.

27
b. L’opérateur « OU s’écrit || » vérifie que l’une des deux conditions (ou que les
deux) est (sont) vraie(s).
L’exemple suivant permet de déterminer si un nombre est divisible par trois ou par cinq
(ou les deux) : (a % 3 == 0) || (a % 5 == 0).
c. L’opérateur de négation manipule une seule condition et en inverse le sens.
Par exemple, si nous voulons vérifier cette fois qu’un nombre n’est pas situé entre zéro
et mille, nous pouvons utiliser la condition a >= 0 && a <= 1000 et lui appliquer
l’opérateur de négation, ce qui donne ! (a >= 0 && a <= 1000).
1.1. Les instructions if else if
L’instruction if permet de conditionner l’exécution d’une suite d’instructions. Une clause

else peut compléter une instruction if afin d’exécuter une autre suite d’instructions dans
le cas où la condition est fausse.
Par ex., nous avons 2 enfants :

08/05/2021
1. L'ordinateur teste d'abord si on en a 0.

28
2. Comme ce n'est pas le cas, il passe au premier else if : est-ce qu'on a 1 enfant ?
Non plus !
3. L'ordinateur teste donc le second else if : est-ce qu'on a 2 enfants ? Oui ! Donc on
affiche le message « Quels beaux enfants vous avez la ! ».
Schéma illustration de test condition
Syntaxe :
if (/* Condition(s) */)
{
/* Instruction(s) */
}
else
{
{
08/05/2021
}
else
{

29
{
}
else
{
}
}
}
1.2. Priorité des opérations
Les règles de priorités sont les suivantes, de la plus forte à la plus faible :
 l’opérateur de négation (!);

 les opérateurs de comparaison (<, <=, >, >=);
 les opérateurs d’égalité et d’inégalité (==, !=);
 l’opérateur ET : &&;
 l’opérateur OU : ||.
Ainsi, les expressions suivantes seront évaluées comme suit :
Si vous souhaitez un résultat différent, il est nécessaire d’ajouter des parenthèses pour
modifier les règles de priorité.
2. Structure répétitif (les Boucles)

Une boucle permet de répéter l’exécution d’une suite d’instructions tant qu’une
condition est vraie.
08/05/2021
Voici ce qu'il se passe dans l'ordre :

o l'ordinateur lit les instructions de haut vers le bas ;

30
o puis, une fois arrivé à la fin de la boucle, il repart à la première instruction

;
o il recommence alors à lire les instructions de haut vers le bas…
o …et il repart au début de la boucle.
Nous allons voir trois types de boucles courantes en C : while, do… while et for.
2.1. boucle while

La boucle while (qui signifie "tant que") évalue une condition avant d’exécuter une
suite d’instructions ;
Syntaxe :
while (/* expression booleenne */ )
{
/* bloc d'instruction à répéter */
}
Ex.
08/05/2021
int i = 0;
while (i < 5)
{

31
printf("La variable i vaut %d\n", i);

i++;
}
Résultat
La variable i vaut 0
Le fonctionnement est simple à comprendre :

 Au tout départ, notre variable i vaut 0. Étant donné que 0 est bien inférieur à 5,
la condition est vraie, donc on rentre dans la boucle.
 On affiche la valeur de i.
 On incrémente i, qui vaut maintenant 1.
 On recommence la boucle.
Ces étapes vont ainsi se répéter pour 1, 2, 3 et 4. Quand la variable i vaudra 5, la
condition sera fausse, et le while ne sera alors pas exécuté.
2.2. boucle « do while »

La boucle « do while » évalue une condition après avoir exécuté une suite
d’instructions. La différence entre while et do while, c'est qu’une boucle do while
s'exécutera toujours au moins une fois, alors qu'une boucle while peut ne pas
s'exécuter.
08/05/2021

32
En termes d'écriture, la première différence avec while est qu'ici le test de la condition
se fait à la fin de la boucle et non au début.
Ex.
int i = 0;
do
{
i++;
} while (i < 5);
Résultat
2.3. boucle for

La boucle for est une forme condensée de la boucle while et se décompose en trois
parties :
 l'initialisation du compteur : on prépare le compteur en l'initialisant à la valeur
que l'on veut (le plus souvent c'est 0). L'initialisation se fait une seule fois, avant
de rentrer dans la boucle, et non à chaque tour de boucle. Par contre, la
modification du compteur et le test de la condition ont lieu à chaque tour de
boucle.
 la condition : comme pour les deux autres boucles, il faut une condition. Tant
qu'elle est vraie, la boucle s'exécute ; elle se stoppe dès qu'elle devient fausse
;
 la modification du compteur : cette étape modifie le compteur. Même s'il s'agit
le plus souvent d'une incrémentation, on peut utiliser toutes les opérations que
l'on veut.
Syntaxe :
08/05/2021
for (initialisation du compteur ; condition ; modification du compteur)

{
Instructions;
}
33
Ex.
int variable;
for (variable = 0 ; variable < 10 ; variable++)
{
printf("variable vaut %d\n", variable);
}
Résultat
variable vaut 0
variable vaut 1
variable vaut 2
variable vaut 3
variable vaut 4
variable vaut 5
variable vaut 6
variable vaut 7
variable vaut 8
variable vaut 9
Une boucle dont la condition est toujours vraie est appelée une boucle infinie
2.4. Boucles infinies

Le point vital dans les boucles, c'est qu'elles puissent se terminer : si elles n'ont pas
de quoi s'arrêter, elles s'exécuteront à l'infini !
Ex.
unsigned int i = 0;
/* Ce qui equivaut a while(1) - Toujours vrai - */
while(i >= 0)
{
}
Résultat
...
Le code continuera jusqu'à ce que l'utilisateur arrête le programme.
08/05/2021

34
Chapitre 4 : Les fonctions
1. Pourquoi utiliser une fonction
Le résultat d’un programme créé sera une grosse suite d'instructions placées les unes
à la suite des autres. Et parmi cette grosse suite d'instructions, il y a des paquets
d'instructions, qui reviennent régulièrement et qui sont présents en plusieurs
exemplaires dans le programme final.
Sans utiliser de fonctions, ces suites d'instructions sont présentes en plusieurs

exemplaires dans le programme et prennent de la place inutilement ; au besoin il faut
recopier à chaque fois. La technique du sous-programme consiste à n'écrire qu'un seul
exemplaire de ces suites d'instructions, et lui donner un nom, c’est ce qu’on appelle
fonction. Les fonctions sont réutilisables, maintenable et permettent de mieux
s’organiser.
2. Définitions et rôles d’une fonction
Une fonction est :
 une suite d’instructions ;

 marquée à l’aide d’un nom ;
 qui a vocation à être exécutée à plusieurs reprises (par des appels);
 qui rassemble des instructions qui permettent d’effectuer une tâche
précise (comme afficher du texte à l’écran, calculer la racine carrée d’un
nombre, etc).
Une fonction exécute des actions et renvoie un résultat. On dit qu'une fonction possède
une entrée et une sortie.
08/05/2021
Lorsqu'on appelle une fonction, il y a trois étapes :

35
 L’entrée : on fait « rentrer » des informations dans la fonction.

 Les calculs : grâce aux informations qu'elle a reçues en entrée, la
fonction travaille (traite).
 La sortie : une fois qu'elle a fini ses calculs, la fonction renvoie un résultat.
Le but des fonctions est donc de simplifier le code source, pour ne pas avoir à retaper
le même code plusieurs fois d'affilée.
Exemple une fonction appelée triple qui calcule le triple du nombre qu'on lui donne, en
le multipliant par 3.
3. Définir et utiliser une fonction
Une fonction est définie avec les informations :
 son nom : les règles sont les mêmes que pour les variables ;
 son corps (son contenu) : le bloc d’instructions à exécuter ;
 son type de retour : le type du résultat de la fonction ;
 d’éventuels paramètres : des valeurs reçues par la fonction lors de
l’appel.
La syntaxe est la suivante :

type nomfonction(paramètres)
{
/* Corps de la fonction ou encore
Suite d’instructions*/
}
Ou type correspond à la sortie ou le résultat que la fonction renvoie (char, int, double,
long etc, void (qui signifie « vide »)) et paramètres correspondent à l'entrée ou des
valeurs avec lesquelles la fonction va travailler.
08/05/2021

36
Noter : Un paramètre est une variable propre à une fonction, il n’est pas utilisable en
dehors de celle-ci. Un argument est une expression passée lors d’un l’appel de
fonction et dont la valeur est affectée au paramètre correspondant.
Ex : fonction avec un paramètre à l’entrée
int triple(int nombre)

{
int resultat = 0;
resultat = 3 * nombre; // On multiplie le nombre fourni par 3
return resultat; // On retourne la variable resultat qui vaut le triple de nombre
}
Ex : fonction avec plusieurs paramètres à l’entrée
int addition(int a, int b)

{
return a + b;
}
Ex : fonction sans paramètres
void bonjour()
{
printf("Bonjour");
}
Ex. d’une fonction qui affiche « bonjour !» à l’écran.
#include <stdio.h>
void bonjour(void)
{
printf("Bonjour !\n");
}
int main(void)
{
bonjour();
return 0;}
Exemple d’Appeler une fonction

08/05/2021

37
Voici ce qui se passe, ligne par ligne :
 Le programme commence par la fonction main.

 Il lit les instructions dans la fonction une par une dans l'ordre.
 Il lit l'instruction suivante et fait ce qui est demandé (printf).
 De même, il lit l'instruction et fait ce qui est demandé (scanf).
 Il lit l'instruction…Ah ! On appelle la fonction triple, on doit donc sauter à
la ligne de la fonction triple plus haut.
 On saute à la fonction triple et on récupère un paramètre (nombre).
 On fait des calculs sur le nombre et on termine la fonction. return signifie
la fin de la fonction et permet d'indiquer le résultat à renvoyer.
 On retourne dans le main à l'instruction suivante.
 Un return ! La fonction main se termine et donc le programme est
terminé.
4. Les prototypes
Jusqu’à présent, nous avons toujours défini notre fonction avant la fonction main(). En
effet, mettre la fonction après le « main » provoquera un comportement indéterminé.
La compilation pourrait très bien marcher comme elle pourrait planter.
08/05/2021
En effet, lorsque la fonction est placée avant, le compilateur connait ses paramètres
et sa valeur de retour. Du coup, quand on appelle la fonction, le compilateur vérifie que

38
les arguments qu'on lui donne sont bons. Si au contraire la fonction est après, le
compilateur ne connait pas la fonction ; il lui fixe arbitrairement des caractéristiques.
Et quand on tente d'appeler la fonction, la compilation plante, car les arguments ne
correspondent pas aux yeux du compilateur.
Pour résoudre ce problème, il est possible de déclarer une fonction à l’aide d’un
prototype. Celui-ci permet de spécifier le type de retour de la fonction, son nombre
d’arguments et leur type, mais ne comporte pas le corps de cette fonction.
Un prototype permet de déclarer une fonction sans spécifier son corps, il n’est ainsi
plus nécessaire de se soucier de l’ordre de définition des fonctions.
La syntaxe d’un prototype est la suivante : type nom(paramètres); ou type

nom_de_la_fonction(arguments);
Ex.
#include <stdio.h>
int carre(int nombre);
int main(void)
{
int nombre, nombre_au_carre;
printf("Entrez un nombre\n");
scanf("%d", &nombre);
nombre_au_carre = carre(nombre);
printf("Voici le carre de %d : %d\n", nombre,
nombre_au_carre);
return 0;
}
int carre(int nombre)
{
nombre *= nombre;
return nombre;
}
5. Les variables globales
Il arrive parfois que l’utilisation de paramètres ne soit pas adaptée et que des fonctions
08/05/2021
soient amenées à travailler sur des données qui doivent leur être communes.

39
Il est possible de définir une variable dite «globale» qui sera utilisable par toutes les
fonctions. Pour définir une variable globale, il vous suffit de définir une variable en
dehors de tout bloc, autrement dit en dehors de toute fonction.
Ex.
#include <stdio.h>
void fonction(void);
int appels = 0;
void fonction(void)
{
++appels;
}
int main(void)
{
fonction();
fonction();
printf("Ce programme a réalisé %d appel(s) de fonction\n",
appels);
return 0;
}
08/05/2021

40
Chapitre 5 : Découper son projet
Nous allons voir comment découper nos projets en plusieurs fichiers. En effet, même
si l'on découpe bien son projet en fonctions, ce dernier est difficile à relire si tout est
contenu dans le même fichier. Ce chapitre a donc pour but de vous apprendre à
découper vos projets efficacement.
1. Portée d’une variable
La portée d’une variable est la partie du programme où cette dernière est utilisable. Il
existe deux types de portées :
 au niveau d’un bloc ;

 au niveau d’un fichier.
a. Au niveau d’un bloc
Une variable, avec une portée au niveau d’un bloc est utilisable, visible de sa
déclaration jusqu’à la fin du bloc dans lequel elle est déclarée.
Ex.
#include <stdio.h>
int main(void)
{
{
int nombre = 3;
printf("%d\n", nombre);
}
/* Incorrect ! */
return 0;
}
Dans ce code, la variable nombre est déclaré dans un sous-bloc. Sa portée est donc
limitée à ce dernier et elle ne peut pas être utilisée en dehors.
08/05/2021
b. Portée au niveau d’un fichier

41
Une variable avec une portée au niveau d’un fichier est utilisable, visible de sa
déclaration jusqu’à la fin du fichier dans lequel elle est déclarée.
Ex.
#include <stdio.h>
int nombre = 3;
int triple(void)
{
return nombre * 3;
}
int main(void)
{
nombre = triple();
return 0;
}
Dans ce code, la variable nombre a une portée au niveau du fichier et peut par
conséquent être aussi bien utilisée dans la fonction triple() que dans la fonction main().
2. Notions de masques
Si elles ont la même portée comme dans l’exemple ci-dessous, alors le compilateur
sera incapable de déterminer à quelle variable ou à quelle fonction le nom fait
référence et, dès lors, il retournera une erreur.
Ex.
int main(void)
{
int nombre = 10;
int nombre = 20;
return 0;
}
En revanche, si elles ont des portées différentes, alors celle ayant la portée la plus
petite sera privilégiée, on dit qu’elle masque celle(s) de portée(s) plus grande(s).
Autrement dit, dans l’exemple qui suit, c’est la variable du bloc de la fonction main()
08/05/2021
qui sera affichée.
Ex.

42
#include <stdio.h>
int nombre = 10;
int main(void)
{
int nombre = 20;
return 0;
}
Notez que: «celle(s) de portée plus petite» car les variables déclarées dans un sous-
bloc ont une portée plus faible que celle déclarée dans un bloc supérieur. Ainsi, le code
ci-dessous est parfaitement valide et affichera 30.
Ex.
#include <stdio.h>
int nombre = 10;
int main(void)
{
int nombre = 20;
if (nombre == 20)
{
int nombre = 30;
}
return 0;
}
3. Les fonctions
nous avions créé une fonction triple() que nous avons placée dans le même fichier que
la fonction main(). Essayons à présent de les répartir dans deux fichiers distincts
comme suit :
autre.c
{
return nombre * 3;
}
08/05/2021
main.c
int main(void)
{

43
int nombre = triple(3);

return 0;
}
Si vous testez ce code, vous aurez droit à un bel avertissement de votre compilateur
du type «implicit declaration of function ’triple’». Quel est le problème ? Le problème
est que la fonction triple() n’est pas déclarée dans le fichier main.c et que le
compilateur ne la connaît donc pas lorsqu’il compile le fichier. Pour corriger cette
situation, nous devons déclarer la fonction en signalant au compilateur que cette
dernière se situe dans un autre fichier. Pour ce faire, nous allons inclure le prototype
de la fonction triple() dans le fichier main.c en le précédant du mot-clé extern, qui
signifie que la fonction est externe au fichier.
autre.c
{
return nombre * 3;
}
main.c
extern int triple(int nombre);
int main(void)
{
int nombre = triple(3);
return 0;
}
En terme technique, on dit que la fonction triple() est définie dans le fichier «autre.c»
(car c’est là que se situe le corps de la fonction) et qu’elle est déclarée dans le fichier
«main.c». Sachez qu’une fonction ne peut être définie qu’une seule et unique fois.
Pour information, notez que le mot-clé extern est facultatif devant un prototype (il est
implicitement inséré par le compilateur). Nous vous conseillons cependant de l’utiliser
par soucis de clarté et de symétrie avec les déclarations de variables (voyez ci-
dessous).
08/05/2021

44

Cours de Programmation Procédurale DAWM-ASRS

Transféré par

Droits d'auteur :

Formats disponibles

Cours de Programmation Procédurale DAWM-ASRS

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours de Programmation Procédurale DAWM-ASRS

Transféré par

Droits d'auteur :

Formats disponibles

L1 : DAWM-ASRS Année Académique 2020-2021

Chapitre 1 : les bases de la programmation en langage C

Prérequis : il faut plusieurs qualités pour arriver à tenir jusqu’au bout de la

C est un langage de programmation impératif généraliste, de bas niveau. Inventé au

Un programme est une séquence d’instructions, d’ordres, donnés à l’ordinateur afin

Pour programmer, il faut un langage de programmation qui joue le rôle d’intermédiaire

Cours de programmation procédurale Chargé du cours : M. Eléazar

 Sa popularité : il fait partie des langages de programmation les plus utilisés.

b. Différence entre C, C++ et C#

Cours de programmation procédurale Chargé du cours : M. Eléazar

C est un langage de programmation procédurale et ne prend pas en charge les classe

Processus de compilation d’un programme en C++

Le code en langage intermédiaire (CIL) correspond au programme que vous allez

3. Classement de quelques langages

Le schéma ci-dessous représente quelques langages de programmation classés par

Cours de programmation procédurale Chargé du cours : M. Eléazar

4. Les logiciels nécessaires pour programmer

Les outils nécessaires pour programmer en C sont entre autres :

 Un éditeur de texte : ce logiciel va servir à écrire le code source ;

Remarques : on peut prendre séparément ces logiciels et compiler par soi-même, ou

Ex. IDE : code ::blocks ; visual C++, Visual C++ Express

Avant de commencer à programmer, il faut définir ce que vous allez programmer,

Cours de programmation procédurale Chargé du cours : M. Eléazar

a. Code minimal d’un IDE

Code :: Blocks a donc généré le minimum de code en langage C que voici :

b. Explication du code source

À l’intérieur des parenthèses, il y a le mot « void ». Ce mot-clé signifie « Je ne veux

int main() { printf("Hello world!\n"); return 0; } : Une fonction « main ou principal »

est la fonction principale du programme qui permet en grosso modo de rassembler

Cours de programmation procédurale Chargé du cours : M. Eléazar

6. Écrire un message à l'écran avec commentaires

Cours de programmation procédurale Chargé du cours : M. Eléazar

a. Codage des informations

Le problème ici consiste à transformer une information en nombre (0 et 1) pour que

Cours de programmation procédurale Chargé du cours : M. Eléazar

La base correspond au nombre de chiffres disponibles pour représenter un nombre.

Les bits sont stockés dans un composant électronique particulier de l’ordinateur : la

Cours de programmation procédurale Chargé du cours : M. Eléazar

 les registres : une mémoire ultra-rapide intégrée directement dans le

b1. Bit et adresse mémoire

Chaque multiplet de la mémoire vive se voit attribuer un nombre unique appelé

Cours de programmation procédurale Chargé du cours : M. Eléazar

B2. Les représentations octales et hexadécimales

Cours de programmation procédurale Chargé du cours : M. Eléazar

L’avantage des représentations octale et hexadécimale est qu’il est facilement

Cours de programmation procédurale Chargé du cours : M. Eléazar

B3. Les variables

8. Déclarer une variable

une variable est constituée de deux éléments obligatoires: un type et un identificateur

Syntaxe : type identificateur ;

un type permet d’indiquer au compilateur quel genre de données nous souhaitons

— toutes les valeurs que peut prendre la variable ;

— les opérations qu’il est possible d’effectuer.

Le langage C fournit neuf types de base :

Cours de programmation procédurale Chargé du cours : M. Eléazar

b. Capacité d’un type

Cours de programmation procédurale Chargé du cours : M. Eléazar

il y a quelques limitations du choix d’un identificateur :

— seuls les 26 lettres de l’alphabet latin (majuscules ou minuscules), le trait de

— un identificateur ne peut pas commencer par un chiffre ;