From 692a589485221f0dc709d7a166a8d01a6fed6734 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicolas=20M=2E=20Thi=C3=A9ry?= <nthiery@users.sf.net>
Date: Sat, 25 Nov 2023 10:20:19 +0100
Subject: [PATCH] =?UTF-8?q?Pr=C3=A9paration?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.gradebook.db | Bin 192512 -> 192512 bytes
cours-conclusion.md | 42 +++---
cours-cycle-de-vie-d-un-programme.md | 106 ++++++++------
cours-digressions.md | 133 +++++++++--------
cours-modularite.md | 209 ++++++++++++++-------------
5 files changed, 252 insertions(+), 238 deletions(-)
diff --git a/.gradebook.db b/.gradebook.db
index 9694c62cb10f33fad562eff4a10497013d6111a2..61ec976c84dc4e896e73739ea2b26103deed93e1 100644
GIT binary patch
delta 747
zcmZ{heMl5R7{+I2XTN4Y<}R!w4P5d3M7irjqYw&;2=XW?DGI`%5TfFO3N9&c3o6O`
z*p|48Xj6!+Kv_>*`Xj9nLLm@BGDNrvir~l$`Xkb6_lPK>`SCIX@5A%V%p1>1@tl+{
zQQ`oAkXtowA)|UNjN5H}oj&=P^ipc3?dl`7T)8SQ*!mhN+kANtLdE>ieT|p7NFbss
z=5b3iM-uH&GAonUAu%5(??KT#oXP~~Rv@TDfF7ac)KFikL+W=rLx*ksriz111e(#5
z#)^g0{9DajytNIxR|p!qR%mBlH$lw}J8A`4xuB{`YHo~U1(y?|=3Vm;P!G}FYKT6h
z=V+PwL`~RwKxG?nz3ZM%g$1z+`y+7IW)lu*W_N#^7tmnnE6sd=1E<vDfU6rxR6yB`
z3^a1m7Q8(IGdH?WnR$OegQVA|4Qkkz#ks{$37rQVopudCh<>Aa`kua_vvk@c>-UY)
z%uFdP>Z~qv1;kSoR@Dk3zW|kdE0BxHc_|>?;m3q$f=c!aXZX{iU&u>e$aCodS;v2n
zH;5C`1#utg6IS!B(gC4YoRbeqlfoX}lA6RuF;0r)e)3uF`aetlZQ1%1=d@PAv#k4i
zrry?Tm}P{_fl3quXdaED9u(t}cq22BsSd;NdZCBJ@Gz5N>u?9R^H1oG-z=qnp?vhP
z^{>#0t%9cnH;MJzy21`mLKwaaqwrHHKMOe20r+x8AmgGew4e?~@BpJ8hHg2dZRjM#
z;$F~c=$kTQ7g55oqG$?xV>@B!QK#h+ddl+_DBu*Q(K{;t`f2FyweBG1Xjb#(sFAL?
M62=a`jTW~51YvB>-2eap
delta 7801
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
D1MN!4
diff --git a/cours-conclusion.md b/cours-conclusion.md
index e1d3896..f50869b 100644
--- a/cours-conclusion.md
+++ b/cours-conclusion.md
@@ -33,30 +33,29 @@ rise:
## Résumé de la séance
-**Programmes et compilation :**
-
+:::{admonition} Programmes et compilation
- Algorithme, programme, sources, binaire, assembleur
- Interpréteur, compilateur
- Cycle de vie d'un programme
+:::
+++ {"slideshow": {"slide_type": "fragment"}}
-**Compilation séparée pour la modularité :**
-
+:::{admonition} Compilation séparée pour la modularité
- Découper un programme non seulement en fonctions, mais en fichiers
-
-- Bibliothèque de fonctions réutilisables entre programmes
+- Définir des bibliothèque de fonctions réutilisables entre programmes :
- fichier d'entêtes : `max.hpp`
- fichier source : `max.cpp`
- fichier de tests : `maxTest.cpp`
+:::
+++ {"slideshow": {"slide_type": "fragment"}}
-**Digressions :**
-
+:::{admonition} Digressions
- Surcharge : un nom, plusieurs fonctions
- Templates : une fonction, plusieurs types
-- Espaces de noms
+- Espaces de noms : pour éviter les conflits de noms
+:::
+++ {"slideshow": {"slide_type": "slide"}}
@@ -64,14 +63,14 @@ rise:
+++ {"slideshow": {"slide_type": "fragment"}}
-**Développement incrémental :**
-
+:::{hint} Bonne pratique : développement incrémental
- Toujours être «proche de quelque chose qui marche»
- Gestion de version (`git`, `mercurial`, ...)
+:::
+++ {"slideshow": {"slide_type": "fragment"}}
-**Spécifications et tests :**
+:::{admonition} Bonnes pratiques : spécifications et tests
- Spécification : définir précisément la sémantique des fonctions :
qu'est-ce qu'elles doivent faire?
@@ -80,38 +79,39 @@ rise:
+++ {"slideshow": {"slide_type": "fragment"}}
-**Modularité :**
-
+:::{hint} Bonne pratique : modularité
- Découpage d'un programme en fonctions : [**cours 4**](../Semaine4/cours.md)
- Découpage d'un programme en modules : **aujourd'hui !**
-- Découpage d'un programme en espace de noms : **plus tard**
+- Découpage d'un programme en espaces de noms : **plus tard**
+:::
+++ {"slideshow": {"slide_type": "slide"}}
-### Conclusion : qu'avez-vous vu ce semestre?
+### Conclusion : qu'avons nous vu ce semestre?
+++ {"slideshow": {"slide_type": "fragment"}}
-**Les bases de la programmation impérative**
-
+:::{admonition} Les bases de la programmation
- Contrôle du flot d'exécution : instructions conditionnelles et itératives, fonctions
- Gestion des données : variables, tableaux, collections, entrées et sorties, fichiers
+:::
+++ {"slideshow": {"slide_type": "fragment"}}
-**Méthodologie de développement**
+:::{admonition} Méthodologie de développement
- Développement incrémental
- Spécifications et tests
- Modularité
+:::
+++ {"slideshow": {"slide_type": "fragment"}}
-**Une esquisse de quelques thèmes de l'informatique**
-
+:::{admonition} Une esquisse de quelques thèmes de l'informatique
- Programmation modulaire (S2)
- Algorithmes et structures de données, complexité (S2)
- Science des données (S2)
- Web, graphisme, architecture, réseau, ...
+:::
+++ {"slideshow": {"slide_type": "fragment"}}
diff --git a/cours-cycle-de-vie-d-un-programme.md b/cours-cycle-de-vie-d-un-programme.md
index ce5a6bd..f7beded 100644
--- a/cours-cycle-de-vie-d-un-programme.md
+++ b/cours-cycle-de-vie-d-un-programme.md
@@ -29,21 +29,19 @@ rise:
## Revenons à la recette de la mousse au chocolat
-**Ingrédients :**
-
+:::{admonition} Ingrédients
+:icon: false
250 g de chocolat, 125 g de beurre, 6 œufs, 50 g de sucre, café
+:::
-**Étapes :**
-
+:::{admonition} Étapes
+:icon: false
- Faire fondre le chocolat avec deux cuillères d'eau
-
- Ajouter le beurre, laisser refroidir puis ajouter les jaunes
-
- Ajouter le sucre et comme parfum un peu de café
-
- Battre les blancs jusqu'Ã former une neige uniforme
-
- Ajouter au mélange
+:::
+++ {"slideshow": {"slide_type": "fragment"}}
@@ -53,9 +51,11 @@ rise:
Pour répondre à cette question, revenons à la définition :
-**Programme** (rappel) : séquence d'**instructions** qui spécifie,
+:::{prf:definition} **Programme** (rappel)
+Séquence d'**instructions** qui spécifie,
étape par étape, les opérations à effectuer pour obtenir, à partir des
**entrées**, un résultat, la **sortie**.
+:::
+++ {"slideshow": {"slide_type": "slide"}}
@@ -90,12 +90,17 @@ Cela nous amène naturellement à la question suivante :
+++ {"slideshow": {"slide_type": "slide"}}
-## Au commencement était l'« assembleur »
+## Au commencement était l'assembleur
-L'assembleur est le langage que comprend directement l'ordinateur.
+:::{prf:definition} Assembleur
+L'***assembleur*** est le langage que comprend directement l'ordinateur.
Chaque instruction correspond à une opération élémentaire que peut
-effectuer le processeur :
+effectuer le processeur.
+:::
+
++++ {"slideshow": {"slide_type": "fragment"}, "tags": []}
+:::{prf:example}
``` nasm
mov -0x1c(%rbp), %edx
mov -0x1c(%rbp), %eax
@@ -105,12 +110,13 @@ effectuer le processeur :
imul -0x18(%rbp), %eax
mov %eax, -0x14(%rbp)
```
-
-Voyons cet exemple de plus près.
+:::
+++ {"slideshow": {"slide_type": "fragment"}}
-**Exercice :**
+Voyons cet exemple de plus près.
+
+:::{exercise}
Exécuter ce fragment d'*assembleur* en suivant les indications
suivantes :
@@ -122,6 +128,7 @@ suivantes :
- `imul a, b`Â : multiplier le contenu de a par celui de b et mettre le
résultat dans b
- Initialiser le contenu de la case `%-0x1c(%rbp)` Ã $3$
+:::
+++ {"slideshow": {"slide_type": "fragment"}}
@@ -139,7 +146,7 @@ bien content de ne pas avoir à programmer tout le temps en assembleur.
**Ce que je veux :**
-« Calculer la puissance 4 d'un nombre »
+« Calculer la puissance quatrième d'un nombre »
+++ {"slideshow": {"slide_type": "fragment"}}
@@ -160,7 +167,9 @@ bien content de ne pas avoir à programmer tout le temps en assembleur.
+++ {"slideshow": {"slide_type": "fragment"}}
**Passer de l'un à l'autre ne va pas se faire tout seul**. Il va
-falloir un peu de méthode ; c'est le cycle de vie d'un programme.
+falloir un peu de méthode.
+
+C'est le **cycle de vie d'un programme**.
+++ {"slideshow": {"slide_type": "slide"}}
@@ -172,47 +181,48 @@ fonctionnel.
+++ {"slideshow": {"slide_type": "fragment"}}
-#### Problème
-
-« Calculer la puissance 4 d'un nombre »
+:::{admonition} Problème
+« Calculer la puissance quatrième d'un nombre »
+:::
+++ {"slideshow": {"slide_type": "fragment"}}
-#### Formalisation
+:::{admonition} Formalisation
-Spécification des **entrées** et des **sorties**
+- Spécification des **entrées** et des **sorties**
-Scénario d'utilisation : « l'utilisateur rentre au clavier un nombre
-entier $x$ ; l'ordinateur affiche en retour la valeur de $x^4$ à l'écran »
+- Scénario d'utilisation : « l'utilisateur saisit au clavier un nombre
+ entier $x$ ; l'ordinateur affiche la valeur de $x^4$ à l'écran »
+:::
+++ {"slideshow": {"slide_type": "fragment"}}
-#### Recherche d'un algorithme
-
+:::{admonition} Recherche d'un algorithme
- Comment on résout le problème ?
- Quel **traitement** appliquer à l'entrée pour obtenir la sortie
désirée ?
+:::
+++ {"slideshow": {"slide_type": "fragment"}}
On note que $x^4=x * x * x * x = (x^2)^2$
-Cela nous donne un **algorithme**Â :
++++ {"slideshow": {"slide_type": "fragment"}}
+Cela nous donne un **algorithme**Â :
- calculer $x*x$
- prendre le résultat et faire de même
+++ {"slideshow": {"slide_type": "slide"}}
-#### Digression : La notion d'algorithme
-
-**Définition : Algorithme**
+### Digression : La notion d'algorithme
+:::{prf:definition} Algorithme
- Description formelle d'un procédé de traitement qui permet, à partir
d'un ensemble d'informations initiales, d'obtenir des informations
déduites
-
- Succession finie et non ambiguë d'opérations clairement posées
+:::
+++ {"slideshow": {"slide_type": "fragment"}}
@@ -220,7 +230,7 @@ Quelle différence entre un **algorithme** et un **programme** ?
+++ {"slideshow": {"slide_type": "fragment"}}
-Un algorithme
+Un algorithme:
- doit toujours se terminer !
- est conçu pour communiquer entre humains
- est un concept indépendant du langage dans lequel il est écrit
@@ -249,7 +259,7 @@ En assembleur ???
+++ {"slideshow": {"slide_type": "fragment"}}
-En C++Â :
+**En C++Â :**
Entrée :
@@ -274,26 +284,26 @@ Sortie :
#### Niveaux de langages de programmation
-+++ {"slideshow": {"slide_type": "slide"}}
++++ {"slideshow": {"slide_type": "fragment"}, "tags": []}
**Langage machine (binaire)Â :**
Un programme y est directement compréhensible par la machine
-+++ {"slideshow": {"slide_type": "slide"}}
++++ {"slideshow": {"slide_type": "fragment"}, "tags": []}
**Langage d'assemblage (ou assembleur)Â :**
Un programme y est traduisible mot-Ã -mot en langage machine
-+++ {"slideshow": {"slide_type": "slide"}}
++++ {"slideshow": {"slide_type": "fragment"}, "tags": []}
**Langage de programmation :**
En général, un programme doit être **transformé** pour être compris
par la machine
-+++ {"slideshow": {"slide_type": "slide"}}
++++ {"slideshow": {"slide_type": "fragment"}, "tags": []}
Comment faire cette transformation ? À la main ?
@@ -328,10 +338,10 @@ Basic, Javascript, LISP, Perl, Python, C++, ...
**Exemple : compilation en C++ :**
- Programme source : `puissance-quatre.cpp`
-- Compilation : `g++ puissance-quatre.cpp -o puissance-quatre`
+- Compilation : `clang++ puissance-quatre.cpp -o puissance-quatre`
- Programme objet (ou binaire)Â : `puissance-quatre`
- Exécution : `./puissance-quatre`
-- Fabrication de l'assembleur : `g++ -S puissance-quatre.cpp`
+- Fabrication de l'assembleur : `clang++ -S puissance-quatre.cpp`
- Programme en assembleur : `puissance-quatre.s`
+++ {"slideshow": {"slide_type": "fragment"}}
@@ -357,29 +367,29 @@ ADA, C, C++, FORTRAN, Java, Pascal, ...
### Exécution et mise au point
-**Exécuter le programme :**
-
+:::{admonition} Exécuter le programme
- Autant de fois que l'on veut !
+:::
+++ {"slideshow": {"slide_type": "fragment"}}
-**Tester que le programme fonctionne :**
-
+:::{admonition} Tester que le programme fonctionne
- En n'oubliant pas les cas particuliers !!!
+:::
+++ {"slideshow": {"slide_type": "fragment"}}
-**Mise au point :**
-
+:::{admonition} Mise au point
- Correction d'erreurs
- Optimisation du programme (consommation de ressources: temps, mémoire, énergie, ...)
- Optimisation de l'algorithme
- Amélioration du programme (lisibilité, généralisation)
+:::
+++ {"slideshow": {"slide_type": "fragment"}}
À chaque fois, on reboucle sur l'étape de compilation, voire de
-conception, d'où le terme de cycle de vie.
+conception, d'où le terme de **cycle de vie**.
+++ {"slideshow": {"slide_type": "slide"}}
@@ -391,8 +401,7 @@ s'appuyer sur un peu de
+++ {"slideshow": {"slide_type": "fragment"}}
-**Méthodologie :**
-
+:::{admonition} Méthodologie
1. Énoncé du problème
2. Formalisation (quel est le problème précisément ?)
3. Recherche d'un algorithme (comment résoudre le problème ?)
@@ -400,6 +409,7 @@ s'appuyer sur un peu de
5. Interprétation / Compilation
6. Exécution
7. Mise au point (test, débogage, optimisation, diffusion)
+:::
+++ {"slideshow": {"slide_type": "skip"}}
diff --git a/cours-digressions.md b/cours-digressions.md
index 4885ece..620e9aa 100644
--- a/cours-digressions.md
+++ b/cours-digressions.md
@@ -30,32 +30,27 @@ rise:
# Digressions : surcharge, templates, espaces de noms, ...
Nous allons maintenant faire quelques digressions, pour pointer vers
-des fonctionnalités de C++ que nous avons utilisées sans explication
-jusqu'ici, et dont l'usage simple est naturel et potentiellement utile
-dès maintenant.
+des fonctionnalités de C++ que nous avons utilisées sans explications
+jusqu'ici, et dont l'usage est naturel et potentiellement utile dès
+maintenant.
-+++ {"slideshow": {"slide_type": "fragment"}}
++++ {"slideshow": {"slide_type": "slide"}, "tags": []}
## Surcharge de fonctions ♣
-```{code-cell}
----
-slideshow:
- slide_type: fragment
----
-using namespace std;
-```
-
+++ {"slideshow": {"slide_type": "fragment"}}
### Exemple : la fonction `monMax`
++++ {"slideshow": {"slide_type": "skip"}, "tags": []}
+
Nous avons vu maintes fois la fonction `max` sur les entiers :
```{code-cell}
---
slideshow:
- slide_type: '-'
+ slide_type: fragment
+tags: []
---
int monMax(int a, int b) {
if ( a < b )
@@ -63,17 +58,11 @@ int monMax(int a, int b) {
else
return a;
}
-```
-```{code-cell}
----
-slideshow:
- slide_type: '-'
----
monMax(1,3)
```
-+++ {"slideshow": {"slide_type": "fragment"}}
++++ {"slideshow": {"slide_type": "skip"}, "tags": []}
On remarquera que le code est générique : on peut par exemple calculer
de même le maximum de deux nombres réels :
@@ -81,7 +70,8 @@ de même le maximum de deux nombres réels :
```{code-cell}
---
slideshow:
- slide_type: '-'
+ slide_type: fragment
+tags: []
---
double monMax(double a, double b) {
if ( a < b)
@@ -89,102 +79,104 @@ double monMax(double a, double b) {
else
return a;
}
-```
-```{code-cell}
----
-slideshow:
- slide_type: '-'
----
monMax(1.0, 3.5)
```
-+++ {"slideshow": {"slide_type": "fragment"}}
++++ {"slideshow": {"slide_type": "skip"}, "tags": []}
ou même de deux chaînes de caractères :
```{code-cell}
---
slideshow:
- slide_type: '-'
+ slide_type: fragment
+tags: []
---
+using namespace std;
+```
+
+```{code-cell}
+:tags: []
+
string monMax(string a, string b) {
if ( a < b)
return b;
else
return a;
}
-```
-```{code-cell}
----
-slideshow:
- slide_type: '-'
----
monMax("toto", "alfred")
```
+++ {"slideshow": {"slide_type": "fragment"}}
-Vous remarquerez que l'on a utilisé le même nom de fonction, et que
+:::{hint} Observation
+Nous avons utilisé chaque fois le même nom de fonction et
`C++` a appelé automatiquement la bonne version.
+:::
+++ {"slideshow": {"slide_type": "fragment"}}
+:::{hint} Remarque
Il serait de même possible d'utiliser le même nom de fonction pour le
max à trois arguments (et plus!) :
+:::
```{code-cell}
----
-slideshow:
- slide_type: '-'
----
+:tags: []
+
int monMax(int a, int b, int c) {
return monMax(monMax(a, b), c);
}
-```
-```{code-cell}
----
-slideshow:
- slide_type: '-'
----
monMax(2,4,3)
```
-+++ {"slideshow": {"slide_type": "slide"}}
++++ {"slideshow": {"slide_type": "fragment"}, "tags": []}
-Mais attention aux ambiguïtés :
+:::{attention} Attention aux ambiguïtés
+<br>
+:::
```{code-cell}
----
-slideshow:
- slide_type: '-'
----
+:tags: []
+
monMax(3, 4.5)
```
-+++ {"slideshow": {"slide_type": "slide"}}
-
-### Surcharge de fonction : résumé
++++ {"slideshow": {"slide_type": "slide"}, "tags": []}
+:::{prf:definition} ***Surcharge de fonction***
- En C++, on peut avoir plusieurs fonctions avec le même nom et des
signatures différentes
-
- Idem en Java, mais pas en C ou en Python par exemple!
+:::
-- Il est recommandé que toutes les fonctions ayant le même nom aient
- la même *sémantique*
++++ {"slideshow": {"slide_type": "fragment"}, "tags": []}
-+++ {"slideshow": {"slide_type": "fragment"}}
+:::{hint} Bonne pratique
+Il est recommandé que toutes les fonctions ayant le même nom aient
+la même *sémantique*
+:::
+
++++ {"slideshow": {"slide_type": "slide"}, "tags": []}
## Digression : templates ♣
+:::{warning} Problème
L'exemple précédent n'est pas satisfaisant : on a dû implanter la
fonction `monMax` pour chaque type sur lequel on peut faire une
comparaison, en dupliquant le même code.
+:::
+
++++ {"slideshow": {"slide_type": "fragment"}, "tags": []}
+
+:::{hint} Solution
+Les ******templates****** pour écrire du code *générique*
+:::
-Correctif : les *templates* pour écrire du code *générique*
++++ {"slideshow": {"slide_type": "fragment"}, "tags": []}
La fonction `monMax` suivante est valide pour tout type sur lequel on
peut faire des comparaisons :
@@ -243,27 +235,30 @@ Les détails seront pour un autre cours!
## Digression : espaces de noms ♣
-**Problème :**
+:::{warning} Problème
Des milliers de développeurs écrivent des bibliothèques, bibliothèques
qui sont par la suite combinées entre elles de multiples façons non
-anticipées à l'origine. Comment s'assurer qu'il n'y a pas de conflit
+anticipées à l'origine.
+
+Comment s'assurer qu'il n'y a pas de conflit
entre deux fonctions portant le même nom et la même signature dans
deux bibliothèques différentes?
+:::
+++ {"slideshow": {"slide_type": "fragment"}}
-**Solution :**
-
-Isoler chaque bibliothèque dans un *espace de noms*.
+:::{hint} Solution
+Isoler chaque bibliothèque dans un ******espace de noms******
+:::
+++ {"slideshow": {"slide_type": "fragment"}}
-**Exemple :**
-
+:::{prf:example}
La bibliothèque standard C++ utilise l'espace de nom `std`. Ainsi,
dans le programme suivant, il faudrait en principe mettre `std`
-devant `cout`, et `endl`Â :
+devant `cout`, et `endl`.
+:::
```{code-cell}
---
@@ -279,12 +274,14 @@ int main() {
+++ {"slideshow": {"slide_type": "fragment"}}
+:::{hint} Explication
Notre incantation magique :
``` c++
using namespace std;
```
dit simplement de définir des raccourcis pour rendre accessible
directement tout ce qui est défini dans l'espace de nom `std`.
+:::
+++ {"slideshow": {"slide_type": "fragment"}}
diff --git a/cours-modularite.md b/cours-modularite.md
index 4857256..2eb508e 100644
--- a/cours-modularite.md
+++ b/cours-modularite.md
@@ -25,7 +25,7 @@ rise:
width: 90%
---
-+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "f003d1fe379fe84ce034a14aea0c8147", "grade": false, "grade_id": "cell-bc2bac01a1ae5d6e", "locked": true, "schema_version": 3, "solution": false, "task": false}, "slideshow": {"slide_type": "slide"}}
++++ {"slideshow": {"slide_type": "slide"}}
# Modularité, compilation séparée
@@ -36,40 +36,39 @@ petit bout, d'éviter les redites, etc.
Nous allons de même **découper un programme en plusieurs fichiers**.
-+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "c32639e12e6a2b647ff43343efe728db", "grade": false, "grade_id": "cell-bc2bac01a1ae5d6f", "locked": true, "schema_version": 3, "solution": false, "task": false}, "slideshow": {"slide_type": "slide"}}
++++ {"slideshow": {"slide_type": "slide"}}
## Compilation séparée
-+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "9497653142bbd1f090931e2db5641f75", "grade": false, "grade_id": "cell-eda0e2d6022d648b", "locked": true, "schema_version": 3, "solution": false, "task": false}, "slideshow": {"slide_type": "fragment"}}
++++ {"slideshow": {"slide_type": "fragment"}}
### Exemple
Considérons les trois programmes suivants :
-+++ {"slideshow": {"slide_type": "slide"}}
++++ {"slideshow": {"slide_type": "fragment"}, "tags": []}
Dans Jupyter :
```{code-cell}
----
-slideshow:
- slide_type: '-'
----
-#include <iostream>
+:tags: []
-#include "max_simpliste.hpp"
+int monMax(int a, int b) {
+ if ( a >= b )
+ return a;
+ else
+ return b;
+}
```
```{code-cell}
monMax(10, 1)
```
-+++ {"slideshow": {"slide_type": "slide"}}
++++ {"slideshow": {"slide_type": "slide"}, "tags": []}
[programme1.cpp](programme1.cpp)Â : maximum de deux entiers, avec un exemple
-+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "1492e87493155542d8d49436f01e4b91", "grade": false, "grade_id": "cell-eda0e2d6022d648c", "locked": true, "schema_version": 3, "solution": false, "task": false}, "slideshow": {"slide_type": "-"}}
-
``` c++
#include <iostream>
using namespace std;
@@ -80,20 +79,17 @@ int monMax(int a, int b) {
else
return b;
}
-```
-``` c++
+
int main() {
cout << monMax(1, 3) << endl;
return 0;
}
```
-+++ {"slideshow": {"slide_type": "slide"}}
++++ {"slideshow": {"slide_type": "slide"}, "tags": []}
[programme2.cpp](programme2.cpp) : maximum de deux entiers, avec interactivité
-+++ {"slideshow": {"slide_type": "-"}}
-
``` c++
#include <iostream>
using namespace std;
@@ -104,9 +100,7 @@ int monMax(int a, int b) {
else
return b;
}
-```
-``` c++
int main() {
cout << "Entrez a et b:" << endl;
int a, b;
@@ -122,7 +116,7 @@ int main() {
On constate une **répétition** : les trois programmes définissent exactement
la même fonction `monMax`, qu'ils utilisent ensuite différemment.
-Pourrait-on partager la fonction `monMax` entre ces trois programmes ?
+Pourrait-on **partager** la fonction `monMax` entre ces trois programmes ?
C'est ce que nous allons faire en définissant une mini-bibliothèque.
Voyons à quoi cela ressemble.
@@ -148,7 +142,7 @@ int monMax(int a, int b) {
+++ {"slideshow": {"slide_type": "fragment"}}
-Pour utiliser cette bibliothèque, il suffit de l'***inclure*** :
+Pour utiliser cette bibliothèque, il suffit de l'******inclure****** :
```{code-cell}
#include "max_simpliste.hpp"
@@ -160,25 +154,26 @@ monMax(1, 3)
+++ {"slideshow": {"slide_type": "fragment"}}
-<div class="alert alert-warning">
+:::{attention}
-On appelle cela une bibliothèque en ***entêtes seuls*** (***header only***).
+On appelle cela une bibliothèque en ******entêtes seuls****** (******header only******).
En `C++`, il y a des cas d'usage où cela peut être pertinent.
Il y a de sérieuses limitations à cette façon de structurer une bibliothèque.
Dans ce cours on évitera.
+:::
-</div>
-
-+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "579b25dc89bdc9c0252cfe90d3f976b0", "grade": false, "grade_id": "cell-04d9ac7b73aa7155", "locked": true, "schema_version": 3, "solution": false, "task": false}, "slideshow": {"slide_type": "slide"}}
++++ {"slideshow": {"slide_type": "slide"}}
#### Exemple : une bibliothèque `max` dans les règles
-+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "bcc5994c592a52d4141024a74fe4ad11", "grade": false, "grade_id": "cell-04d9ac7b73aa7156", "locked": true, "schema_version": 3, "solution": false, "task": false}, "slideshow": {"slide_type": "fragment"}}
++++ {"slideshow": {"slide_type": "fragment"}}
+
+% TODO: ici et dans les pages suivantes: use literalinclude
-Contenu du fichier `max.hpp`Â :
+Contenu du fichier [max.hpp](max.hpp)Â :
``` c++
/** La fonction max
* @param x, y deux entiers
@@ -190,7 +185,7 @@ int monMax(int a, int b);
+++ {"slideshow": {"slide_type": "fragment"}}
-Contenu du fichier `max.cpp`Â :
+Contenu du fichier [max.cpp](max.cpp)Â :
``` c++
#include "max.hpp"
@@ -204,10 +199,11 @@ int monMax(int a, int b) {
+++ {"slideshow": {"slide_type": "slide"}}
-#### Exemple : deux programmes utilisant la bibliothèque max
+#### Exemple : deux programmes utilisant la bibliothèque `max`
+++ {"slideshow": {"slide_type": "fragment"}}
+Contenu du fichier [programme1.cpp](programme1.cpp):
``` c++
#include <iostream>
using namespace std;
@@ -221,6 +217,7 @@ int main() {
+++ {"slideshow": {"slide_type": "fragment"}}
+Contenu du fichier [programme2.cpp](programme2.cpp):
``` c++
#include <iostream>
using namespace std;
@@ -236,13 +233,13 @@ int main() {
}
```
-+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "4660ee07cdbb406ba256477ea7c4fc59", "grade": false, "grade_id": "cell-c0ee9ca9166c339f", "locked": true, "schema_version": 3, "solution": false, "task": false}, "slideshow": {"slide_type": "slide"}}
++++ {"slideshow": {"slide_type": "slide"}}
#### Exemple : les tests de la bibliothèque `max`
-+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "12530a4d02fe03e35ea980f1ee58d2b0", "grade": false, "grade_id": "cell-c0ee9ca9166c339g", "locked": true, "schema_version": 3, "solution": false, "task": false}, "slideshow": {"slide_type": "fragment"}}
++++ {"slideshow": {"slide_type": "fragment"}}
-Contenu du fichier `max-test.cpp`Â :
+Contenu du fichier [max-test.cpp](max-test.cpp)Â :
``` c++
#include <iostream>
using namespace std;
@@ -251,8 +248,7 @@ using namespace std;
/** Infrastructure minimale de test **/
#define CHECK(test) if (!(test)) cerr << "Test failed in file " << __FILE__ << " line " << __LINE__ << ": " #test << endl
-```
-``` c++
+
void monMaxTest() {
CHECK( monMax(2,3) == 3 );
CHECK( monMax(5,2) == 5 );
@@ -264,7 +260,7 @@ int main() {
}
```
-+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "787972a2428cc04cb9217d9a030d58c4", "grade": false, "grade_id": "cell-fdf12d05bb0ffe32", "locked": true, "schema_version": 3, "solution": false, "task": false}, "slideshow": {"slide_type": "slide"}}
++++ {"slideshow": {"slide_type": "slide"}}
### Qu'avons-nous vu ?
@@ -274,59 +270,63 @@ int main() {
+++ {"slideshow": {"slide_type": "fragment"}}
-**Syntaxe :**
-
+:::{admonition} Syntaxe
``` c++
int monMax(int a, int b);
```
+:::
+++ {"slideshow": {"slide_type": "fragment"}}
-**Sémantique :**
-
-- Le programme *définit* quelque part une fonction `monMax` avec cette
- *signature*Â :
+:::{admonition} Sémantique
+- Le programme ******définit****** quelque part une fonction `monMax` avec cette
+ ******signature******Â :
type des paramètres et type du résultat
- Cette définition n'est pas forcément dans le même fichier
- Si cette définition n'existe pas ou n'est pas unique, une erreur est
déclenchée par le compilateur
- Cette erreur est déclenchée au moment où l'on combine les différents
- fichiers
- Édition de liens; voir plus loin
+ fichiers: voir plus loin «Édition de liens»
+++ {"slideshow": {"slide_type": "fragment"}}
-**♣ Application :**
-
+:::{hint} ♣ Application
Deux fonctions qui s'appellent réciproquement
+:::
-+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "b3709f14a593cf15abcc96057044e99f", "grade": false, "grade_id": "cell-26e5cd21217b8ec5", "locked": true, "schema_version": 3, "solution": false, "task": false}, "slideshow": {"slide_type": "slide"}}
++++ {"slideshow": {"slide_type": "slide"}}
#### Compilation séparée (1)
- Un programme peut être composé de plusieurs ***fichiers source***
Contenu :
- - Des *définitions* de fonctions
+ - Des définitions de fonctions
- Des variables globales, ...
++++ {"slideshow": {"slide_type": "fragment"}, "tags": []}
+
- Chaque fichier source est compilé en un ***fichier objet*** (extension : .o)
Contenu :
- Le code binaire des fonctions, ...
-- L'*éditeur de liens* combine plusieurs fichiers objet en un
- *fichier exécutable*
++++ {"slideshow": {"slide_type": "fragment"}, "tags": []}
+
+- L'******éditeur de liens****** combine plusieurs fichiers objet en un
+ ******fichier exécutable******
+++ {"slideshow": {"slide_type": "fragment"}}
Voyons cela pour un programme voulant utiliser la bibliothèque `max` :
-Les sources sont `max.cpp` et `programme.cpp`.
+Les sources sont [max.cpp](max.cpp) et [programme.cpp](programme.cpp).
+
++++ {"slideshow": {"slide_type": "fragment"}}
On les compile séparément avec :
```shell
-g++ -c max.cpp
-g++ -c programme.cpp
+clang++ -c max.cpp
+clang++ -c programme.cpp
```
Cela produit les fichiers objets `max.o` et `programme.o`. Chacun est
@@ -334,13 +334,17 @@ un bout incomplet de programmes binaires : `max.o` contient le code
binaire de la fonction `max` mais pas la fonction `main`, et
réciproquement pour `programme.o`.
++++ {"slideshow": {"slide_type": "fragment"}}
+
Il ne reste plus qu'Ã combiner ces deux bouts de programmes binaires
pour obtenir un programme complet.
```shell
-g++ programme.o max.o -o programme
+clang++ programme.o max.o -o programme
```
++++ {"slideshow": {"slide_type": "fragment"}}
+
Maintenant, on peut exécuter le programme obtenu autant de fois qu'on
le souhaite :
@@ -348,135 +352,138 @@ le souhaite :
./programme
```
-+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "0d83630ea4ed4d5d557e122d963571f8", "grade": false, "grade_id": "cell-de97499851e34054", "locked": true, "schema_version": 3, "solution": false, "task": false}, "slideshow": {"slide_type": "slide"}}
++++ {"slideshow": {"slide_type": "slide"}}
#### Compilation séparée (2)
**Au moment de l'édition de lien :**
-- Chaque fonction utilisée doit être définie une et une seule fois
-- La fonction `main` doit être définie une et une seule fois
-
-+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "ce17de7f5b94f7bb286b8110e5437571", "grade": false, "grade_id": "cell-de97499851e34055", "locked": true, "schema_version": 3, "solution": false, "task": false}, "slideshow": {"slide_type": "fragment"}}
+- Chaque fonction utilisée **doit être définie une et une seule fois**
+- La fonction `main` **doit être définie une et une seule fois**
-**Quelques variantes autour des fichiers objets :** ♣
++++ {"slideshow": {"slide_type": "fragment"}}
+:::{hint} ♣ Quelques variantes autour des fichiers objets
- Bibliothèques (.a) :
Une archive contenant plusieurs fichiers objets .o
-
- Bibliothèques dynamiques (.so) :
Édition de lien dynamique au lancement du programme
+:::
-+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "52664d050cdb13f6a766e3cbcc175719", "grade": false, "grade_id": "cell-e568b9b55cb70a3b", "locked": true, "schema_version": 3, "solution": false, "task": false}, "slideshow": {"slide_type": "slide"}}
++++ {"slideshow": {"slide_type": "slide"}}
#### Fichiers d'entête
+:::{prf:definition} Fichier d'entête
Fichier `.hpp` (ou `.h` en C) contenant la *déclaration* des fonctions *définies* dans
le fichier `.cpp` correspondant
+:::
-+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "caf19989e2817546698bf5fbf404d630", "grade": false, "grade_id": "cell-e568b9b55cb70a3c", "locked": true, "schema_version": 3, "solution": false, "task": false}, "slideshow": {"slide_type": "fragment"}}
-
-**Exemple :** Fichier d'entête `max.hpp`
++++ {"slideshow": {"slide_type": "fragment"}}
+:::{prf:example} Fichier d'entête `max.hpp`
``` c++
int monMax(int a, int b);
```
+:::
-+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "1e9959987853b8d9ed69ad76b649bbe2", "grade": false, "grade_id": "cell-e568b9b55cb70a3d", "locked": true, "schema_version": 3, "solution": false, "task": false}, "slideshow": {"slide_type": "fragment"}}
-
-**Syntaxe :** Utilisation d'un fichier d'entête
++++ {"slideshow": {"slide_type": "fragment"}}
+#### Utilisation d'un fichier d'entête
+:::{admonition} Syntaxe
``` c++
#include "max.hpp"
```
-
-**Sémantique :**
-
+:::
+:::{admonition} Sémantique
Utiliser la bibliothèque `max`
+:::
-+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "7c7bbb13cb5d1fe766e13d181ac0e393", "grade": false, "grade_id": "cell-e568b9b55cb70a3e", "locked": true, "schema_version": 3, "solution": false, "task": false}, "slideshow": {"slide_type": "fragment"}}
++++ {"slideshow": {"slide_type": "fragment"}}
-**Implantation en C++Â :**
+:::{hint} Implantation en C++
- Équivalent à copier-coller le contenu de `max.hpp` à l'emplacement du
`#include "max.hpp"`
- ♣ Géré par le préprocesseur (cpp)
+```
-+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "ff72d7aa40bd416b2c3dacc17f4839cb", "grade": false, "grade_id": "cell-1501d26cad5b60f2", "locked": true, "schema_version": 3, "solution": false, "task": false}, "slideshow": {"slide_type": "slide"}}
++++ {"slideshow": {"slide_type": "slide"}}
#### Inclusion de fichiers d'entêtes standards
-**Syntaxe :**
-
+:::{admonition} Syntaxe
``` c++
#include <iostream>
```
+:::
-**Sémantique :**
+:::{admonition} Sémantique
- Charge la déclaration de toutes les fonctions définies dans la
bibliothèque standard `iostream` de C++
-
- Le fichier `iostream` est recherché dans les répertoires standards
du système
-
- Sous linux : `/usr/include`, ...
+:::
-+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "eeb3f33e690b970c5a4138874c58ed52", "grade": false, "grade_id": "cell-208ec2ed61304261", "locked": true, "schema_version": 3, "solution": false, "task": false}, "slideshow": {"slide_type": "slide"}}
++++ {"slideshow": {"slide_type": "skip"}, "tags": []}
## Résumé
-+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "84c2764e1ac634a4c126e1fb2c9ed6f8", "grade": false, "grade_id": "cell-208ec2ed61304262", "locked": true, "schema_version": 3, "solution": false, "task": false}, "slideshow": {"slide_type": "fragment"}}
++++ {"slideshow": {"slide_type": "slide"}, "tags": []}
### Résumé : implantation d'une bibliothèque en C++
-+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "d26c3cdec520f8f76b0624b17f950fe6", "grade": false, "grade_id": "cell-208ec2ed61304263", "locked": true, "schema_version": 3, "solution": false, "task": false}, "slideshow": {"slide_type": "fragment"}}
-
-**Écrire un fichier d'entête (max.hpp) :**
++++ {"slideshow": {"slide_type": "fragment"}}
+:::{admonition} Écrire un fichier d'entête (max.hpp)
- La déclaration de toutes les fonctions publiques
- *Avec leur documentation !*
+:::
-+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "9b390f6d19d63b7222aaf3e9ea2c2733", "grade": false, "grade_id": "cell-208ec2ed61304264", "locked": true, "schema_version": 3, "solution": false, "task": false}, "slideshow": {"slide_type": "fragment"}}
-
-**Écrire un fichier source (max.cpp) :**
++++ {"slideshow": {"slide_type": "fragment"}}
+:::{admonition} Écrire un fichier source (max.cpp)
- La définition de toutes les fonctions
- *Inclure le fichier .hpp !*
+:::
-+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "b16ddc2f444fbd91507b32f1ad2bb135", "grade": false, "grade_id": "cell-208ec2ed61304265", "locked": true, "schema_version": 3, "solution": false, "task": false}, "slideshow": {"slide_type": "fragment"}}
-
-**Écrire un fichier de tests (maxTest.cpp) :**
++++ {"slideshow": {"slide_type": "fragment"}}
+:::{admonition} Écrire un fichier de tests (maxTest.cpp)
- Les fonctions de tests
- Une fonction `main` lançant tous les tests
+:::
+++ {"slideshow": {"slide_type": "slide"}}
### Résumé : utilisation d'une bibliothèque en C++
-**Inclusion des entêtes :**
-
+:::{admonition} Inclusion des entêtes
```c++
#include <iostream> // fichier d'entête standard
#include "max.hpp" // fichier d'entête perso
```
+:::
+++ {"slideshow": {"slide_type": "fragment"}}
-**Compilation :**
-
+:::{admonition} Compilation
```shell
-g++ -c max.cpp
-g++ -c programme1.cpp
-g++ max.o programme1.o -o programme1
+clang++ -c max.cpp
+clang++ -c programme1.cpp
+clang++ max.o programme1.o -o programme1
```
+:::
+++ {"slideshow": {"slide_type": "fragment"}}
-**En une seule étape :**
-
+:::{admonition} En une seule étape
```shell
-g++ max.cpp programme1.cpp -o programme1
+clang++ max.cpp programme1.cpp -o programme1
```
+:::
+
++++ {"slideshow": {"slide_type": "skip"}, "tags": []}
## Suite
--
GitLab