REPUBLIQUE DEMOCRATIQUE DU CONGO

MINISTERE DE L’ENSEIGNEMENT SUPERIEUR, UNIVERSITAIRE ET

RECHERCHES SCIENTIFIQUES
INSTITUT SUPERIEUR DE TCHNIQUES APPLIQUEES
DE GOMBE MATADI
ISTA/G-M

SECTION Informatique, Mécanique et

Construction

Les Bases de la Programmation

Informatique

Bergelin MANSINSA MATUETIMONA

Ir. en Génie électrique/Informatique appliquée
Assistant

Année académique 2025-2026

Introduction
Dans ce cours, nous allons aborder les bases de la programmation d’un
ordinateur, afin de constituer une introduction en douceur aux autres cours de
programmation.
On y verra ce qu’est la programmation informatique, et pourquoi elle est
nécessaire. On abordera un certain nombre de notions essentielles à la
compréhension d’un cours de programmation, comme les notions de langage
informatique, d’exécutable, d’interpréteur ou encore de débogueur, et l’on en
profitera pour enseigner le vocabulaire usuel de la programmation.
On abordera également quelques notions un peu plus avancées, comme les
patrons de conception ou les bonnes pratiques en programmation, car elles sont
transversales à tous les langages de programmation, et s’avéreront utiles un peu
plus tard dans l’apprentissage. Enfin, on présentera brièvement les principaux
langages de programmation, afin de vous orienter vers un choix qui vous
correspond.

Objectifs
À la fin du cours, l’étudiant(e) sera capable de :

 Maitriser les fondamentaux de la programmation informatique.

 Identifier les structures de base d’un programme. Expliquer les structures
conditionnelles et répétitives.
 Traduire un algorithme en programme C.
 Déboguer et tester un programme.
 Manipuler entrées/sorties pour traiter des données.
 Résoudre des problèmes scientifiques simples (forces, vitesses, etc.)
 Préparer les étudiants aux cours futurs : Matlab, simulation numérique
ect…

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
Table des matières
Introduction............................................................................................................................................. 2
Objectifs .................................................................................................................................................. 2
Chapitre I. Généralités............................................................................................................................. 5
I.1. Introduction ................................................................................................................................... 5
[Link] la programmation ? ........................................................................................................ 5
I.3. Créer des programmes .................................................................................................................. 6
I.3.1. On programme généralement dans un contexte donné........................................................ 7
I.3.2. Un type de fichiers particulier : les programmes ................................................................... 7
I.4. Au commencement était le code source ...................................................................................... 8
I.5. Comment apprendre? ................................................................................................................. 11
Choix du langage ................................................................................................................................... 11
I.6. Vers l’exécutable, et au-delà ! ..................................................................................................... 11
I.6.1. Langages compilés ................................................................................................................ 12
I.6.2. Langages interprétés ............................................................................................................ 12
I.6.3. Langages à machine virtuelle ............................................................................................... 13
I.7. Il y a programmer, et bien programmer ..................................................................................... 13
I.7.1. Les outils indispensables ...................................................................................................... 13
I.7.2. Un compilateur ou interpréteur ........................................................................................... 14
I.7.3. Un débogueur ....................................................................................................................... 14
I.7.4. Les IDE .................................................................................................................................. 14
I.7.5. Quelques outils supplémentaires ......................................................................................... 15
[Link] et conseils ..................................................................................................................... 16
Chapitre II. Les bases de la programmation en C .................................................................................. 18
II.1 Historique .................................................................................................................................... 18
II.2 La compilation ............................................................................................................................. 18
II.3 Les composants élémentaires du C ............................................................................................. 19
II.3.1 Les identificateurs ................................................................................................................ 19
II.3.2 Les mots-clefs ....................................................................................................................... 19
II.3.3 Les commentaires................................................................................................................. 20
II.4 Structure d’un programme C....................................................................................................... 20
II.5 Les types prédéfinis ..................................................................................................................... 21
II.6 Les opérateurs ............................................................................................................................. 22
II.6.1 L’affectation.......................................................................................................................... 22
II.6.2 Les opérateurs arithmétiques .............................................................................................. 23
II.6.3 Les opérateurs relationnels .................................................................................................. 23
Bergelin MANSINSA MATUETIMONA
Ir. En Génie électrique/ informatique appliquée
 II.6.4 Les opérateurs logiques booléens ........................................................................................ 23
[Link] langages de programmation ................................................................................................. 23
II.7.1. Langages interprétés - Langages compilés .......................................................................... 24
II.7.2. Vers des langages de plus en plus évolués .......................................................................... 25
[Link] langages non structurés ................................................................................................. 25
II.7.4. Les langages structurés ....................................................................................................... 25
II.8. Développer, un métier à part entière ........................................................................................ 26
II.9. Un éditeur de texte .................................................................................................................... 27
[Link] le programme ........................................................................................................... 27
[Link]. LES LITTERAUX ET LES VARIABLE ..................................................................................... 32
[Link]................................................................................................................................ 32
III.2. Les littéraux ............................................................................................................................... 32
[Link] variables ............................................................................................................................... 32
III.2.1. Déclaration d’une variable ................................................................................................. 33
III.2.2. Types de variables .............................................................................................................. 33
III.2.3. Affecter une valeur à une variable ..................................................................................... 34
[Link] ............................................................................................................................ 35
III.3. Les entrées-sorties .................................................................................................................... 36
[Link] le contenu d'une variable ...................................................................................... 36
III.3.2. Récupérer une saisie .............................................................................................................. 38
[Link] calculs de base...................................................................................................................... 39
CHAPITRE IV. LES STRUCTURES DE CONTROLE ..................................................................................... 48
IV.1. Introduction .............................................................................................................................. 48
[Link] conditions............................................................................................................................. 48
[Link] condition if ...................................................................................................................... 49
[Link] : ce qu'il faut faire si la condition n'est pas vérifiée .................................................... 50
[Link] if : effectuer un autre test............................................................................................ 50
[Link] des conditions .............................................................................................. 51
[Link] condition switch ............................................................................................................. 53
[Link] boucles ................................................................................................................................. 56
[Link] — Tant que… ............................................................................................................. 57
[Link] boucle do… while ............................................................................................................ 59
[Link] boucle for........................................................................................................................ 59
Bibliographie.......................................................................................................................................... 61

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
Chapitre I. Généralités
I.1. Introduction
Un programme est une suite d'instructions définissant des opérations à réaliser
sur des données.
Les instructions du programme sont exécutées les unes après les autres, le plus
souvent dans l'ordre séquentiel dans lequel elles sont données dans le
programme on dit que le flot d'exécution, ou flot de contrôle, est séquentiel.
Pour écrire des programmes, on se sert d'une notation, appelée langage de
programmation.
Les langages de programmation les plus rudimentaires sont ceux qui « collent »
au jeu d'instructions de l'ordinateur ; on les appelle les langages d'assemblage.
Un langage d'assemblage est par définition propre à un processeur donné (ou au
mieux à une famille de processeurs) ; l'évolution de la programmation vers des
projets à la fois complexes et portables a créé le besoin de langages de plus haut
niveau.
[Link] la programmation ?
Pour bien comprendre la raison d’être de la programmation, il vous faut déjà
comprendre ce qu’est réellement un ordinateur en fin de compte. Beaucoup de
gens pensent qu’un ordinateur est une grosse boite noire, quelque peu mystique
et particulièrement intelligente. Comme nous allons le voir, la réalité est tout
autre.
D’abord, un ordinateur, ça regroupe énormément de choses, depuis l’ordinateur
de bord de votre voiture jusqu’aux supercalculateurs de Météo, en passant par
les téléphones dits intelligents (smartphone, en anglais), les ordinateurs de
bureau (fussent-ils Mac ou PC), les consoles de jeu et les calculettes
programmables. Mais derrière cette variabilité se cache une réalité beaucoup
plus simple : un ordinateur est composé des trois éléments suivants.
 Un processeur, dont nous allons reparler dans un instant.
 De la mémoire, qui peut prendre des formes extrêmement variées, mais
dont l’utilité est toujours la même : garder un certain nombre
d’informations (que l’on appelle des données), à disposition du processeur
jusqu’au moment où il en aura besoin.
 Des périphériques, qui peuvent en théorie être absents. Un périphérique
est un circuit électronique dédié à une tâche précise, et qui sert au
processeur à communiquer avec le monde extérieur : par exemple, une
carte graphique1, pour afficher des choses sur un support visuel, une carte
son, pour… produire du son, un clavier ou une souris, pour que

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
 l’utilisateur puisse lui communiquer des informations, ou encore un
capteur de température, pour éviter la surchauffe.

L’élément central d’un ordinateur est donc son processeur. De quoi s’agit-il ?
Simplement et uniquement d’une machine à calculer extrêmement rapide. En
effet, bien qu’il fonctionne à l’électricité, un processeur n’est rien de plus qu’un
automate : il est possible de lui donner des ordres, que l’on appelle des
instructions, et une suite d’instructions strictement identiques produira
systématiquement le même résultat, sans la moindre originalité. Les instructions
qu’un processeur peut recevoir diffèrent d’un modèle à l’autre2, et peuvent être
très variées au sein d’un même modèle, mais elles se ramènent toutes à quatre
types.
 Copier le contenu d’un emplacement en mémoire vers un autre
emplacement en mémoire.
 Comparer le contenu d’un emplacement en mémoire avec une valeur
prédéfinie.
 Effectuer des opérations mathématiques de base. Quand je dis de base, je
parle vraiment de base : addition, multiplication, quelques fonctions
trigonométriques, etc. Peut-être certains processeurs spécialisés peuvent-
ils réaliser des opérations un peu plus sioux, mais l’immense majorité des
processeurs ne connaît pas plus d’opérations mathématiques qu’un élève
de Terminale S.
 Envoyer ou recevoir des données vers ou depuis un périphérique.

Et c’est tout. Tout de suite, ça casse le mythe, hein ? Et pourtant, c’est en

profitant du fait que le processeur est capable d’obéir à des millions de telles
instructions basiques chaque seconde que l’on parvient à écrire des jeux vidéos.
Programmer un ordinateur, cela consiste donc à placer en mémoire les
données adéquates pour que votre processeur et ses périphériques, contrôlés par
lui, se comportent comme vous le voulez.
I.3. Créer des programmes
Programmer, c’est avant tout créer des programmes. Mais là, on se mord un
peu la queue : dans ce cas, ça veut dire quoi « programme », et comment on en
crée un ? A fortiori plusieurs ?
À moins que vous ne lisiez ce cours depuis le futur, à l’aide d’une technologie
qui m’est encore inconnue3, vous le consultez depuis votre navigateur Web
(Firefox, Chrome, Internet Explorer, Edge, Safari, Opera…), qui est un
Bergelin MANSINSA MATUETIMONA
Ir. En Génie électrique/ informatique appliquée
programme. Tous et chacun de vos jeux vidéo sont des programmes. De même
que votre traitement de texte, votre lecteur vidéo, la fenêtre qui s’affiche lorsque
vous consultez une image, ou encore l’application « réveil » de votre éventuel
téléphone.
I.3.1. On programme généralement dans un contexte donné
Tous ces programmes tournent sur un système d’exploitation4 : ce peut être
Windows, Linux, OS X, le plus couramment, Android ou iOS (ou
éventuellement Firefox OS) si vous êtes sur téléphone ou tablette, ou encore
OpenBSD, FreeBSD ou Solaris pour les plus explorateurs d’entre vous.
Celui-ci est une sorte de super-programme, qui fait le pont entre le matériel et
les autres programmes. Le qualifier de dictateur bienveillant serait plus exact : il
a la mainmise totale sur l’accès au matériel, c’est lui qui décide sur quoi le
processeur va travailler, et il fournit un certain nombre de services auxquels les
programmes devront avoir recours pour toutes leurs tâches qui concernent les
ressources communes (en particulier, la mémoire et l’utilisation des
périphériques).
Son utilité première (outre la gestion des conflits entre programmes pour l’accès
aux ressources), ce sont précisément ces services. Il fournit en réalité des
abstractions, que les programmes peuvent utiliser pour faire fonctionner le
matériel, quel que soit le matériel effectivement utilisé.
Par exemple, malgré leur grande diversité, il est un service que tous les systèmes
d’exploitation offrent, sans exception : un système de fichiers. Il s’agit d’une
manière de structurer les données conservées en mémoire, en particulier sur les
mémoires « longue durée » comme les disques durs, clés USB ou autres CD, de
manière à pouvoir retrouver l’intégralité d’un ensemble cohérent de données. En
effet, il serait dommage de mettre de côté une image et que votre ordinateur n’en
retrouve que la moitié !
I.3.2. Un type de fichiers particulier : les programmes
Mais revenons sur ces fichiers, car ils se divisent en deux catégories. D’une part,
les fichiers de données, qui stockent de l’information, et sont destinés à être
utilisés comme tels : une image, une vidéo, un son, un document de bureautique,
un livre électronique, etc. D’autre part, les fichiers exécutables, qui stockent le
moyen de faire réaliser un certain nombre d’actions à l’ordinateur.
Et c’est là que l’on retrouve nos programmes ! En effet, quand on fait faire à un
programme ce pour quoi il est conçu, on dit qu’on l’exécute6. Mais n’en restons
pas là, il existe deux sortes de fichiers exécutables. Les premiers s’appellent les
bibliothèques logicielles.
Bergelin MANSINSA MATUETIMONA
Ir. En Génie électrique/ informatique appliquée
Une bibliothèque logicielle est une collection de petits outils destinés à une
tâche bien précise qui sont partagés, car ils peuvent être utiles à de nombreux
programmes. En effet, des centaines de programmes peuvent avoir besoin
d’afficher une barre de menus en haut de leur fenêtre, ou de décompresser une
archive ZIP. Il serait fastidieux et totalement contre-productif que chaque
programme qui en a besoin réécrive et contienne les instructions permettant de
réaliser cette tâche. On regroupe donc ces instructions dans une bibliothèque, et
les programmes qui en ont besoin se contentent de l’appeler le moment venu.
Il n’est donc pas possible d’exécuter directement une bibliothèque. Il faut
nécessairement l’appeler depuis un autre programme, conçu pour réaliser des
tâches qui ne serviront qu’à lui. On l’appelle un logiciel et il constitue notre
seconde catégorie de fichiers exécutables. Tous les programmes dont je vous ai
parlé plus haut (navigateur, traitement de texte, etc.) sont des logiciels, qui
s’appuient sur des bibliothèques mais ne servent d’appui à aucun autre
programme.
Pour terminer sur le vocabulaire, on distingue les bibliothèques système, mises
à disposition nativement par le système d’exploitation, et les bibliothèques
tierces, qu’il faut installer en même temps que l’on installe un logiciel qui en a
besoin.
I.4. Au commencement était le code source
Pour créer vos propres programmes, il vous faudra des outils, qui seront détaillés
dans les deux sections suivantes. Mais il vous faudra également acquérir des
connaissances brutes et, en premier lieu, apprendre à maîtriser un langage de
programmation.
Un langage de programmation, c’est un ensemble de conventions et
d’abstractions, qui permettent d’écrire ce que l’on veut faire faire à son
ordinateur sous une forme plus compréhensible par un humain.
Par exemple, pour calculer la somme de tous les nombres de 1 à 100, si l’on se
limite strictement à ce dont est capable un processeur, cela prendra la forme de
la suite d’instructions suivante.

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
Vous avouerez que ce n’est pas très sexy. Il s’agit pourtant de la forme que
prend le plus basique de tous les langages de programmation, l’assembleur.
Celui-ci donne une maîtrise presque totale sur sa machine, car il n’est que la
transcription des instructions brutes sous une forme humainement
compréhensible. Mais en contrepartie, il est spécifique à chaque famille de
processeurs, et la moindre action intelligente est excessivement difficile à mettre
en œuvre. Un langage de programmation plus évolué (c’est-à-dire tous les
autres) permettra d’écrire plutôt ce qui suit.

Ou encore, dans d’autres langages, il est également possible d’écrire tout

simplement la ligne suivante.

Pour programmer, il suffit alors d’écrire un texte8, qui décrit dans un

formalisme donné ce que fait votre programme, et que l’on appelle un code
source : un programme spécialement dédié, que l’on appelle selon les cas un
compilateur ou un interpréteur (voir section suivante), va ensuite se charger
de transformer votre code source en les données adéquates pour faire
fonctionner votre ordinateur comme vous l’entendez.

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
Comme je l’ai dit, ce langage est formel. En effet, l’ordinateur n’étant jamais
qu’une machine à calculer, pas très intelligente de base, le
compilateur/interpréteur ne peut pas faire de miracle : contrairement à un
langage humain, où les sous-entendus, connotations et supplétifs permettent de
se faire comprendre même sans dire exactement les choses, les langages
informatiques n’ont qu’un nombre limité de moyens d’expression, qui doivent
être utilisés d’une manière spécifique. On appelle cela la syntaxe d’un langage,
et si on ne la respecte pas à la lettre, le compilateur/interpréteur refusera de
fonctionner.
Le bon côté, en revanche, c’est qu’un même code source pourra être compilé ou
interprété de manière à fonctionner sur plusieurs processeurs différents : là où
chaque processeur doit être contrôlé au moyen de ses instructions spécifiques
qui ne marcheront pas ailleurs, un programme écrit dans un langage de
programmation autre que l’assembleur sera réutilisable sur d’autres types de
machine, pour peu que le compilateur/interpréteur soit disponible sur cette plate-
forme.
Il existe au total des milliers de langages différents. Certains sont proches du
fonctionnement réel de la machine, d’autres très éloignés : on appelle les
premiers des langages de bas niveau et les autres des langages de haut niveau.
Mais tous partagent des abstractions, des conventions, des concepts qui
permettent de les classer en grandes familles, qui regrouperont des langages
ayant plus ou moins le même « patron de conception » : cela s’appelle des
paradigmes de programmation. Apprendre un langage est beaucoup plus simple
lorsque l’on connaît déjà un langage qui suit le même paradigme : en effet, il
n’est plus nécessaire d’apprendre toute la théorie sur laquelle repose le langage,
mais uniquement son implémentation effective.

Il n’appartient pas à ce cours de vous présenter les différents paradigmes de

programmation. Afin que vous connaissiez le vocabulaire, les principaux
paradigmes sont la programmation impérative (ou procédurale), la
programmation orientée objet qui en est une extension, la programmation
fonctionnelle, la programmation logique et la programmation concurrente, qui
est transversale aux quatre autres.
Outre la syntaxe, l’apprentissage d’un langage inclut généralement la
connaissance correcte de sa bibliothèque standard. En effet, il serait très
pénible de réinventer la roue chaque fois que l’on veut créer un nouveau
programme. Chaque langage est donc généralement livré avec un ensemble de
Bergelin MANSINSA MATUETIMONA
Ir. En Génie électrique/ informatique appliquée
morceaux de code qui permettent de réaliser des tâches courantes, comme
déterminer si une liste d’éléments contient une valeur donnée, en particulier des
tâches qui doivent être réalisées différemment d’un système d’exploitation à
l’autre, comme ouvrir un fichier ou afficher du texte à l’écran.
Tous ces morceaux de code pris ensemble s’appellent la bibliothèque standard
du langage, et il est possible d’appeler chacun d’eux facilement depuis votre
programme, via une syntaxe particulière. En particulier, les tâches spécifiques à
chaque système d’exploitation pourront généralement être appelées au moyen
d’une commande unique, et c’est la bibliothèque standard qui se chargera de
déterminer comment, précisément, elle doit les réaliser.
I.5. Comment apprendre?

Choix du langage
Il faut d’abord choisir un langage de programmation. Un ingénieur pourrait
évidemment être tenté d’apprendre à programmer en Maple, Matlab, Scilab ou
autre. Il faut qu’il comprenne qu’il s’agit là d’outils spécialisés pour
mathématicien ou ingénieur qui lui seront utiles et qui, certes, se programment,
mais pas à proprement parler de langages généralistes complets. Sans
argumenter sur les défauts respectifs des langages qui en font partie, il nous
semble évident qu’il ne s’agit pas du bon choix pour l’apprentissage de la
programmation.
Depuis quelques années, un langage qui s’impose de plus en plus est le Python.
La raison est qu’il est portable, puissant et facile d’accès. Cependant, il présente
des inconvénients.
Il est en constante évolution, non standardisé, et la compatibilité entre les
versions n’est pas garantie. De plus, les structures de données de Python, certes
très utiles, cachent la complexité qu’il y a derrière du point de vue de la gestion
mémoire, et il est important pour un ingénieur d’être conscient de ce qui se
passe en coulisse.
Encore une fois, répétons que le choix du langage n’est pas le plus important et
que l’essentiel est d’apprendre à programmer.

I.6. Vers l’exécutable, et au-delà !

Une fois que votre code source est rédigé, vous désirez légitimement pouvoir
exécuter votre programme. Les langages de programmation se répartissent en
trois catégories en fonction de la manière dont cette étape s’opère.

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
I.6.1. Langages compilés
La compilation consiste à transformer le code source en un fichier exécutable,
généralement unique, qui est immédiatement utilisable. Cette transformation est
effectuée par un compilateur, et si tout est généralement transparent pour vous,
le processus est en réalité assez complexe et passe par plusieurs étapes.
La compilation présente l’avantage que le fichier exécutable généré sera
optimisé pour votre machine, ce qui signifie qu’il sera plus rapide que s’il était
interprété, et qu’il prend généralement moins de place sur le disque dur que son
code source. Cela peut s’avérer un inconvénient si votre programme est destiné
à être diffusé auprès d’autres gens : il faudra soit leur fournir le code source et
les laisser le compiler par leurs propres moyens, soit fournir un exécutable
différent pour chaque système d’exploitation et pour chaque type de processeur,
et donc répéter autant de fois la compilation à chaque mise à jour du
programme, ce qui devient très vite fastidieux.
I.6.2. Langages interprétés
Dans le cas des langages interprétés, en revanche, on fournit le code source à
l’interpréteur, qui exécute directement le programme : plus besoin de vous
soucier du système d’exploitation ou du type de processeur des utilisateurs de
votre programme, vous diffusez directement le code source, qui est prévu pour !
En pratique, ce n’est pas tout à fait vrai. L’interpréteur est indispensable au
processus, et doit donc être installé sur l’ordinateur de votre utilisateur. Ce qui
constitue un obstacle quand l’interpréteur n’existe pas pour son système
d’exploitation et/ou son processeur. Voire, de manière plus fourbe, la
perspective de devoir installer un (gros) logiciel annexe peut décourager les gens
d’utiliser votre programme : par exemple, l’interpréteur Perl est installé par
défaut sous Linux, mais absent sous Windows, ce qui fait que très peu de gens
sous Windows utilisent des programmes en Perl, alors qu’ils sont assez courants
sous Linux. Et par conséquent, quelqu’un qui voudrait diffuser son programme
sous Windows et sous Linux choisira rarement de programmer en Perl.
Par ailleurs, comme le code source doit être « traduit » en code machine à
chaque exécution, les langages interprétés sont souvent lents comparés à des
langages compilés équivalents. Ce point est à nuancer légèrement. En effet, les
interpréteurs optimisent moins le code machine qu’ils génèrent, ce qui les rend
plus lents à l’exécution, mais le processus de génération du code machine est du
coup plus rapide que celui des compilateurs.

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
I.6.3. Langages à machine virtuelle
Et entre les deux, on trouve les langages à machine virtuelle, souvent
raccourcis en « langages à VM » d’après l’anglais virtual machine, qui ont un
pied dans chaque monde. Le principe en est de compiler le code source non pas
en code machine compréhensible par un processeur donné, mais en un code
machine « fictif » (généralement appelé bytecode) qui sera lui-même interprété
par la machine virtuelle associée au langage.
Un tel langage tire ses avantages et inconvénients des deux autres catégories.
Comme avec les langages interprétés, le programme compilé en bytecode peut-
être exécuté sur n’importe quel système d’exploitation et processeur… pourvu
que la machine virtuelle soit disponible pour cette combinaison.
En revanche, comme il y a eu une compilation en amont, le programme est plus
rapide que dans un langage interprété équivalent, et parvient souvent à atteindre
des vitesses similaires à celle d’un langage compilé en code machine « réel ».
Cela se paye cependant souvent par le fait que cette machine virtuelle peut être
assez gourmande en ressources, notamment en mémoire.
I.7. Il y a programmer, et bien programmer
I.7.1. Les outils indispensables
Comme vous vous en doutez peut-être, pour programmer, il nous faut plusieurs
outils. En fait, malgré toute la multitude d’outils disponibles pour faire tout un
tas de tâches, seuls quelques-uns sont vraiment absolument nécessaires.
Découvrons-les ensemble.
I.7.1.1. Un éditeur de texte
Cet outil est celui qui va nous permettre d’écrire notre code source. C’est un
outil commun, indispensable pour programmer dans n’importe quel langage. En
effet, même si certains langages offrent un interpréteur en ligne de commande
qui permet de tester rapidement quelques lignes, dès lors que l’on veut écrire un
programme un poil plus conséquent, et surtout qu’on veut sauvegarder le code
source, passer par un éditeur de texte devient incontournable !
On parle bien ici d’un éditeur de texte, et non d’un traitement de texte, comme
Word ou LibreOffice.
En théorie, n’importe quel éditeur ferait l’affaire : Notepad++, vim, gedit,
Emacs, bloc-note de Windows, nano, Kate, Visual Studio Code, etc. En
pratique, plus notre éditeur est complet et configurable, mieux c’est. En effet,
lorsqu’on programme, on apprécie d’avoir certaines fonctionnalités comme :
 l’auto-complétion, alias l’éditeur complète automatiquement le code que
l’on est en train d’écrire, soit en suivant la logique interne du langage (par
Bergelin MANSINSA MATUETIMONA
Ir. En Génie électrique/ informatique appliquée
 exemple, une parenthèse ouverte devra nécessairement être fermée, alors
autant ajouter dès le départ la parenthèse fermante), soit en vous
proposant des noms d’élément que vous avez déjà utilisés (par exemple, si
une des portions de votre code s’appelle « ornithorynque », l’éditeur vous
proposera de compléter automatiquement dès que vous taperez « orni ») ;
 la coloration syntaxique, alias l’éditeur affiche les caractères du code
dans différentes couleurs en fonction de ce qu’ils signifient dans le
langage ;
 la recherche / édition pour rechercher et remplacer rapidement des
portions de code, par exemple pour changer le nom d’un élément à tous
les endroits où il est utilisé ;
 l’indentation automatique et réglable, alias l’éditeur formate
automatiquement le code source pour aligner différentes portions faisant
corps.
I.7.2. Un compilateur ou interpréteur
Cet outil est directement lié au langage que vous souhaitez apprendre, aussi
aurez-vous beaucoup moins de marge de manoeuvre pour le choisir. Par
exemple, si en C++ vous avez le choix parmi gcc, Clang, LLVM, etc., au
contraire, en Python, vous devrez utiliser l’interpréteur Python. Si vous utilisez
un Unixoïde, tel que les BSD ou GNU/Linux, certains de ces outils, comme gcc,
sont fournis par défaut. Sinon, ce sera à vous d’aller sur le site officiel du
langage ou de l’outil pour le télécharger, l’installer et le configurer.
Si cela vous paraît compliqué, ne vous inquiétez pas : la plupart des tutoriels de
programmation vous indiqueront quels outils utiliser et télécharger et comment
le faire.
I.7.3. Un débogueur
Les développeurs sont susceptibles, comme tous les humains, de faire des
erreurs. Certaines sont tellement vicieuses que les retrouver et les corriger prend
du temps. Le débogueur est un outil qui va vous aider à les traquer. Il permet
d’exécuter le programme pas à pas, de voir son état à chaque instant, ainsi que
sa consommation de mémoire, de modifier en direct son état, de vérifier si une
portion de code est bien exécutée ou non, etc. En fonction du langage que vous
choisirez, le débogueur sera déjà disponible ou non.
I.7.4. Les IDE
Derrière ce sigle se cache le terme Integrated Development Environment, soit «
environnement de développement intégré » en bon français. Un IDE est un
regroupement de tous les outils que nous avons vus précédemment en un seul
logiciel. Ainsi, dans la même fenêtre, on va pouvoir écrire le code puis, d’un clic
Bergelin MANSINSA MATUETIMONA
Ir. En Génie électrique/ informatique appliquée
de souris ou d’un raccourci clavier (au choix), lancer le programme puis le
déboguer. Mais un bon IDE ne s’arrête pas là. Certains des plus puissants et des
plus complets intègrent même un navigateur Internet (pour consulter de la
documentation), ou des émulateurs (pour tester le code sur d’autres machines ou
d’autres systèmes d’exploitation), et peuvent être complétés par des modules
d’extension (plugins), etc.
Certains sont liés à un langage ou une plate-forme donnés, comme Android
Studio , qui est dédié au développement pour Android ; d’autres sont utilisables
avec différents langages, comme Eclipse ou Visual Studio. Certains sont
payants, d’autres gratuits. Certains ont une interface minimaliste et austère,
d’autres sont très complets. En bref, il y en a pour tous les goûts.

I.7.4.1. Que choisir ? Outils séparés ou IDE ?

C’est un grand débat qui fait rage parmi les développeurs. Chacun voit midi à sa
porte. Certains vont dire que des outils séparés leur donnent plus de flexibilité,
que les IDE ne sont pas assez configurables, qu’ils sont lourds et lents à
démarrer, qu’ils ont pleins d’options en pagaille qui ne sont jamais utilisées, etc.
D’autres vont dire que les IDE sont plus simples à utiliser, plus intuitifs,
permettent au programmeur de moins se laisser distraire par des opérations et
configurations manuelles pour mieux se concentrer sur le code, etc.
Je ne peux vous dire qu’une chose : faites votre propre choix.
I.7.5. Quelques outils supplémentaires
I.7.5.1. L’algorithmique
Un bon programmeur ne se jette pas sur son clavier sauvagement : il prend le
temps de réfléchir à ce qu’il va faire. Pour cela, il va d’abord concevoir des
algorithmes. Ce sont en quelque sorte des recettes de cuisine informatiques, qui
décrivent étape par étape la réalisation d’une action ou d’une commande. On
trouve ainsi des algorithmes pour trier un ensemble d’éléments, trouver le
chemin le plus court d’un point A à un point B, rechercher une information à
travers Internet (Google, par exemple, applique un algorithme pour retrouver ce
que vous avez demandé), etc.
En bref, ils sont omniprésents en informatique.
I.7.5.2. Les structures logicielles
Une structure logicielle (ou framework) est un type particulier de bibliothèque
logicielle. En effet, son but premier est d’encadrer votre programmation, en vous
fournissant autant que possible tous les outils dont vous aurez besoin, afin que
vous n’ayez pas à programmer en dehors d’elle. Par exemple, Django est un
Bergelin MANSINSA MATUETIMONA
Ir. En Génie électrique/ informatique appliquée
framework en Python destiné à faciliter la création de sites Web réactifs : il
impose une structure, et propose des outils génériques dont tous les sites peuvent
avoir besoin, tels qu’une interface d’administration, un espace membre et les
services d’authentification qui vont avec, le moyen de traduire son site en
plusieurs langues, etc.
Autre exemple, il existe plusieurs frameworks en JavaScript (jQuery ou
[Link], pour ne citer qu’eux) ayant un unique but : passer outre le fait que
chaque navigateur n’en fait qu’à sa tête concernant ce langage, et que les mêmes
actions doivent s’écrire différemment selon le navigateur utilisé par chaque
visiteur de votre site Web. Pour ce faire, ils proposent une interface unique, et se
chargent en coulisse de transformer cela en code compréhensible par chaque
navigateur.
Eh oui ! Comme la bibliothèque standard d’un langage !
Alors framework ou pas framework ? C’est là une autre des éternelles disputes
entre développeurs. En pour, il y a le fait de pouvoir se consacrer plus à coder
réellement votre logiciel, et moins à re-coder des outils déjà codés cent fois, et
sans doute mieux que ce que vous seriez capable de faire.
[Link] et conseils
Au niveau auquel nous prétendons l’enseigner, la programmation ne requiert ni
grande théorie, ni connaissances encyclopédiques. Les concepts utilisés sont
rudimentaires mais c’est leur mise en œuvre qui est délicate. S’il n’y avait qu’un
seul conseil à donner, ce serait la règle des trois "P" :
1. Programmer
2. Programmer
3. Programmer
La pratique est effectivement essentielle. C’est ce qui fait qu’un enfant a plus de
facilités, puisqu’il a plus de temps. Ajoutons quand même quelques conseils de
base :
 S’amuser. C’est une évidence en matière de pédagogie. Mais c’est
tellement facile dans le cas de la programmation, qu’il serait dommage de
passer à côté ! Au pire, si programmer n’est pas toujours une partie de
plaisir pour tout le monde, il vaut mieux que le programme obtenu dans
la douleur soit intéressant pour celui qui l’a fait !
 Bricoler. Ce que nous voulons dire par là, c’est qu’il ne faut pas hésiter à
tâtonner, tester, fouiller, faire, défaire, casser, etc. L’ordinateur est un
outil expérimental. Mais sa programmation est elle aussi une activité
Bergelin MANSINSA MATUETIMONA
Ir. En Génie électrique/ informatique appliquée
 expérimentale à la base. Même si le programmeur aguerri trouvera la
bonne solution du premier jet, il est important pour le débutant
d’apprendre à connaître le langage et l’outil de programmation en jouant
avec eux.
 Faire volontairement des erreurs. Provoquer les erreurs pendant la
phase d’apprentissage pour mieux les connaître est le meilleur moyen de
comprendre beaucoup de choses et aussi de repérer ces erreurs quand
elles ne seront plus volontaires.
 Rester (le) maître (de la machine et de son programme). Que
programmer soit expérimental ne signifie pas pour autant qu’il faille faire
n’importe quoi jusqu’à ce que ça marche plus ou moins. Il faut avancer
progressivement, méthodiquement, en testant au fur et à mesure, sans
laisser passer la moindre erreur ou imprécision. En contre, il y a
l’obligation d’apprendre encore une couche d’abstraction, le fait
qu’utiliser un framework peut s’apparenter à chasser la mouche au lance-
roquette, et les limitations qu’induit toute structure.
 Debugger. Souvent, la connaissance du debuggeur (l’outil pour
rechercher les bugs) est négligée et son apprentissage est repoussé au
stade avancé. Cet outil est pourtant pratique pour comprendre ce qui se
passe dans un programme, même dépourvu de bugs. Il faut donc le
considérer comme essentiel et faisant partie intégrante de la conception
d’un programme. Là encore, un bon environnement de programmation
facilite la tâche.

Gardons bien présents ces quelques principes car il est maintenant temps de. . .
passer à notre premier programme!

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
Chapitre II. Les bases de la programmation en C

II.1 Historique
Le C a été conçu en 1972 par Dennis Richie et Ken Thompson, chercheurs aux
Bell Labs, afin de développer un système d’exploitation UNIX sur un DEC
PDP-11. En 1978, Brian
Kernighan et Dennis Richie publient la d´définition classique du C dans le livre
The C Programming language. Le C devenant de plus en plus populaire dans les
années 80, plusieurs groupes mirent sur le marché des compilateurs comportant
des extensions particulières.
En 1983, l’ANSI (American National Standards Institute) d´décida de
normaliser le langage ; ce travail s’acheva en 1989 par la d´définition de la
norme ANSI C. Celle-ci fut reprise telle quelle par l’ISO (International
Standards Organization) en 1990. C’est ce standard, ANSI C, qui est d´écrit
dans le présent document.

II.2 La compilation
Le C est un langage compilé (par opposition aux langages interprétés). Cela
signifie qu’un programme C est décrit par un fichier texte, appelé fichier source.
Ce fichier n´étant évidemment pas exécutable par le microprocesseur, il faut le
traduire en langage machine. Cette opération est effectuée par un programme
appelé compilateur. La compilation se décompose en fait en 4 phases
successives :

1. Le traitement par le préprocesseur : le fichier source est analysé par le

préprocesseur qui effectue des transformations purement textuelles
(remplacement de chaînes de caractères, inclusion d’autres fichiers source
. . . ).
2. La compilation : la compilation proprement dite traduit le fichier généré
par le préprocesseur en assembleur, c’est-`a-dire en une suite
d’instructions du microprocesseur qui utilisent des mnémoniques rendant
la lecture possible.
3. L’assemblage : cette opération transforme le code assembleur en un
fichier binaire, c’est-`a-dire en instructions directement compréhensibles
par le processeur. Généralement, la compilation et l’assemblage se font
dans la foulée, sauf si l’on spécifie explicitement que l’on veut le code
assembleur. Le fichier produit par l’assemblage est appelé fichier objet.
4. L’édition de liens : un programme est souvent séparé en plusieurs fichiers
source, pour des raisons de clarté mais aussi parce qu’il fait généralement
appel à des librairies de fonctions standard déjà écrites. Une fois chaque
code source assemblé, il faut donc lier entre eux les différents fichiers
objets. L’édition de liens produit alors un fichier dit exécutable.

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
II.3 Les composants élémentaires du C
Un programme en langage C est constitué des six groupes de composants
élémentaires suivants :
– les identificateurs,
– les mots-clefs,
– les constantes,
– les chaînes de caractères,
– les opérateurs,
– les signes de ponctuation.
On peut ajouter à ces six groupes les commentaires, qui sont enlevés par le
préprocesseur.

II.3.1 Les identificateurs

Le rôle d’un identificateur est de donner un nom à une entité du programme.
Plus précisément, un identificateur peut désigner :
– un nom de variable ou de fonction,
– un type défini par typedef, struct, union ou enum,
– une étiquette.
Un identificateur est une suite de caractères parmi :
– les lettres (minuscules ou majuscules, mais non accentuées),
– les chiffres,
– le “blanc souligné” ( ).
Le premier caractère d’un identificateur ne peut pas être un chiffre. Par exemple,
var1, tab 23 ou deb sont des identificateurs valides ; par contre, 1i et i:j ne le
sont pas. Il est cependant déconseillé d’utiliser comme premier caractère d’un
identificateur car il est souvent employé pour définir les variables globales de
l’environnement C.
Les majuscules et minuscules sont différenciées.
Le compilateur peut tronquer les identificateurs au-delà d’une certaine longueur.
Cette limite dépend des implémentations, mais elle est toujours supérieure à 31
caractères. (Le standard dit que les identificateurs externes, c’est-`a-dire ceux
qui sont exportés à l’édition de lien, peuvent être tronqués à 6 caractères, mais
tous les compilateurs modernes distinguent au moins 31 caractères).

II.3.2 Les mots-clefs

Un certain nombre de mots, appelés mots-clefs, sont réservés pour le langage
lui-même et ne peuvent pas être utilisés comme identificateurs. L’ANSI C
compte 32 mots clefs :

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
II.3.3 Les commentaires
Un commentaire débute par /* et se termine par */. Par exemple,
/* Ceci est un commentaire */

On ne peut pas imbriquer des commentaires. Quand on met en commentaire un

morceau de programme, il faut donc veiller à ce que celui-ci ne contienne pas de
commentaire.

II.4 Structure d’un programme C

Une expression est une suite de composants élémentaires syntaxiquement
correcte, par exemple
x=0
Ou bien
(i >= 0) && (i < 10) && (p[i] != 0)

Une instruction est une expression suivie d’un point-virgule. Le point-virgule

signifie en quelque sorte “évaluer cette expression”. Plusieurs instructions
peuvent être rassemblées par des accolades { et } pour former une instruction
composée ou bloc qui est syntaxiquement équivalent `a une instruction. Par
exemple :

if (x != 0)
{
z = y / x;
t = y % x;
}

Une instruction composée d’un spécificateur de type et d’une liste

d’identificateurs séparés par une virgule est une déclaration. Par exemple,

int a;
int b = 1, c;

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
 double x = 2.38e4;
char message[80];

En C, toute variable doit faire l’objet d’une d´eclaration avant d’être utilisée.
Un programme C se présente de la façon suivante :

II.5 Les types prédéfinis

Le C est un langage typé. Cela signifie en particulier que toute variable,
constante ou fonction est d’un type précis. Le type d’un objet définit la façon
dont il est représenté en mémoire.
La mémoire de l’ordinateur se décompose en une suite continue d’octets.
Chaque octet de la mémoire est caractérisé par son adresse, qui est un entier.
Deux octets contigus en mémoire ont des adresses qui diffèrent d’une unité.
Quand une variable est définie, il lui est attribué, une adresse. Cette variable
correspondra à une zone mémoire dont la longueur (le nombre
d’octets) est fixée par le type.

La taille mémoire correspondant aux différents types dépend des compilateurs ;

toutefois, la norme ANSI spécifie un certain nombre de contraintes.
Les types de base en C concernent les caractères, les entiers et les flottants
(nombres réels).
Ils sont désignés par les mots-clefs suivants :

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
II.6 Les opérateurs
II.6.1 L’affectation
En C, l’affectation est un opérateur à part entière. Elle est symbolisée par le
signe =. Sa syntaxe est la suivante :

variable = expression

Le terme de gauche de l’affectation peut être une variable simple, un élément de

tableau mais pas une constante. Cette expression a pour effet d’évaluer
expression et d’affecter la valeur obtenue `a variable. De plus, cette expression
possède une valeur, qui est celle expression.

Ainsi, l’expression i = 5 vaut 5.

L’affectation effectue une conversion de type implicite : la valeur de

l’expression (terme de droite) est convertie dans le type du terme de gauche. Par
exemple, le programme suivant.

Imprime pour x la valeur 6.5 (et non 7), car dans l’instruction i = j + x;
l’expression j + x a été convertie en entier.

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
II.6.2 Les opérateurs arithmétiques
Les opérateurs arithmétiques classiques sont l’operateur unaire - (changement de
signe) ainsi que les opérateurs binaires
+ addition
- soustraction
* multiplication
/ division
% reste de la division (modulo)

II.6.3 Les opérateurs relationnels

> Strictement supérieur

>= supérieur ou égal
< Strictement inférieur
<= inférieur ou égal
== égal
!= différent

Attention à ne pas confondre l’opérateur de test d’égalité == avec l’opérateur

d’affection =.
II.6.4 Les opérateurs logiques booléens
&& et logique
|| ou logique
! négation logique
[Link] langages de programmation

Quelques définitions
Un langage de programmation est destiné à décrire l'ensemble des actions
consécutives qu'un ordinateur doit exécuter. A l’instar des langages naturels
(l'anglais, le français), qui permettent à un groupe d'individus de communiquer,
le langage de programmation est une manière pratique pour les humains de
donner des ordres à un ordinateur.

Attention, les langages permettant aux ordinateurs de communiquer entre eux

n'ont rien à voir avec des langages informatiques, on parle dans ce cas de
protocoles, ce sont deux notions totalement différentes. Nous n’aborderons pas
la notion de protocole dans ce document.
Le langage utilisé par le processeur, c'est-à-dire les données telles qu'elles lui
parviennent, est appelé le langage machine (c’est une suite de 0 et de 1 encore
appelé système binaire2). Ce langage machine étant très difficilement
Bergelin MANSINSA MATUETIMONA
Ir. En Génie électrique/ informatique appliquée
compréhensible par l'humain, il est indispensable d’avoir recours à un langage
intermédiaire qui sera ensuite transformé en langage machine pour être
exploitable par le processeur. Ce langage intermédiaire est appelé le langage de
programmation.

On distingue plusieurs catégories de langages de programmation que nous allons

classifier dans les chapitres à venir.
Un programme informatique est une succession d'instructions exécutable par
l'ordinateur. La façon d'écrire un programme est très liée au langage de
programmation que l'on a choisi. D'une manière générale, le programme est un
simple fichier texte (écrit avec un traitement de texte ou un éditeur de texte), que
l'on appelle fichier source.
Le fichier source contient les lignes de programmes que l'on appelle code
source. Ce fichier source une fois terminé doit être compilé ou interprété.

II.7.1. Langages interprétés - Langages compilés

Comme nous venons de le dire, les instructions écrites dans un langage de
programmation doivent être traduites en langage machine pour être exploitable
par le processeur. Cette traduction dépend du type de langage utilisé :
 S’il s’agit d’un langage interprété, la traduction nécessite l’emploi d'un
programme auxiliaire, appelé interpréteur, qui traduit et exécute au fur
et à mesure les instructions du programme ;
 S’il s’agit d’un langage compilé, le programme est traduit une fois pour
toutes par un programme annexe, appelé compilateur, afin de générer un
nouveau fichier qui sera autonome, c'est-à-dire qui n'aura plus besoin d'un
autre programme pour s'exécuter (on parle dans ce cas de fichier
exécutable).

La compilation se déroule en deux étapes :

 Le compilateur transforme le code source en code objet puis le
sauvegarde dans un fichier objet, c'est-à-dire qu'il traduit le fichier source
en langage machine ;
 Le compilateur fait ensuite appel à un éditeur de liens (en anglais linker)
qui permet d'intégrer dans le fichier final tous les éléments annexes
(fonctions ou librairies) auxquels le programme fait référence mais qui ne
sont pas stockés dans le fichier source.
Un fichier exécutable qui contient tout ce dont il a besoin pour fonctionner de
façon autonome est créé à l’issue de la phase d’édition de liens.

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
II.7.2. Vers des langages de plus en plus évolués
Le premier langage de programmation ayant été utilisé est un langage très
proche du langage machine : l’assembleur. Il subsiste aujourd’hui encore des
programmeurs spécialisés développant des applications très spécifiques en
assembleur. Ce langage est difficilement compréhensible mais permet d’écrire
des applications extrêmement rapides. Il dépend étroitement du type de
processeur utilisé (chaque type de processeur peut avoir son propre langage
machine). Ainsi un programme développé pour une machine ne pourra pas être
« porté » sur un autre type de machine (on désigne par « portable » un
programme pouvant être utilisé sur des machines différentes). Pour pouvoir
utiliser une application écrite en assembleur sur une autre machine il faut le plus
souvent réécrire entièrement le programme. Ceci va à l’encontre des principes
de programmation enseignés aujourd’hui qui prônent au contraire la réutilisation
du code existant.

Depuis l’assembleur, beaucoup de langages de programmation ont vu le jour.

Aujourd’hui, les langages sont de plus en plus simples à utiliser, permettant une
plus grande portabilité et une plus grande facilité d’adaptation. Il est possible de
classifier ces différents langages en trois grandes familles : les langages « non
structurés », les langages « structurés », les langages « orienté objet ».

[Link] langages non structurés

On désigne par « non structuré » une suite d’actions à exécuter dans l’ordre de
leur arrivée sans se soucier de les ordonner ou de les regrouper. Le langage «
non structuré » le plus connu est le Basic.
Les langages de programmation « non structurés » sont très simples d’utilisation
mais restent limités dès que le programme devient important. A l’heure actuelle,
ils ne sont plus utilisés.

II.7.4. Les langages structurés

Les langages de programmation « structurés » permettent le regroupement
d’instructions correspondant à une action afin de ne pas répéter le code. Les
instructions sont regroupées dans un « module » appelé procédure ou fonction.
Pour différentier l’objet que l’on veut sortir du réfrigérateur il faut le préciser à
la procédure.
L’objet est appelé paramètre de la procédure. Une procédure peut avoir aucun,
un ou plusieurs paramètres.
Les langages de programmation « structurés » autorisent également la définition
de types « structures » dont nous parlerons dans le chapitre consacré à la
programmation.
Voici le même programme dans sa version structuré :

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
Un langage « structuré » permet un découpage du programme ce qui le
rend beaucoup plus lisible et beaucoup plus modulable qu’un programme
écrit en langage « non structuré »

II.8. Développer, un métier à part entière

Eh oui! Créer des logiciels, c’est un métier. D’ailleurs, il y a mêmes des écoles
et des études spécialisées pour ça. C’est que développer, ce n’est pas simplement
écrire du code. Il y a aussi des phases de réflexion, de conceptions, d’écriture, de
validation, de tests, de réécriture d’anciennes portions, etc.
Par ailleurs, même si cela n’est pas directement lié à la programmation, peut
également s’ajouter à cela: la gestion de base de données, l’usage du réseau, le
management, la gestion de projet, etc.
En bref, être développeur c’est beaucoup de compétences différentes dans
des domaines variés.
La cruelle vérité qui se cache derrière tout ça, c’est que ce cours ne fera pas de
vous des experts, ni des développeurs professionnels. Par contre, une fois fini,
vous aurez des bases solides pour continuer votre apprentissage. La route du
savoir est infinie.

Les questions spéciales :

Les mathématiques, indispensables ?
Une des grandes appréhensions, qui revient régulièrement dans la bouche des
débutants, est de savoir si les mathématiques sont un prérequis à l’apprentissage
de la programmation. La réponse est non. Il est tout à fait possible d’apprendre
à programmer tout en ayant un faible niveau en mathématique. Ce cours ne
demande aucune connaissance en mathématiques plus poussées que les
opérations de base et, quelques fois, l’utilisation de sinus et cosinus, en guise
d’exemples.
Bergelin MANSINSA MATUETIMONA
Ir. En Génie électrique/ informatique appliquée
Bien sûr, certains aspects de la programmation, comme la sécurité, la
cryptographie ou les applications scientifiques vont demander un bagage
mathématique solide. Mais cela ne rentre pas dans le cadre de ce cours.

L’anglais, indispensable ?
À strictement parler, dans le cadre de ce cours, pas besoin de savoir parler
anglais.
Et quand bien même il y aurait quelque chose sur lequel vous butez, vous
pouvez vous servir d’un traducteur automatique.
D’un point de vue plus général, si vous souhaitez continuer dans l’informatique
et la programmation, il sera très difficile d’échapper à l’anglais. Beaucoup de
cours, de documents, de forums sont en anglais, ou en font un usage massif.
L’anglais est tout simplement la langue de l’informatique. Après, sachez que
l’anglais informatique est simple à comprendre, car souvent écris par des gens
dont l’anglais n’est pas la langue maternelle. Ainsi, inutile d’être bilingue, un
bon dictionnaire ou un traducteur vous aideront.

II.9. Un éditeur de texte

Ce choix est le vôtre et peut-être que vous en avez déjà un qui vous convient très
bien. Si c’est le cas, très bien, continuez dessus. Sinon, choisissez un éditeur de
texte qui au moins possède la coloration syntaxique, c’est à dire la capacité de
changer la couleur du texte en fonction de ce qu’un mot signifie. Parmi les plus
connus, on peut citer Visual Studio Code , Atom ou encore Sublime Text .

[Link] le programme
Allez donc sur Code :block , ou bien ouvrez votre projet C, et copiez-collez ce
code dans la zone de texte.
À la fin des étapes de l'assistant, le projet est créé et contient un premier fichier.
Déployez l'arborescence à gauche pour voir apparaître le fichier [Link] et
faites un double-clic dessus pour l'ouvrir. Ce fichier est notre premier code
source et il est déjà un peu rempli (figure suivante) !

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
Notez que la ligne :

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
Analysons le code minimal

Ce sont des lignes spéciales que l'on ne voit qu'en haut des fichiers source. Ces
lignes sont facilement reconnaissables car elles commencent par un dièse #. Ces
lignes spéciales, on les appelle directives de préprocesseur .
Ce sont des lignes qui seront lues par un programme appelé préprocesseur, un
programme qui se lance au début de la compilation.
Oui : comme je vous l'ai dit plus tôt, ce qu'on a vu au début n'était qu'un schéma
très simplifié de la compilation. Il se passe en réalité plusieurs choses pendant
une compilation. On les détaillera plus tard : pour le moment, vous avez juste
besoin d'insérer ces lignes en haut de chacun de vos fichiers.

Le mot include en anglais signifie « inclure » en français. Ces lignes demandent

d'inclure des fichiers au projet, c'est-à-dire d'ajouter des fichiers pour la
compilation.
Il y a deux lignes, donc deux fichiers inclus. Ces fichiers s'appellent stdio.h et
stdlib.h. Ces fichiers existent déjà, des fichiers source tout prêts. On verra plus
tard qu'on les appelle des bibliothèques (certains parlent aussi de librairies mais
c'est un anglicisme). En gros, ces fichiers contiennent du code tout prêt qui
permet d'afficher du texte à l'écran.
Sans ces fichiers, écrire du texte à l'écran aurait été mission impossible.
L'ordinateur à la base ne sait rien faire, il faut tout lui dire.
Bref, en résumé les deux premières lignes incluent les bibliothèques qui vont
nous permettre (entre autres) d'afficher du texte à l'écran assez « facilement ».
Passons à la suite. La suite, c'est tout ça :

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
Ce que vous voyez là, c'est ce qu'on appelle une fonction. Un programme en
langage C est constitué de fonctions, il ne contient quasiment que ça. Pour le
moment, notre programme ne contient donc qu'une seule fonction.
Une fonction permet grosso modo de rassembler plusieurs commandes à
l'ordinateur. Regroupées dans une fonction, les commandes permettent de faire
quelque chose de précis. Par exemple, on peut créer une fonction ouvrir_fichier
qui contiendra une suite d'instructions pour l'ordinateur lui expliquant comment
ouvrir un fichier.
L'avantage, c'est qu'une fois la fonction écrite, vous n'aurez plus qu'à dire
ouvrir_fichier, et votre ordinateur saura comment faire sans que vous ayez à tout
répéter !
C'est un nom de fonction particulier qui signifie « principal ». main est la
fonction principale de votre programme, c'est toujours par la fonction main
que le programme commence.
Une fonction a un début et une fin, délimités par des accolades { et }. Toute la
fonction main se trouve donc entre ces accolades. Si vous avez bien suivi, notre
fonction main contient deux lignes :

Ces lignes à l'intérieur d'une fonction ont un nom. On les appelle instructions (ça
en fait du vocabulaire qu'il va falloir retenir).

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
Chaque instruction est une commande à l'ordinateur. Chacune de ces lignes
demande à l'ordinateur de faire quelque chose de précis.
return 0; Eh bien ça, en gros, ça veut dire que c'est fini (eh oui, déjà). Cette
ligne indique qu'on arrive à la fin de notre fonction main et demande de
renvoyer la valeur 0.

Écrire un message à l'écran

À partir de maintenant, on va modifier nous-mêmes le code de ce programme
minimal.
Votre mission, si vous l'acceptez : afficher le message « Bonjour » à l'écran.

Les caractères spéciaux

Les caractères spéciaux sont des lettres spéciales qui permettent d'indiquer qu'on
veut aller à la ligne, faire une tabulation, etc.
Ils sont faciles à reconnaître : c'est un ensemble de deux caractères. Le premier
d'entre eux est toujours un anti-slash ( \ ), et le second un nombre ou une lettre.
Voici deux caractères spéciaux courants que vous aurez probablement besoin
d'utiliser, ainsi que leur signification :
 \n : retour à la ligne (= « Entrée ») ;
 \t : tabulation.

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
[Link]. LES LITTERAUX ET LES VARIABLE

[Link]
Vous savez désormais afficher des messages à l’écran. C’est un bon début, mais
on est quand même assez limités, n’est-ce pas? Rassurez-vous, C nous permet de
faire bien plus que ça. Grâce à ce langage, nous allons nous amuser avec ce
super calculateur qu’est notre ordinateur et nous découvrirons qu’il possède
aussi une super mémoire!
Ce chapitre va nous faire découvrir les littéraux et les variables.

III.2. Les littéraux

Que sont les littéraux? Une valeur écrite littéralement dans le code, d’où son
nom. Nous avons rencontré un littéral dans le chapitre précédent: "Hello World
!". Ce littéral est ce qu’on appelle une chaîne de caractères. Mais ce n’est pas
le seul littéral possible en C.
Les caractères
Nous avons fait connaissance avec les chaînes de caractères lors du chapitre
précédent. Les chaînes de caractères ne sont rien d’autre que du texte. On les
reconnait parce qu’elles commencent et finissent par des doubles guillemets ".
[Link] variables
Les variables permettent d'utiliser la mémoire de l'ordinateur afin de stocker une
information pour pouvoir la réutiliser plus tard.
C’est un concept commun à beaucoup de langages de programmation qui permet
de stocker une valeur et de lui associer un nom, afin de faciliter tant l’écriture
que la lecture du code. On peut les voir comme des enveloppes, des tiroirs, des
conteneurs, bref, une zone où est stockée une valeur, à laquelle on associe un
nom.
Toutes les variables sont stockées dans la mémoire vive de l’ordinateur, la
RAM. Son fonctionnement est un peu complexe et ne nous intéresse pas (dans le
cadre de ce cours tout du moins). Les curieux trouveront beaucoup de ressources
sur Internet pour combler leur soif de savoir, allant de la vulgarisation simple à
des explications complètes.

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
III.2.1. Déclaration d’une variable
Alors une variable, c'est quoi ?
Eh bien c'est une petite information temporaire qu'on stocke dans la RAM. Tout
simplement.
On dit qu'elle est « variable » car c'est une valeur qui peut changer pendant le
déroulement du programme. Par exemple, notre nombre 5 de tout à l'heure (le
nombre de vies restant au joueur) risque de diminuer au fil du temps. Si ce
nombre atteint 0, on saura que le joueur a perdu.
En langage C, une variable est constituée de deux choses :
 D’abord, un type, qui indique ce que la variable va stocker (un entier, une
chaîne de caractères, etc).
 un nom : c'est ce qui permet de la reconnaître.
 une valeur : c'est le nombre qu'elle stocke, par exemple 5 ;
Hélas, il y a quelques contraintes. Vous ne pouvez pas appeler une variable
n'importe comment :
 il ne peut y avoir que des minuscules, majuscules et des chiffres
(abcABC012) ;
 votre nom de variable doit commencer par une lettre ;
 les espaces sont interdits. À la place, on peut utiliser le caractère «
underscore » _ (qui ressemble à un trait de soulignement). C'est le seul
caractère différent des lettres et chiffres autorisé ;
 vous n'avez pas le droit d'utiliser des accents (éàê etc.).
III.2.2. Types de variables
Les types de base en C concernent les caractères, les entiers et les flottants
(nombres réels).
Ils sont d´désignés par les mots-clefs suivants :

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
Bon bref, vous avez compris le principe je pense !
Ce qu'on fait là s'appelle une déclaration de variable (un vocabulaire à retenir).
Vous devez faire les déclarations de variables au début des fonctions. Comme
pour le moment on n'a qu'une seule fonction (la fonction main), vous allez
déclarer la variable comme ceci :

III.2.3. Affecter une valeur à une variable

C'est tout ce qu'il y a de plus bête. Si vous voulez donner une valeur à la variable
nombreDeVies, il suffit de procéder comme
ceci :

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
[Link]
Il permet d’empêcher toute modification de la variable sur laquelle ce mot-clé
s’applique. On dit qu’on crée une constante. Et si l’on essaye de modifier une
constante, le compilateur refuse clair et net.
Pour déclarer une constante, c'est en fait très simple : il faut utiliser le mot const
juste devant le type quand vous déclarez votre variable. Par ailleurs, il faut
obligatoirement lui donner une valeur au moment de sa déclaration comme on
vient d'apprendre à le faire. Après, il sera trop tard : vous ne pourrez plus
changer la valeur de la constante.
Exemple de déclaration de constante :

Variable chaîne des caractères en C

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
III.3. Les entrées-sorties
[Link] le contenu d'une variable
On sait afficher du texte à l'écran avec la fonction printf.
Maintenant, on va voir comment afficher la valeur d'une variable avec cette
même fonction.
On utilise en fait printf de la même manière, sauf que l'on rajoute un symbole
spécial à l'endroit où l'on veut afficher la valeur de la variable. Par exemple :

Ce « symbole spécial » dont je viens de vous parler est en fait un '% suivi d'une
lettre (dans mon exemple, la lettre 'd'). Cette lettre permet d'indiquer ce que l'on
doit afficher. 'd' signifie que l'on souhaite afficher un int.
Il existe plusieurs autres possibilités, mais pour des raisons de simplicité on va
se contenter de retenir celles-ci :

On a presque fini. On a indiqué qu'à un endroit précis on voulait afficher un

nombre entier, mais on n'a pas précisé lequel ! Il faut donc indiquer à la fonction
printf quelle est la variable dont on veut afficher la valeur.
Pour ce faire, vous devez taper le nom de la variable après les guillemets et
après avoir rajouté une virgule, comme ceci :

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
Le %d sera remplacé par la variable indiquée après la virgule, à savoir
nombreDeVies.
On se teste ça dans un programme ?

Afficher plusieurs variables dans un même printf

Il est possible d'afficher la valeur de plusieurs variables dans un seul printf. Il
vous suffit pour cela d'indiquer des %d ou des %f là où vous voulez, puis
d'indiquer les variables correspondantes dans le même ordre, séparées par des
virgules.

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
III.3.2. Récupérer une saisie
Les variables vont en fait commencer à devenir intéressantes maintenant. On va
apprendre à demander à l'utilisateur de taper un nombre dans la console. Ce
nombre, on va le récupérer et le stocker dans une variable.
Une fois que ça sera fait, on pourra faire tout un tas de choses avec, vous verrez.
Pour demander à l'utilisateur d'entrer quelque chose dans la console, on va
utiliser une autre fonction toute prête : scanf.
Cette fonction ressemble beaucoup à printf. Vous devez mettre un format pour
indiquer ce que l'utilisateur doit entrer (un int, un float, ...). Puis vous devez
ensuite indiquer le nom de la variable qui va recevoir le nombre.
Voici comment faire par exemple :

On doit mettre le %d entre guillemets.

Par ailleurs, il faut mettre le symbole & devant le nom de la variable qui va
recevoir la valeur.

Voici un petit programme simple qui demande l'âge de l'utilisateur et qui le lui
affiche ensuite :

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
[Link] calculs de base

Il faut savoir qu'en plus de n'être qu’un vulgaire calculateur, votre ordinateur est
une calculatrice très basique puisqu'on ne peut faire que des opérations très
simples :

 addition ;
 soustraction;
 multiplication ;
 division ;
 modulo

Si vous voulez faire des opérations plus compliquées (des carrés, des puissances,
des logarithmes et autres joyeusetés) il vous faudra les programmer, c'est-à-dire
expliquer à l'ordinateur comment les faire.
Fort heureusement, nous verrons plus loin dans ce chapitre qu'il existe une
bibliothèque mathématique livrée avec le langage C qui contient des fonctions
mathématiques toutes prêtes. Vous n'aurez donc pas à les réécrire, à moins que
vous souhaitiez volontairement passer un sale quart d'heure (ou que vous soyez
prof de maths).

Voyons donc l'addition pour commencer.

Pour faire une addition, on utilise le signe + (sans blague !).
Vous devez mettre le résultat de votre calcul dans une variable. On va donc par
exemple créer une variable resultat de type
int et faire un calcul :

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
Pour les autres opérations, c'est la même chose, seul le signe utilisé change (voir
tab. suivante).

La division
Les divisions fonctionnent normalement sur un ordinateur quand il n'y a pas de
reste. Par exemple, 6 / 3 font 2, votre ordinateur vous donnera la réponse juste.
Jusque-là pas de souci.
Mais prenons maintenant une division avec reste comme 5 / 2… Le résultat
devrait être 2.5. Et pourtant !

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
Si on veut que l'ordinateur affiche le bon résultat, il va falloir transformer les
nombres 5 et 2 de l'opération en nombres décimaux, c'est-à-dire écrire 5.0 et 2.0
(ce sont les mêmes nombres, mais l'ordinateur considère que ce sont des
nombres décimaux, donc il fait une division de nombres décimaux) :

Le modulo
Le modulo est une opération mathématique qui permet d'obtenir le reste d'une
division. C'est peut-être une opération moins connue que les quatre autres, mais
pour votre ordinateur ça reste une opération de base… probablement pour
justement combler
le problème de la « division d'entiers » qu'on vient de voir.
Le modulo, je vous l'ai dit tout à l'heure, se représente par le signe %.

Voici quelques exemples de modulos :

5%2=1;
14 % 3 = 2 ;
Bergelin MANSINSA MATUETIMONA
Ir. En Génie électrique/ informatique appliquée
4 % 2 = 0.
Le modulo 5 % 2 est le reste de la division 5 / 2, c'est-à-dire 1. L'ordinateur
calcule que 5 = 2 * 2 + 1 (c'est ce 1, le reste, que le modulo renvoie).
De même, 14 % 3, le calcul est 14 = 3 * 4 + 2 (modulo renvoie le 2).
Enfin, pour 4 % 2, la division tombe juste, il n'y a pas de reste, donc modulo
renvoie 0.
Voilà, il n'y a rien à ajouter au sujet des modulos. Je tenais juste à l'expliquer à
ceux qui ne connaîtraient pas.

Des calculs entre variables

Ce qui serait intéressant, maintenant que vous savez faire les cinq opérations de
base, ce serait de s'entraîner à faire des calculs
entre plusieurs variables.
En effet, rien ne vous empêche de faire :

Et c'est là que les choses commencent à devenir très intéressantes. Tenez, il me

vient une idée. Vous avez maintenant déjà le niveau pour réaliser une mini-
calculatrice.
Voire Travail dirigé…

L'incrémentation

Vous verrez que vous serez souvent amenés à ajouter 1 à une variable. Au fur et
à mesure du programme, vous aurez des variables qui augmentent de 1 en 1.
Imaginons que votre variable s'appelle nombre (nom très original, n'est-ce pas
?). Sauriez-vous comment faire pour ajouter 1 à cette variable, sans savoir quel
est le nombre qu'elle contient ?
Voici comment on doit faire :

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
Que se passe-t-il ici ? On fait le calcul nombre + 1, et on range ce résultat dans
la variable… nombre ! Du coup, si notre variable nombre valait 4, elle vaut
maintenant 5. Si elle valait 8, elle vaut maintenant 9, etc.
Cette opération est justement répétitive. Les informaticiens étant des gens
particulièrement fainéants, ils n'avaient guère envie de taper deux fois le même
nom de variable (ben oui quoi, c'est fatigant !).
Ils ont donc inventé un raccourci pour cette opération qu'on appelle
l'incrémentation. Cette instruction produit exactement le même résultat que le
code qu'on vient de voir :

La décrémentation
C'est tout bêtement l'inverse de l'incrémentation : on enlève 1 à une variable.
Même si on fait plus souvent des incrémentations que des décrémentations, cela
reste une opération pratique que vous utiliserez de temps en temps.
La décrémentation, si on l'écrit en forme « longue » :

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
La bibliothèque mathématique

En langage C, il existe ce qu'on appelle des bibliothèques « standard », c'est-à-

dire des bibliothèques toujours utilisables. Ce sont en quelque sorte des
bibliothèques « de base » qu'on utilise très souvent.
Les bibliothèques sont, je vous le rappelle, des ensembles de fonctions toutes
prêtes. Ces fonctions ont été écrites par des programmeurs avant vous, elles vous
évitent en quelque sorte d'avoir à réinventer la roue à chaque nouveau
programme.
Vous avez déjà utilisé les fonctions printf et scanf de la bibliothèque stdio.h.
Il faut savoir qu'il existe une autre bibliothèque, appelée math.h, qui contient de
nombreuses fonctions mathématiques toutes prêtes.

Pour pouvoir utiliser les fonctions de la bibliothèque mathématique, il est

indispensable de mettre la directive de préprocesseur suivante en haut de votre
programme :

Une fois que c'est fait, vous pouvez utiliser toutes les fonctions de cette
bibliothèque.

fabs
Cette fonction retourne la valeur absolue d'un nombre, c'est-à-dire |x| (c'est la
notation mathématique).
La valeur absolue d'un nombre est sa valeur positive :
si vous donnez -53 à la fonction, elle vous renvoie 53 ;
si vous donnez 53 à la fonction, elle vous renvoie 53.
En bref, elle renvoie toujours l'équivalent positif du nombre que vous lui
donnez.

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
Cette fonction renvoie un double, donc votre variable absolu doit être de type
double.

ceil
Cette fonction renvoie le premier nombre entier après le nombre décimal qu'on
lui donne. C'est une sorte d'arrondi. On arrondit en
fait toujours au nombre entier supérieur.
Par exemple, si on lui donne 26.512, la fonction renvoie 27.
Cette fonction s'utilise de la même manière et renvoie un double :

floor
C'est l'inverse de la fonction précédente : cette fois, elle renvoie le nombre
directement en dessous.
Si vous lui donnez 37.91, la fonction floor vous renverra donc 37.
pow
Cette fonction permet de calculer la puissance d'un nombre. Vous devez lui
indiquer deux valeurs : le nombre et la puissance à laquelle vous voulez l'élever.
Voici le schéma de la fonction :

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
Vous pouvez donc utiliser cette fonction pour calculer des carrés. Il suffit
d'indiquer une puissance de 2.

sqrt
Cette fonction calcule la racine carrée d'un nombre. Elle renvoie un double.

sin, cos, tan

Ce sont les trois fameuses fonctions utilisées en trigonométrie.
Le fonctionnement est le même, ces fonctions renvoient un double.
Ces fonctions attendent une valeur en radians.
asin, acos, atan
Ce sont les fonctions arc sinus, arc cosinus et arc tangente, d'autres fonctions de
trigonométrie.
Bergelin MANSINSA MATUETIMONA
Ir. En Génie électrique/ informatique appliquée
Elles s'utilisent de la même manière et renvoient un double.
Exp Cette fonction calcule l'exponentielle d'un nombre. Elle renvoie un double
(oui, oui, elle aussi).
Log Cette fonction calcule le logarithme népérien d'un nombre (que l'on note
aussi « ln »).
log10
Cette fonction calcule le logarithme base 10 d'un nombre.

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
CHAPITRE IV. LES STRUCTURES DE CONTROLE

IV.1. Introduction
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.
Ce nom cache en fait deux éléments suivant :
 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.
Savoir manier les structures de contrôle est fondamental ! Bien que ce chapitre
ne soit pas réellement difficile, il faut faire attention à bien comprendre ces
notions de base. Elles vous serviront durant toute votre vie de développeurs C
mais aussi dans d'autres langages car le principe y est le même !

[Link] conditions
Pour qu'un programme soit capable de prendre des décisions, on utilise dans le
code source des conditions (on parle aussi de « structures conditionnelles »). Le
principe est simple : vous voulez que votre programme réagisse différemment en
fonction des circonstances. Nous allons découvrir ici comment utiliser ces
fameuses conditions dans nos programmes C.
Pour commencer, il faut savoir que les conditions permettent de tester des
variables. Vous vous souvenez de ces variables stockées en mémoire que nous
avons découvertes précédement ? Eh bien nous allons maintenant apprendre à
les analyser : « Est-ce que cette variable est supérieure à 10 ? », « Est-ce que
cette variable contient bien le mot de passe secret ? », etc.
Pour effectuer ces tests, nous utilisons des symboles. Voici le tableau des
symboles à connaître par coeur :

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
[Link] condition if

Maintenant, examinons la façon de poser une question en C, si l’on peut dire.

Nous allons en effet découvrir la première structure de contrôle: if. Ce mot-clef
est un mot anglais signifiant «si», et exécute des instructions si, et seulement si
la condition donnée est vraie. Voyez donc ce schéma.

À la place de mon commentaire « Votre condition », on va écrire une condition

pour tester une variable.
Par exemple, on pourrait tester une variable age qui contient votre âge. Tenez
pour s'entraîner, on va tester si vous êtes majeur,
c'est-à-dire si votre âge est supérieur ou égal à 18 :

La variable age vaut 20, donc le « Vous êtes majeur ! » s'affichera.

Essayez de changer la valeur initiale de la variable pour voir. Mettez par
exemple 15 : la condition sera fausse, et donc « Vous êtes majeur ! » ne
s'affichera pas cette fois.

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
[Link] : ce qu'il faut faire si la condition n'est pas vérifiée
Le else pour dire « sinon »
Maintenant que nous savons faire un test simple, allons un peu plus loin : si le
test n'a pas marché (il est faux), on va dire à l'ordinateur d'exécuter d'autres
instructions.
En français, nous allons donc écrire quelque chose qui ressemble à cela :

Les choses sont assez simples : si la variable age est supérieure ou égale à 18, on
affiche le message « Vous êtes majeur ! », sinon on affiche « Vous êtes mineur
».

[Link] if : effectuer un autre test

Il est possible de faire plusieurs tests à la suite.
On a vu comment faire un « si » et un « sinon ». Il est possible aussi de faire un
« sinon si » pour faire un autre test si le premier test n'a pas marché. Le « sinon
si » se place entre le if et le else.
On dit dans ce cas à l'ordinateur :

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
L'ordinateur fait les tests dans l'ordre.
1. D'abord il teste le premier if : si la condition est vraie, alors il exécute ce
qui se trouve entre les premières accolades.
2. Sinon, il va au « sinon si » et fait à nouveau un test : si ce test est vrai,
alors il exécute les instructions correspondantes entre accolades.
3. Enfin, si aucun des tests précédents n'a marché, il exécute les instructions
du « sinon ».

[Link] des conditions

Il peut aussi être utile de faire plusieurs tests à la fois dans votre if. Par exemple,
vous voudriez tester si l'âge est supérieur à 18
ET si l'âge est inférieur à 25.
Pour faire cela, il va falloir utiliser de nouveaux symboles :

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
Test ET
Si on veut faire le test que j'ai mentionné plus haut, il faudra écrire :

Test OU
Pour faire un OU, on utilise les deux signes ||.

Test NON
Le dernier symbole qu'il nous reste à tester est le point d'exclamation. En
informatique, le point d'exclamation signifie « non ».
Vous devez mettre ce signe avant votre condition pour dire « si cela n'est pas
vrai » :

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
Les booléens
Vous vous souvenez du type bool ? Ce type de données peut stocker deux
valeurs :
1. true (vrai) ;
2. false (faux).
Ce type est souvent utilisé avec les conditions. Quand on y pense, c'est logique :
une condition est soit vraie, soit fausse. Une variable booléenne aussi.
Si je vous parle du type bool, c'est parce qu'on peut l'utiliser d'une façon un peu
particulière dans les conditions.

[Link] condition switch

La condition if... else que l'on vient de voir est le type de condition le plus
souvent utilisé.
En fait, il n'y a pas 36 façons de faire une condition en C. Le if... else permet de
gérer tous les cas.
Toutefois, le if... else peut s'avérer quelque peu… répétitif. Prenons cet exemple
:

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
Alors, pour éviter d'avoir à faire des répétitions comme ça quand on teste la
valeur d'une seule et même variable, ils ont inventé
une autre structure que le if... else. Cette structure particulière s'appelle switch.
Voici un switch basé sur l'exemple
qu'on vient de voir :

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
L'idée c'est donc d'écrire switch (maVariable) pour dire « je vais tester la valeur
de la variable maVariable ». Vous ouvrez ensuite des accolades que vous
refermez tout en bas.
Ensuite, à l'intérieur de ces accolades, vous gérez tous les cas : case 2, case 4,
case 5, case 45…
Enfin, le cas default correspond en fait au else qu'on connaît bien maintenant. Si
la variable ne vaut aucune des valeurs précédentes, l'ordinateur ira lire le
default.

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
[Link] boucles
Après avoir vu comment réaliser des conditions en C, nous allons découvrir les
boucles. Qu'est-ce qu'une boucle ? C'est une technique permettant de répéter les
mêmes instructions plusieurs fois. Cela nous sera bien utile par la suite,

Qu'est-ce qu'une boucle ?

Je me répète : une boucle est une structure qui permet de répéter les mêmes
instructions plusieurs fois.
Tout comme pour les conditions, il y a plusieurs façons de réaliser des boucles.
Au bout du compte, cela revient à faire la même
chose : répéter les mêmes instructions un certain nombre de fois.
Nous allons voir trois types de boucles courantes en C :
 while
 do… while
 for
Dans tous les cas, le schéma est le même (fig. suivante).

Voici ce qu'il se passe dans l'ordre :

1. L'ordinateur lit les instructions de haut en bas (comme d'habitude) ;
2. Puis, une fois arrivé à la fin de la boucle, il repart à la première instruction
;
3. Il recommence alors à lire les instructions de haut en bas…
4. . … Et il repart au début de la boucle.

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
Le problème dans ce système c'est que si on ne l'arrête pas, l'ordinateur est
capable de répéter les instructions à l'infini !
Et c'est là qu'on retrouve… les conditions ! Quand on crée une boucle, on
indique toujours une condition. Cette condition signifiera « Répète la boucle tant
que cette condition est vraie ».
[Link] — Tant que…
Commençons cette leçon avec une boucle while. En toute originalité, ce mot-
clef est aussi un mot anglais qui signifie «tant que». Elle exécute une série
d’instructions tant que la condition est vraie. Par contre, dès que la condition
est évaluée à false, la boucle s’arrête. On dit aussi qu’on boucle ou qu’on itère.
Voici comment on construit une boucle while :

C'est aussi simple que cela. while signifie « Tant que ». On dit donc à
l'ordinateur « Tant que la condition est vraie, répète les instructions entre
accolades ».
Je vous propose de faire un test simple : on va demander à l'utilisateur de taper
le nombre 47. Tant qu'il n'a pas tapé le nombre 47, on lui redemande le nombre.
Le programme ne pourra s'arrêter que si l'utilisateur tape le nombre 47 (je sais,
je sais, je suis diabolique) :

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
Le programme s'est arrêté après avoir tapé le nombre 47.
Cette boucle while se répète donc tant que l'utilisateur n'a pas tapé 47, c'est assez
simple.
Maintenant, essayons de faire quelque chose d'un peu plus intéressant : on veut
que notre boucle se répète un certain nombre de fois.
On va pour cela créer une variable compteur qui vaudra 0 au début du
programme et que l'on va incrémenter au fur et à mesure. Vous vous souvenez
de l'incrémentation ? Ça consiste à ajouter 1 à la variable en faisant variable++.
Regardez attentivement ce bout de code et, surtout, essayez de le comprendre :

On pourrait d'ailleurs voir que la variable compteur augmente au fur et à mesure

dans la boucle, en l'affichant dans le printf.

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
[Link] boucle do… while
Ce type de boucle est très similaire à while, bien qu'un peu moins utilisé en
général.
La seule chose qui change en fait par rapport à while, c'est la position de la
condition. Au lieu d'être au début de la boucle, la condition est à la fin :

Qu'est-ce que ça change ?

C'est très simple : la boucle while pourrait très bien ne jamais être exécutée si la
condition est fausse dès le départ. Par exemple, si on avait initialisé le compteur
à 50, la condition aurait été fausse dès le début et on ne serait jamais rentré dans
la boucle.
Pour la boucle do… while, c'est différent : cette boucle s'exécutera toujours
au moins une fois. En effet, le test se fait à la fin comme vous pouvez le voir. Si
on initialise compteur à 50, la boucle s'exécutera une fois.
Il est donc parfois utile de faire des boucles de ce type, pour s'assurer que l'on
rentre au moins une fois dans la boucle.
[Link] boucle for
En théorie, la boucle while permet de réaliser toutes les boucles que l'on veut.
Toutefois, tout comme le switch pour les conditions, il est dans certains cas utile
d'avoir un autre système de boucle plus «condensé », plus rapide à écrire.
Les boucles for sont très très utilisées en programmation. Je n'ai pas de
statistiques sous la main, mais sachez que vous utiliserez certainement autant de

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
for que de while, si ce n'est plus, il vous faudra donc savoir manipuler ces deux
types de boucles.
Ce type de boucle, que l'on retrouve fréquemment, permet de condenser :
 une initialisation ;
 une condition ;
 une incrémentation.

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée
Bibliographie

1. Dominus Karn, Les bases de la programmation, juillet

2020
2. Karl Tombre, Introduction à la programmation, 2021
3. Mathieu Nebra, Apprendre à programmer en C, 2013.
4. Anne CANTEAUT, Programmation en C, 2019.
5. Maude Manouvrier, Langage C, 2021.
6. Claude Delannoy, Programmer en langage C, 2022.

Bergelin MANSINSA MATUETIMONA

Ir. En Génie électrique/ informatique appliquée