Année Universitaire 2020-2021

Université d’Abomey-Calavi (UAC)

Faculté des Sciences et Techniques (FAST)
Département de Mathématiques
2ème année de Maths & Informatique (MI 2)

Langage C : Algorithmique & Langage C (ALC2203)

Leçon 2 : Langage C
Enseignant : Dr Abdou Wahidi BELLO

DESCRIPTIF DE LA LEÇON
— initiation à l’algorithmique ;
— conception d’un pseudo-code

Table des matières

1 ELEMENTS NOTIONNELS 1
1.1 Environnement de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Code source, compilation, code objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2.1 Activité 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2.2 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2.3 Le préprocesseur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3 Structure générale d’un programme C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.4 Fondements du langage C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.4.1 Les identificateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.4.2 Les mots réservés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.4.3 Les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4.4 Types de base du langage C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4.5 Déclaration d’une variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4.6 Affectation de valeur à une variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.5 Portée (visibilité) des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.5.1 Définition des constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.5.2 Fonctions de base pour les entrées/sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.5.3 Opérations arithmétiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.6 Bibliothèque mathématique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2 Les Travaux Pratiques 5

2.1 TP1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 TP2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.3 TP3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.4 TP4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

1 ELEMENTS NOTIONNELS
1.1 Environnement de travail
(a) Ordinateur (PC portatif par étudiant obligatoire)
(b) Logiciels :
— Système d’Exploitation : Unix de préférence (Ubuntu, Mint, etc.)
— Editeur de texte : gedit, Visual Studio Code
— Compilateur : gcc (GNU Compiler Collection)

1
1.2 Code source, compilation, code objet
1.2.1 Activité 1

1. Dans un fichier nommé tp0.c, éditer le code suivant :

#include <stdio.h>
int main(){
printf("Bravo ! J’écris mon premier programme en langage C.\n") ;
}
2. Dans votre terminal :
(a) accéder au dossier contenant le fichier (utilisation de la commande cd)
(b) taper la commande : gcc tp0.c
(c) valider (si gcc n’est pas installé, connectez-vous à l’internet et exécuter dans le terminal la commande : sudo
apt-get install gcc).
(d) exécuter la commande ./a.out
3. Visualisation de fichier dans le terminal (utilisation de la commande head pour visualiser les premières lignes) :
Dans votre terminal :
(a) exécuter la commande : ls
afin de visualiser le contenu du dossier courant (dossier contenant le fichier tp0.c)
(b) exécuter la commande : head tp0.c
(c) exécuter la commande : head a.out

1.2.2 Définitions
(a) Code source : texte qui détaille les instructions d’un programme informatique dans un langage de programmation compréhensible
et utilisable par l’homme.
Exemple : contenu du fichier tp0.c
(b) Compilateur : programme qui traite les instructions écrites dans un code source pour les traduire en langage machine (utilisé par
le processeur d’un ordinateur).
Exemple : gcc (GNU Compiler Collection)
(c) Code objet : code (compréhensible par l’ordinateur dans un format binaire exécutable) obtenu après compilation d’un code
source.
Exemple : a.out

1.2.3 Le préprocesseur
Le préprocesseur est un programme qui réalise des traitements préliminaires sur le code source avant que ce dernier ne soit réellement
compilé. Il effectue des modifications textuelles sur le fichier source à partir de directives. Les différentes directives au préprocesseur,
introduites par le caractère #, ont pour but :
(a) l’incorporation de fichiers source (#include),
(b) la définition de constantes symboliques et de macros (#define),
(c) la compilation conditionnelle (#if, #ifdef,...).

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

[ directives au préprocesseur ]
[ déclarations de variables externes ]
[ fonctions secondaires ]
main(){
déclarations de variables internes
instructions
}

2
1.4 Fondements du langage C
1.4.1 Les identificateurs

(1) servent à donner un nom à une entité du programme (variables, fonctions, ...).
(2) sont formés d’une suite de lettres de l’alphabet anglais (pas d’accents), chiffres et du caractère souligné (_), le
premier caractère étant impérativement une lettre ou un caractère souligné.

NOTE :
— Le langage C distingue les minuscules des majuscules (on dit qu’il respecte la casse) : mi2, MI2 et Mi2 sont troix noms différents.
— On conseille de choisir des identificateurs évocateurs !

1.4.2 Les mots réservés

(1) encore appelés mots clés.

(2) ne peuvent pas être utilisés comme identificateurs.

les spécificateurs de type

char double enum float int long short signed struct union unsigned void

Les spécificateurs de stockage

auto register static extern typedef

les qualificateurs de type

const volatile

les instructions de contrôle

break case continue default do else for goto if switch while

divers
return sizeof

1.4.3 Les variables

(1) informations temporaires qu’on stocke dans la RAM. On dit qu’elles sont "variables" car ce sont des valeurs qui
peuvent changer pendant le déroulement du programme.
(2) une variable possède deux composantes :
(a) une valeur : c’est le nombre qu’elle stocke, par exemple 3,14 ;
(b) un identifiant : c’est le nom qui permet de la reconnaître, par exemple PI.

NOTE : Déclaration d’une variable

Afin d’aider l’ordinateur à s’organiser et surtout à ne pas prendre trop de place mémoire pour rien, lorsqu’on désire stocker une
variable, on doit indiquer son type (caractère, entier, décimal, ....) : c’est cela la déclaration d’une variable.

1.4.4 Types de base du langage C

Quatre types de base :
Type C Type correspondant
char caractère (entier de petite taille)
int entier
float nombre flottant (réel) en simple précision
double nombre flottant (réel) en double précision

3
1.4.5 Déclaration d’une variable
type identificateur [,identificateur,...] ;
Exemple :
int effectif ;
double x, y, z ;
char reponse2, reponse2 ;

1.4.6 Affectation de valeur à une variable

nom de la variable = valeur ;
Exemple :
effectif=4 ;
x = y = 2.7 ;
z=1.2345e16 ;
car1=’a’ ; /* car1 reçoit ici le code Ascii de ’a’, soit 97 */
car2=83 ; /* on affecte ici le code Ascii du carèctère S */

En C, il est possible de procéder à la déclaration et à l’initialisation en une seule instruction, par exemple :
int effectif=4 ;
double x=2.7, y=2.7, z=1.2345e16 ;
char car1=’a’, car2=83 ;

1.5 Portée (visibilité) des variables

(a) Variable Globale : déclarée à l’extérieur de toute fonction ou de tout bloc d’instructions ; elle est accessible de partout dans le
code (n’importe quelle fonction du programme peut faire appel à cette variable).
(b) Variable Locale : déclarée à l’intérieur d’un bloc d’instructions (dans une fonction ou une boucle par exemple) ; portée limitée à
ce seul bloc d’instruction.

1.5.1 Définition des constantes

Les constantes sont définies grâce à la directive ]define
Exemple :
]define Pi 3.1415927
Toutefois, avec cette méthode les constantes ne sont pas typées, c’est pourquoi le C++ rajoute le mot réservé const, qui permet de
définir une constante typée :
const type identificateur=valeur ;
Exemple :
const int X = 76 ;
const float Pi = 3.14159 ;

1.5.2 Fonctions de base pour les entrées/sorties

(a) Les sorties : utilisation de la fonction printf pour afficher à l’écran le contenu des variables
printf("texte [chaines de format]" [, arg1, arg2 , . . . ]) ;

chaîne de format

Elle permet de spécifier la manière d’afficher et les arguments suivants sont les variables que l’on veut afficher.
Exemple
int i=20 ;
double resultat=0.1 7 6 4 7 1 ;

Dans un programme, on aura par exemple :

printf ("la valeur de i est : %d\n", i) ;

4
 printf ("resultat vaut %f ou encore (%1.2f)\n", resultat, resultat) ;
printf("i=%04d et resultat=%1.3f\n", i, resultat) ;
Un tel programme donnera à l’écran :
la valeur de i est : 20
resultat vaut 0.176471 ou encore
(0.18)
i=0020 et resultat=0.176

NOTE
* %d permet d’afficher un entier ;
• %04d permet d’afficher un entier sur 4 caractères en comblant avec des 0 sur la gauche si nécessaire ;
• %4d permet d’afficher un entier sur 4 caractères comblant avec des ”blancs” sur la gauche si nécessaire ;
* %f permet d’afficher un nombre à virgule flottante ;
• %.3f permet d’afficher un nombre à virgule flottante avec 3 chiffres après la virgule ;
* %c permet d’afficher un caractère ;
* %s permet d’afficher une chaîne de caractères ;
La bibliothèque d’entrée/sortie du C dispose de bien d’autres fonctionnalités ...

(b) Les Sorties : utilisation de la fonction scanf pour la lecture des données entrées.
scanf("chaines de format", &arg1, &arg2 , . . . ) ;

1.5.3 Opérations arithmétiques

utilisation naturelle des opérateurs +, −, ∗ et / pour l’addition, la soustraction, la multiplication et la division.

L’opérateur % : renvoie du modulo (reste de la division entière)
Exemple : 5%3 renvoie 2.

Conversion des types

Lors de l’évaluation d’une opération arithmétique, l’opération sera effectuée dans le plus grand des deux types mis en jeu. Ainsi,
dans l’exemple :
int i=2 ;
float f=4.3 ;
f=f*i ;
la multiplication f*i est effectuée en float. Notons que l’opérateur de division peut agir comme division entière ou division sur les
nombres à virgule flottante.
float f=2/3 ; affecte la valeur 0 à f puisque 2 et 3 sont des constantes de types entiers, la division est une division entière !
On écrira donc :
float f=2.0/3 ; ou float f=2/3.0 ; ou float f=2.0/3.0 ; pour affecter 2/3 = 0.6666... à f.

1.6 Bibliothèque mathématique

La bibliothèque mathématique propose un grand nombre de fonctions mathématiques (logarithmes, fonctions puissance et racines,
trigonométrie, arrondis, . . . ).
Pour les utiliser dans un programme, on écrira dans l’entête : ] include <math.h> et on spécifie l’usage de la bibliothèque
mathématique par −lm lors de la compilation.
Les fonctions disponibles sont, de manière non exhaustive :
• double exp(double x) ; renvoie l’exponentielle de x ;
• double log(double x) ; renvoie le logarithme népérien de x ;
• double pow(double x, double y) ; renvoie x à la puissance y ;
• double sqrt(double x) ; double cbrt(double x) ; renvoient la racine carrée et cubique de x, respectivement ;
• double sin(double x) ; double cos(double x) ; double tan(double x) ; renvoient respectivement le sinus,
le cosinus et la tangente de x (x étant exprimé en radians) ;

5
 • int abs(int x) ; double fabs(double x) ; renvoie la valeur absolue de x ;
• double ceil(double x) ; double floor(double x) ; double rint(double x) ; effectuent toutes trois des ar-
rondis, ceil par excès, floor par défaut et rint vers l’entier le plus proche.

2 Les Travaux Pratiques

2.1 TP1
Modifier l’Activité 1 en :
\* #include <stdio.h> *\
int main(){
printf("Bravo ! J’écris mon premier programme en langage C.\n") ;
}
1. Compiler
2. Quel est selon vous le rôle joué par la partie du code : #include <stdio.h> ?

2.2 TP2
Ecrire en langage C, un programme qui affiche à l’écran le rectange :

******
* *
* *
* *
******

2.3 TP3
1o)
Ecrire un programme qui demande 2 entiers x, y à l’utilisateur et qui affiche en retour un rectangle de x lignes et y colonnes. Par
exemple, si l’utilisateur choisit x = 5, y = 3 le programme devra afficher :
xxx
xxx
xxx
xxx
xxx
2o) Modifier le programme précédent. Cette fois, un seul nombre x est demandé et le programme affiche un triangle de x lignes
comme suit (avec x=5, dans l’exemple) :
x
xx
xxx
xxxx
xxxxx

2.4 TP4
Ecrire un programme somme demandant á l’utilisateur de taper 10 entiers et qui affiche leur somme. Le programme ne devra utiliser
que 3 variables et ne devra pas utiliser de tableau.