Le langage C
Presenté par SOLOHERIANIANA José Pascal
1.Introduction au langage C
• Historique
• 1960 – Algol60
très abstrait, donne le Pascal, PL/I et CPL
• 1967 – BCPL par Martin Richards
Basic Combined Programming Language
• 1970 – Langage B par Ken Thompson
afin d’assurer l’évolution de Unix écrit en assembleur, son créateur crée ce langage
inspiré du BCPL
• 1972 – Langage C par Dennis Ritchie et Ken Thompson
après modification du langage B
Description de l’environnement de programmation
Cette partie décrit la prise en main de l’environnement de programmation gcc utilisé en TD sous envi-ronnement
Linux ou avec cygmin sous Windows .
Convention à utiliser pour les extensions des noms de fichiers :
.c : fichier source C
.h : fichier en-tête (header) C
.o : fichier objet
sans extension : exécutable
Premier exemple
Utiliser votre éditeur favori pour taper la version C suivante du classique “Hello World” . . .en français.
/*Vous l’avez reconnu : Bonjour le monde !*/
#include<stdio.h>
int main()
{
printf("Bonjour le (centre du) monde !\n");
return 0;
}
Sauvegarder ce programme dans le fichier bonjourlemonde.c.
Méthode 1 : génération directe de l’exécutable
Le cas simple du code contenu dans un fichier unique permet d’utiliser une seule commande à cet effet.
La version la plus courte est
$ gcc bonjourlemonde.c
A partir du fichier source bonjourlemonde.c, le compilateur gcc génère un exécutable appelé a.exe(windows)
a.out(linux) qui se trouvera au même endroit que le fichier source.
Pour l’exécuter il suffit alors d’entrer la commande suivante (dans une fenêtre terminal)
$ ./a.exe ou ./a.exe
Il est plus pratique de pouvoir choisir le nom de son exécutable en le précisant avec l’option -o.
$ gcc -o bonjourlemonde bonjourlemonde.c
Profitons-en pour introduire quelques options de compilation obligatoires tout au long de cette année.
Vous utiliserez en effet la commande plus longue suivante.
$ gcc -Wall -pedantic -std=c99 -o bonjourlemonde bonjourlemonde.c
– -std=c99 indique au compilateur de traiter le code selon le standard C99 (et donc de rejeter certaines
extensions comme celles de GNU par exemple)
– -pedantic permet de signaler les avertissements, ou warnings, selon la norme ISO ; et
– -Wall permet de signaler un grand nombre d’autres warnings décrit dans le man gc
Méthode 2 : compiler et lier avant d’exécuter
Dès que votre application comporte plusieurs fichiers, il est nécessaire de procéder en deux étapes :
i) compilation-génération (option -c) d’un fichier objet (extension .o)
ii) puis création de l’exécutable (sans extension) par éditions des liens (option -o) entre les différents
fichiers objets.
Dans le cas simple, chaque étape (compilation, édition des liens) correspond à une des deux lignes de
commandes suivantes.
$ gcc -Wall -pedantic -std=c99 -c bonjourlemonde.c
$ gcc -Wall -pedantic -std=c99 -o bonjourlemonde bonjourlemonde.o
Il suffit maintenant d’exécuter bonjourlemonde
Editer-compiler-lier-exécuter
Une session classique
1. Créer un fichier source sous l’éditeur,
2. le compiler,
3. corriger (sous l’éditeur) les erreurs signalées par le compilateur,
4. le recompiler puis revenir à l’étape 3 tant que la compilation ne s’achève pas avec succès,
5. exécuter le programme sur différents jeux de données bien choisis,
6. identifier ainsi les (premiers) bugs et revenir à l’étape 3 jusqu’à obtenir l’exécution attendue.
Utiliser MSys2 sous M* Windows.
Nous vous proposons d’installer le compilateur GCC à l’aide de MSys2 qui est une suite
logicielle permettant de disposer d’un environnement compatible POSIX sous Windows.
Rendez-vous sur le site de MSys2 et téléchargez la version correspondant à votre système (32 ou 64 bits).
Exécutez ensuite le programme et suivez la procédure d’installation.
Une fois l’installation terminée, vous serez face au terminal de MSys2.
Entrez alors la commande pacman -Syu et validez ce qui est proposé. Une fois cette commande
exécutée, il devrait vous être demandé de fermer le terminal.
Fermez alors cette fenêtre et ouvrez en une nouvelle. Dans celle-ci, exécutez la commande
pacman -Su puis pacman -S gcc et validez à chaque fois les actions proposées. Le compilateur
est à présent installé
L’éditeur de texte
L’éditeur de texte va nous permettre d’écrire notre code source et de l’enregistrer. L’idéal est d’avoir un
éditeur de texte facile à utiliser et pas trop minimaliste. Si jamais vous avez déjà un éditeur de texte et que
vous l’appréciez, n’en changez pas, il fera sûrement l’affaire.
Si vous n’avez pas d’idée, nous vous conseillons CodeBlocks qui est simple, pratique et
efficace. Pour le télécharger, rendez-vous simplement dans la site web de Téléchargements.
Introduction
Maintenant que nous avons introduit le langage C et installé les outils nécessaires, il est temps de plonger dans
le vif du sujet et de compiler notre premier programme.
Bien, il est à présent temps d’écrire et de compiler notre premier programme!
Pour ce faire,
ouvrez votre éditeur de texte et entrez les lignes suivantes.
/*Vous l’avez reconnu : Bonjour le monde !*/
#include<stdio.h>
int main()
{
printf("Bonjour le (centre du) monde !\n");
return 0;
}
Ensuite, enregistrez ce fichier dans un dossier de votre choix et nommez-le «main.c»
Une fois ceci fait, rendez-vous dans le dossier contenant le fichier à l’aide d’un terminal et exécutez la
commande de compilation et d’éxecution au par avant
Erreur lors de la compilation
Si cela ne vous est pas arrivé lors de la compilation du premier code d’exemple, il vous arrivera de rencontrer
des erreurs lors de la compilation.
Le plus souvent, ces dernières se produisent à cause d’erreurs de syntaxe.
Par exemple, si vous essayez de compiler le code suivant, vous obtiendrez une erreur.
intxxx main(void)
{
return 0;
}
gcc -Wall -Wextra -pedantic -std=c11 -fno-common -fno-builtin main.c
Les commentaires
Il est possible d’ajouter des commentaires dans un code source, par exemple pour décrire des passages un peu
moins lisibles ou tout simplement pour offrir quelques compléments d’information au lecteur du code.
Nous en utiliserons souvent dans la suite de ce cours pour rendre certains exemples plus parlant.
Un commentaire est ignoré par le compilateur, il n’est pas présent dans l’exécutable final. Il ne sert qu’au
programmeur et aux lecteurs du code.
Un commentaire en C est écrit soit en étant précédé de deux barres obliques //, soit en étant
placé entre les signes /* et */. Dans le dernier cas, le commentaire peut alors s’étendre sur plusieurs lignes.
// Ceci est un commentaire.
/* Ceci est un autre commentaire. */
/* Ceci est un commentaire qui
prends plusieurs lignes. */
2.Déclarations variables et fonctions
2.1. Déclarations variables
Pour la déclarer, il faut commencer par le type, puis le nom, et enfin la valeur.
Regardons la déclaration suivante de la variable count :
La déclaration d'une variable doit donc contenir deux choses : un nom et le type de données
qu'elle peut contenir.
La déclaration d'une variable permet de réserver la mémoire pour en stocker la valeur.
Le nom d'une variable doit refléter la signification de son contenu, comme des étiquettes sur une
boîte.
Par example:
int nombreDeMotsDansLaPhrase = 1000;
long nombre;
char text = "A";
int jour, mois, annee ;
Types
Comme dit précédemment, un type permet d’indiquer au compilateur quel genre de données nous
souhaitons stocker.
Ce type va permettre de préciser:
— toutes les valeurs que peut prendre la variable;
— les opérations qu’il est possible d’effectuer avec (il n’est par exemple pas possible de réaliser une
division entière avec un nombre à virgule flottante, nous y reviendrons).
Définir le type d’une variable permet donc de préciser son contenu potentiel et ce que nous pouvons faire
avec.
Le langage C fournit dix types de base
Le type char sert au stockage de caractères.
Les types signed char, short int, int, long int et long long int servent tous à stocker des nombres entiers
qui peuvent prendre des valeurs positives, négatives, ou nulles.
Le type _Bool3 est un type entier non signé un peu particulier: il permet de stocker soit 0, soit 1
Les types float, double et long double permettent quant à eux de stocker des nombres réels.
Capacité d’un type
Les types entiers et flottants Tous les types stockant des nombres ont des bornes, c’est-à-dire une
limite aux valeurs qu’ils peuvent stocker
Le type char
Le type char quant à lui est garanti de pouvoir stocker un ensemble de caractères limités.
il s’agit des caractères suivants
Les mots-clés
Déclaration
Maintenant que nous connaissons toutes les bases, entrainons-nous à déclarer quelques variables
Il est possible de déclarer plusieurs variables de même type sur une même ligne, en séparant leur noms par
une virgule
int age, taille, nombre;
Ceci permet de regrouper les déclarations suivant les rapports que les variables ont entre elles
Initialiser une variable
En plus de déclarer une variable, il est possible de l’initialiser, c’est-à-dire de lui attribuer une valeur. La
syntaxe est la suivante.
type identificateur = valeur;
Pour les types entiers, c’est assez simple, la valeur à attribuer est… un nombre entier.
Rendre une variable constante
En plus d’attribuer une valeur à une variable, il est possible de préciser que cette variable ne pourra pas être
modifiée par la suite à l’aide du mot-clé const.
Ceci peut être utile pour stocker une valeur qui ne changera jamais (comme la constante π qui vaut toujours
3,14159265).
Affecter une valeur à une variable
Nous savons donc déclarer (créer) nos variables et les initialiser (leur donner une valeur à la création).
Il ne nous reste plus qu’à voir la dernière manipulation possible: l’affectation.
Celle-ci permet de modifier la valeur contenue dans une variable pour la remplacer par une autre valeur.
Example
Manipulations basiques des entrées/sorties
Durant l’exécution d’un programme, le processeur a besoin de communiquer avec le reste du matériel. Ces
échanges d’informations sont les entrées et les sorties (ou input et output pour les anglophones), souvent
abrégées E/S (ou I/O par les anglophones).
Les entrées permettent de recevoir une donnée en provenance de certains périphériques.
À l’inverse, les sorties vont transmettre des données vers ces périphériques
Les sorties
Intéressons-nous dans un premier temps aux sorties. Afin d’afficher du texte au console, nous avons besoin
d’une fonction particulière printf() .
Deux remarques au sujet de ce code
#include <stdio.h>
s’agit d’une directive du préprocesseur, facilement reconnaissable car elles commencent toutes par le symbole
#. Celle-ci sert à inclure un fichier («stdio.h») qui contient les références de différentes fonctions d’entrée et
sortie («stdio» est une abréviation pour «Standard input output», soit «Entrée-sortie standard»).
Un fichier se terminant par l’extension «.h» est appelé un fichier d’en-tête (header en anglais) et fait partie avec
d’autres d’un ensemble plus large appelée la bibliothèque standard («standard» car elle est prévue par la
norme1
).
Les formats
Ceux-ci sont en fait des sortes de repères au sein d’un texte qui indiquent à printf() que la valeur
d’une variable est attendue à cet endroit.
Voici un exemple pour une variable de type int.
En voici une liste non exhaustive.
Examplle
Les caractères spéciaux
Dans certains cas, nous souhaitons obtenir un résultat à l’affichage (saut de ligne, une tabulation,
un retour chariot, etc.).
Interagir avec l’utilisateur
Nous allons à présent voir comment en récupérer grâce à la fonction scanf(), dont l’utilisation est assez
semblable à printf().
Les opérations mathématiques
Nous savons désormais déclarer, affecter et initialiser une variable, mais que diriez-vous d’apprendre à
réaliser des opérations dessus? Il est en effet possible de réaliser des calculs sur nos variables, comme les
additionner, les diviser voire des opérations plus complexes.
Les opérations mathématiques de base
— l’addition (opérateur +);
— la soustraction (opérateur -);
— la multiplication (opérateur *);
— la division (opérateur /);
— le modulo (opérateur %).
Les opérateurs combinés
Comment vous y prendriez-vous pour multiplier une variable par trois? La solution qui devrait vous venir à
l’esprit serait d’affecter à la variable son ancienne valeur multipliée par trois.
Avec le code précédent, nous obtenons ceci.
L’incrémentation et la décrémentation
L’incrémentation et la décrémentation sont deux opérations qui, respectivement, ajoute ou enlève une
unité à une variable.
Avec les opérateurs vus précédemment, cela se traduit par le code ci-dessous.
Cependant, ces deux opérations étant très souvent utilisées, elles ont droit chacune à un opérateur
spécifique disponible sous deux formes:
— une forme préfixée;
— une forme suffixée.
La forme préfixée s’écrit comme ceci.
La forme suffixée s’écrit comme cela
Example
