14/10/2018

CER PROSIT 1.6 Compilation BODIOU

Naoki
Comment traduire l’algorigramme en langage C pour faire la mini-calculatrice ?
CER PROSIT 1.6 Compilation

Contexte du PROSIT :

Suite du prosit précédent + introduction au C

Problématique :

Comment traduire l’algorigramme en langage C pour faire la mini-calculatrice ?

Contraintes :

- Langage C ;
- Ajouter du Include ;
- Savoir Compiler ;
- Codes dans un seul fichier ;
- Respecter la syntaxe et leur convention.

Plan d’action :

- Se renseigner sur le langage C ;

- Étudier la bibliothèque standard ;
- Définir printf et scanf ;
- Reprendre l’instruction du code en C ;
- Traduire l’algorigramme en C pour réaliser la mini-calculatrice en C.

Sommaire de la réalisation du plan d’action :

1. Automate / langage
A. Définition d’un automate
B. Définition d’un langage et lien avec automate
2. Le langage C
A. Structure d’un programme en c
B. Syntaxe
C. Bibliothèque standard STDIO
D. Contenu du corps d’un programme en c
E. Structures de contrôles en c
F. Les étapes de la compilation
3. Analyse du code
4. La mini-calculatrice

Réalisation du plan d’action :

1. Automate / langage
A. Définition d’un automate

Un automate est un appareil qui est programmé au préalable pour exécuter un ensemble de tâche.
En informatique, on peut distinguer quelques principes chez un automate.
- En effet, un automate en informatique est programmé avec une séquence (une suite
d’action).

- Selon l’endroit dans la séquence où est l’automate, son état change.

CER PROSIT 1.6 Compilation

- Selon la séquence et l’état actuel de l’automate, l’automate décide de la suite des

événements, de la prochaine action à effectuer. C’est la transition.

Pour donner un exemple, un ascenseur est un automate. Une séquence programmée au préalable
permet à l’ascenseur d’accéder à différents étages selon ce que le passager souhaite. Si l’ascenseur
est à l’état 0 (RdC) et qu’un individu rentre dans l’ascenseur pour aller à l’étage 1. L’automate, en
l’occurrence ici l’ascenseur ira à l’étage 1. Le passage de l’étage 1 à 0 est la transition. Arrivé à l’étage
1, l’ascenseur aura changé d’état, de 0 à 1.

B. Définition d’un langage et lien avec automate

Un langage est un outil de communication. Il en existe de nombreuse forme dont les langues
courantes comme celle qui a été utilisé pour rédiger ce CER : le Français. Ici, le type de langage nous
intéressant est le langage de programmation.

Comme tout langage, dans les langages de programmation, il existe certaines règles à respecter pour
ce faire comprendre.

Le langage de programmation est un langage permettant un dialogue entre les Hommes et les
machines. Pour être plus précis, le langage de la machine est le binaire. Cependant, ce langage étant
difficile à appréhender pour les Hommes, les Hommes ont créé les langages de programmations. Ce
sont des langages plus facilement appréhendables par l’Homme et qui peuvent être ensuite
traduit/compilé en binaire pour pouvoir être lu par les machines. Une machine est donc tout d’abord
programmé à l’aide d’un langage de programmation par l’Homme pour ensuite devenir un automate.

2. Le langage C
A. Structure d’un programme en c

#include <NOM DE LA BIBLIOTHÈQUE.h> // déclaration des bibliothèques utilisé

Int main ()
{
// déclaration des variables

// corps du programme

return 0; // aucune erreur renvoyé

}
Voici la structure de base d’un programme en c. Tout sera détaillé dans la suite du CER

B. Syntaxe

Je vais aborder ici la syntaxe de base du c. Un programme en c démarre toujours par une déclaration
de bibliothèque. Ensuite, une fonction est déclarée. Il est possible de déclarer plusieurs fonctions. La
syntaxe d’une fonction est la suivante :

(Type de la fonction) (nom de la fonction) (paramètres)

Les types possibles d’une fonction porte les mêmes noms que les types de variables. On pourra par
exemple avoir une fonction de type int, char… Selon le type de la fonction, la fonction renverra un
type de valeur différente. Une fonction de type int renverra par exemple un entier. Il est aussi
possible de créer une fonction qui ne possède pas de type. Elle renvoie donc rien.
CER PROSIT 1.6 Compilation

Dans paramètre, on peut déclarer des valeurs avec lesquelles la fonction travaillera. Par exemple si je
déclare un int A en paramètre, je vais pouvoir utiliser A dans la fonction. Après avoir déclaré la
fonction, il faudra mettre { avant le début des instructions propre à la fonction et mettre } à la fin.

Pour ce qui est des instructions, lorsqu’une instruction est terminée il faut mettre un ; . Par exemple,
si je souhaite utiliser l’instruction printf à la fin je mettrais un ; . En dernière instruction du main, il est
bon de mettre un return (0) ; .

C. Bibliothèque standard STDIO

En c, une bibliothèque est un ensemble de fonction. Pour utiliser une fonction spécifique, il faudra
s’informer dans quelle bibliothèque se trouve la fonction car le compilateur doit être au courant de
l’utilisation d’une bibliothèque pour pouvoir compiler. Pour mettre au courant le compilateur, il
suffira d’ajouter #include <nom de la bibliothèque.h>. Par exemple, si j’ai besoin de fonction contenu
dans la librairie standard STDIO il suffira d’ajouter au début du code #include <stdio.h>. Déclaration
de variables

Tout d’abord, il existe plusieurs types de variables. Les plus basiques sont le type int (entier) et le
type char(caractère). Une variable de type int pourra contenir des chiffres entiers alors qu’une
variable de type char pourra contenir des caractères. La petite nuance étant que chaque caractère
possède un équivalent en nombre et donc si on essaye de stocker un nombre de type int dans une
variable de type char, c’est le caractère équivalent au nombre et non le nombre qui sera stocké. Par
exemple le nombre 65 correspond à la majuscule A. Si on stocke 65 dans un type char, ce sera en fait
le caractère A qui sera stocké dans le type char. Ce tableau de correspondance s’appelle la table
ASCII.
CER PROSIT 1.6 Compilation

La structure de déclaration d’une variable est la suivante :

int A ; // déclaration d’une variable A de type int

char B ; // déclaration d’une variable B de type char

Il existe aussi un type spécial de variables : les pointeurs. Jusqu'à maintenant, une variable ne
possédait qu’une case de mémoire. Sur une variable de type int ou char on peut stocker qu’une seule
donnée car ces variables possèdent une seule adresse. Avec les pointeurs, on peut stocker plusieurs
adresses dans une seule variable. Il faut imaginer une colonne d’un tableau. Chaque case de la
colonne représente un emplacement mémoire. Une variable pointeur pourra se balader dans cette
colonne du tableau pour stocker des valeurs dans chacune de ces cases. Une variable simple comme
le type int ou char est combiné pour créer une variable pointeur de type int ou une variable pointeur
de type char. Voici la structure de déclaration d’une variable pointeur :

int* A // déclaration d’une variable A pointeur de type int

int A[10] // autre manière de déclarer une variable A pointeur de type int
char* B // déclaration d’une variable B pointeur de type char
char B[9] // autre manière de déclarer une variable B pointeur de type int
Il existe deux manières de déclarer une variable pointeur. La première manière, avec * ne permet pas
de définir le nombre d’emplacement mémoire de la variable. La variable ainsi donc crée aura donc un
nombre d’emplacement mémoire infini par défaut. La seconde manière permet de définir ou non le
nombre d’emplacement mémoire. Dans la déclaration de la variable pointeur de type int ci-dessous :

int A[10]
char B[5]
La variable A créé pourra accéder et stocker des valeurs dans 10 adresses mémoires de type int.
Pour accéder à la première, il faudra stocker la valeur dans A[0]. Pour la seconde, dans A[1] et ainsi
de suite jusqu’à A[9]. Attention, le ‘'tableau’' commençant à 0, on pourra ici stocker des valeurs que
jusqu’à A[9] et non A[10].

Dans la variable B créé, comme 5 est indiqué entre les crochets, la variable possédera 5
emplacements mémoire.

Pour aller plus loin, il est possible de créer des variables qui sont de type pointeur sur pointeur et
même de type pointeur sur pointeur sur pointeur sur pointeur... Un type pointeur sur pointeur nous
donnera accès à un tableau en entier. Voici un exemple : supposons la variable A[3][3]. On peut
représenter les emplacements mémoires accessible par la variable par un tableau :

A[0][0] A[0][1] A[0][2]

A[1][0] A[1][1] A[1][2]
A[2][0] A[2[1] A[2][2]
Avec A[3][3], on pourra donc stocker 9 valeurs de type int à des emplacements mémoires différents.

Il faut noter que lorsque l’on stocke un mot dans une chaîne de caractère, à la fin du mot sera stocké
un octet nul (\0).

D. Contenu du corps d’un programme en c

Le corps du programme contient les instructions du programme. Il existe un nombre énorme de

fonctions utilisable en c contenu dans diverses bibliothèques mais ici nous nous intéresserons à deux
fonctions : Printf et Scanf. Ces deux fonctions sont présente dans la bibliothèque STDIO.
CER PROSIT 1.6 Compilation

 Printf est une fonction permettant d’afficher des caractères en sortie standard. Il est possible
d’afficher du texte contenu dans une variable tout comme du texte directement.

Voici différents exemples d’utilisation de printf ci-dessous. Pour les exemples, supposons qu’une
variable ABC contenant ‘A’ a été préalablement crée.

printf("BCD") ; // affiche BCD

printf("%c", ABC) ; // affiche A
printf("%c BCD" , ABC); // affiche A BCD
Le premier exemple affiche directement du texte sans passer par une variable. Il suffit de mettre le
texte entre ‘’.

Le second exemple affiche le contenu de la variable ABC. Pour cela il faut d’abord déclarer le type de
la variable à afficher entre ‘’, puis en dehors des ‘’ nommer la variable que l’on veut afficher. Chaque
type de variable possède une lettre pour déclarer son utilisation. Voici un tableau avec la plupart des
différents types de variable et sa correspondance en lettre :

Le dernier exemple affiche le contenu de la variable ABC, puis du texte sans passer par une variable.
En effet, il est possible de combiner affichage de contenu de variable et affichage direct de texte.

 Scanf est une fonction permettant de demander à l’utilisateur du programme de donner la

valeur d’une variable. En effet, l’utilisateur sera amené à saisir une valeur et cette valeur sera
recopié à l’adresse de la variable spécifié dans l’instruction Scanf. Voici ci-dessous, un
exemple d’utilisation de scanf. Pour l’exemple, supposons qu’une variable ABC qui n’est pas
encore initialisé a été créé.

scanf("%c", &ABC) ; // récupère la valeur entrée par l’utilisateur et la stocke à l’adresse de ABC
Comme vous pouvez le voir, la structure de déclaration de scanf est similaire à l’utilisation de printf.
Cependant, il faut mettre & avant le nom de la variable. Le & avant une variable signifie que l’on
récupère l’adresse de la variable et non le contenu de la variable. Comme ici on a besoin que la
valeur entrée par l’utilisateur soit stockée à l’adresse de la variable, il faut donc rediriger la valeur
entré vers &ABC.

Les structures de contrôles peuvent aussi être utilisé dans le corps d’un programme en c.

E. Structures de contrôles en c
CER PROSIT 1.6 Compilation

Pour comprendre les structures de contrôles, il est important de faire un petit point sur les
opérateurs de comparaison ainsi que les opérateurs ou et et. Voici donc un tableau contenant les
différents opérateurs et sa notation en langage C.

Opérateur de comparaison Notation en C Exemple

Égalité == 10 == 10 renverra TRUE
10 == 42 renverra FALSE
Différence != 10 != 42 renverra TRUE
10 != 10 renverra FALSE
Strictement Supérieur > 10 > 9 renverra TRUE
10 > 42 renverra FALSE
Supérieur ou Égal >= 10 >= 10 renverra TRUE
10 >= 42 renverra FALSE
Strictement Inférieur < 10 < 42 renverra TRUE
10 < 9 renverra FALSE
Inférieur ou égal <= 10 <= 10 renverra TRUE
10 <= 9 renverra FALSE
Négation (permet d’inverser ! !0 renverra TRUE
TRUE et FALSE) !10 renverra FALSE
!(10 != 10) renverra TRUE
!(10 == 10) renverra FALSE
Ou || TRUE || TRUE renverra TRUE
TRUE || FALSE renverra TRUE
FALSE || FALSE renverra FALSE
Et && TRUE && TRUE renverra TRUE
TRUE && FALSE renverra FALSE
FALSE && FALSE renverra FALSE
Il existe une priorité dans l’utilisation des opérateurs. La voici :

Les différents opérateurs classés du plus prioritaire au moins prioritaire

()
! ~ ++ -- + - sizeof

Du moins prioritaire au plus

* / %
+ -
<< >>
< <= > >=
== !=
&
^
prioritaire

|
&&
||
= += -= *= /= %= &= ^= |= <<= >>=

Passons maintenant aux structures. Il existe différents types de structures : les structures
conditionnelles, itératives, conditionnelles particulière, et les instructions d’altération de contrôle de
boucle. Je vais ici m’axer uniquement sur les structures conditionnelles et itératives.

 Les structures conditionnelles : if, if… else…, if… else if… else

Ces structures permettent de choisir quelle partie de code lire selon une ou des conditions données.
CER PROSIT 1.6 Compilation

Voici la structure de déclaration d’une structure conditionnelles if :

if (ABC == 42)
printf(‘’cette partie de code est lu uniquement si ABC == 42’’) ;
Voici la structure de déclaration d’une structure conditionnelles if… else :

if (ABC == 42)
printf(‘’cette partie de code est lu uniquement si ABC == 42’’) ;
else
printf(‘’sinon cette partie de code est lu’’) ;
Voici la structure de déclaration d’une structure conditionnelles if… else if… else

if (ABC == 42)
{
printf(‘’cette partie de code est lu uniquement si ABC == 42’’) ;
printf(‘’comme il y a plus d’une instruction dans cette partie de code, la partie de code est
sous crochet’’)
}
else if (ABC == 66)
{
printf(‘’sinon si ABC == 66, cette partie du code est lu. On peut tout de même mettre sous
crochet quand il y a qu’une seule instruction’’) ;
}
else
printf(‘’sinon, cette partie du code est lu’’) ;
Il existe aussi une structure conditionnelle un peu différente : l’opérateur ternaire vrai ou faux. Cet
opérateur permet d’obtenir une valeur différente selon si la condition est vraie ou fausse. Voici la
structure de déclaration d’un opérateur de condition ternaire vrai ou faux :

(ABC == 42 ? 1 : 2) ;
// Si ABC == 42, on obtient la valeur 1 sinon on obtient la valeur 2

 Les structures itératives : while, do…while, for, continue, break

Ces structures permettent de faire des boucles qui s’arrête si la condition devient fausse.

Voici la structure de déclaration d’une structure itérative while :

while (condition) // tant que la condition est vraie, exécuter la partie de code en boucle
{
partie de code / instruction
}
Et voici un exemple :

ABC = 40 ;
while (ABC < 42)
{
printf(‘’cette partie de code sera lu tant que ABC < 42. Donc 3 fois ici.’’) ;
a++;
}
CER PROSIT 1.6 Compilation

On peut noter qu’une initialisation de la variable que l’on va mettre dans la condition est obligatoire
avant le while. Une instruction augmentant ou diminuant selon la condition la valeur de la variable
présente dans la condition est aussi nécessaire pour éviter une boucle infinie. Dans l’exemple,
l’instruction faisant office de cela est a++. Cette instruction augmente de 1 la valeur de a. Elle peut
aussi se noter a + 1.

Voici la structure de déclaration d’une structure itérative do… while :

do
{
Partie de code / instruction
}
while (condition) // tant que la condition est vraie, exécuter la partie de code en boucle

Cette structure possède qu’une différence avec while. Avec while, la condition est d’abord vérifiée
avant le premier passage dans la partie du code alors qu’avec do while, la partie du code est
forcément lu une fois. Après cette première lecture, la condition du while est utilisé pour déterminer
si la partie du code sera lu une autre fois.

Voici la structure de déclaration d’une structure itérative for :

for (initialisation de la variable ; condition ; opération sur la variable de la boucle)

{
partie du code / instruction
}
Et voici un exemple :

for (ABC = 0 ; ABC != 5 ; ABC++)

{
printf(‘’cette partie de code sera lu tant que ABC != 5) ;
}

Dans les structures itératives, il y a les instructions d’altération de contrôle de boucle : l’instruction
continue, l’instruction break, et l’instruction goto.

Voici la structure de déclaration de continue :

Cette structure est à éviter car elle rend le code difficilement compréhensible.

Voici la structure de déclaration de break :

CER PROSIT 1.6 Compilation

Voici la structure de déclaration de goto :

Cette structure est à éviter car elle rompt avec la logique conditionnelle du code.

 La structure conditionnelle particulière : switch

La structure switch permet d’exécuter une partie différente de code selon la valeur d’une variable.

Voici la structure de déclaration d’une structure conditionnelle particulière switch :

switch(NOM DE LA VARIABLE)
{
case VALEUR1 :
Instructions lues si la variable est égale à VALEUR1
break;
case VALEUR2 :
Instructions lues si la variable est égale à VALEUR2
break;
default :
Instructions lues si la valeur de la variable est différente de VALEUR1 et VALEUR2
break;
}

F. Les étapes de la compilation

Pour que le langage C soit exécutable, il faut tout d’abord traduire le code en langage machine. Cette
étape s’appelle la compilation. La compilation est effectuée par un programme. On distingue 4
étapes de compilation :

- Préprocesseur : cette première étape est une analyse puis transformation

textuelle du code.
- Compilation : cette seconde étape traduit le fichier obtenu en assembleur.
- Assemblage : cette troisième étape transforme le code assembleur en fichier
binaire lisible par le processeur.
- Édition de lien : Si plusieurs fichiers sources sont présent, cette étape finale va
rassembler ces fichiers en un seul pour ensuite produire un fichier exécutable.

Pour compiler du C il faudra utiliser la commande GCC.

CER PROSIT 1.6 Compilation

3. Analyse du code

Ce code est un comparateur de valeur.

4. La mini-calculatrice
CER PROSIT 1.6 Compilation

Validation des hypothèses :

- Même boucles dans le code et dans l’algorigramme de la mini-calculatrice

Il est effectivement possible de convertir les boucles de l’algorigramme en code mais comme il existe
de multiple façon de programmer une mini-calculatrice on peut très bien faire autrement.

- Après le Include on retrouve la bonne bibliothèque de fonction

Oui après le include on déclare la bibliothèque de fonction à utiliser : dans notre cas la librairie
standard STDIO.

- Utiliser le Printf et Scanf pour la mini-calculatrice

Oui, printf pour afficher et scanf pour demander les valeurs à calculer ainsi que l’opérateur à utiliser.

- Chaque fonction qu’on retrouve dans l’algorithme peuvent être retrouvés dans le langage C.

Effectivement. L’algorithme étant du pseudo code, on peut bien sur retrouver l’équivalent en c.

Conclusion et retour sur les objectifs :

L’objectif était de traduire l’algorigramme de la mini-calculatrice en langage C. L’objectif à bien été

réalisé.

Les contraintes étaient les suivantes :

- Langage C ;
- Ajouter du Include ;
- Savoir Compiler ;
- Codes dans un seul fichier ;
- Respecter la syntaxe et leur convention.

Le langage C a été utilisé. L’include nécessaire à la fonction printf et scanf à bien été ajouté dans le
code la mini-calculatrice. La compilation est effectuée par un programme. Pour lancer une
compilation il faut utiliser GCC. Le code est bien dans un seul fichier et la syntaxe et convention a
bien été respecté. Les contraintes ont donc été levées.

Bilan critique du travail effectué :

Mon CER m’a l’air plutôt complet. Cependant tout le C n’est pas expliqué ici. Il reste de nombreuse
notion non étudiée et d’autres à approfondir. De plus, comprendre ce CER ne suffit pas à maitriser
les bases du C. Il faut coder en c énormément tout en veillant à ne pas prendre de mauvaise habitude
en respectant la syntaxe et certaines conventions rendant plus lisible le code pour maitriser vraiment
les notions abordées ici.

Ce bilan clos mon CER. Merci de l’avoir lu, il est plutôt long ;).