cours.md

jupytext:
  notebook_metadata_filter: rise, semantic
  text_representation:
    extension: .md
    format_name: myst
    format_version: 0.13
    jupytext_version: 1.15.1
kernelspec:
  display_name: C++14
  language: C++14
  name: xcpp14
rise:
  auto_select: first
  autolaunch: false
  centered: false
  controls: false
  enable_chalkboard: true
  height: 100%
  margin: 0
  maxScale: 1
  minScale: 1
  scroll: true
  slideNumber: true
  start_slideshow_at: selected
  transition: none
  width: 90%
semantic:
  use_module: info-111

+++ {"slideshow": {"slide_type": "slide"}}

Premiers éléments de programmation impérative

+++ {"slideshow": {"slide_type": "slide"}}

Prélude

+++ {"slideshow": {"slide_type": "slide"}}

Résumé des épisodes précédents ...

+++ {"slideshow": {"slide_type": "fragment"}}

• Info 111: modalités et infrastructure

+++ {"slideshow": {"slide_type": "fragment"}}

• Informatique: usage, technologie, science

+++ {"slideshow": {"slide_type": "fragment"}}

• Objectif d'Info 111: initier à la science via la technologie

+++ {"slideshow": {"slide_type": "fragment"}}

• Concrètement: bases de la programmation impérative + ...

+++ {"slideshow": {"slide_type": "slide"}}

Rappel

:::{prf:definition} Programmes

Programme : suite d'instructions exécutées de manière séquentielle (les unes après les autres)

:::

+++ {"slideshow": {"slide_type": "fragment"}}

::::::{prf:example} :::::{grid} :gutter: 0

:::{grid-item-card}

debut()
droite()
avance()
prend()
gauche()
avance()
pose()
droite()
avance()
gauche()
avance()
avance()
droite()
ouvre()

:::

::::{grid-item-card}

:::{image} media/laby0.png :height: 20ex :align: center :::

:::: ::::: ::::::

+++ {"slideshow": {"slide_type": "slide"}}

Comment rompre la monotonie?

+++ {"slideshow": {"slide_type": "fragment"}}

• Faire des calculs : expressions et variables

+++ {"slideshow": {"slide_type": "fragment"}}

• Découper en petits programmes : les fonctions

+++ {"slideshow": {"slide_type": "fragment"}}

• S'adapter au contexte : les instructions conditionnelles

+++ {"slideshow": {"slide_type": "fragment"}}

• Répéter : les instructions itératives (boucles)

+++ {"slideshow": {"slide_type": "slide"}}

Expressions

+++ {"slideshow": {"slide_type": "fragment"}}

(expression)= :::{prf:definition} Expressions

Expression : combinaison de valeurs par des opérations donnant une nouvelle valeur

:::

+++ {"slideshow": {"slide_type": "fragment"}}

:::{prf:example} L'expression 3 * (1 + 3) + (1 + 4) * (2 + 4) vaut 42 :::

+++ {"slideshow": {"slide_type": "fragment"}}

(operations_sur_les_entiers)= :::{admonition} Opérations sur les entiers

Opération	Exemple	Résultat
opposé	-(-5)	5
addition	17 + 5	22
soustraction	17 - 5	12
multiplication	17 * 5	85
division entière	17 / 5	3
reste de la division entière	17 % 5	2

:::

+++ {"slideshow": {"slide_type": "slide"}}

:::{tip} Aparté : syntaxe, sémantique, algorithme

(syntaxe_informel)=

• Syntaxe : comment on l'écrit (semantique_informel)=
• Sémantique : ce que cela fait (algorithme_informel)=
• Algorithme : comment c'est fait :::

+++ {"slideshow": {"slide_type": "fragment"}}

:::{prf:example}

• Syntaxe : 17 / 5
• Sémantique : calcule la division entière de 17 par 5
• Algorithme : division euclidienne :::

+++ {"slideshow": {"slide_type": "slide"}}

Expressions booléennes

+++ {"slideshow": {"slide_type": "fragment"}}

(expression_booleenne)= :::{prf:definition} Expressions booléennes (conditions)

Une expression booléenne est une expression dont la valeur est «vrai» ou «faux» (type : bool).

(condition)= Une expression booléenne est aussi appelée une condition.

:::

+++ {"slideshow": {"slide_type": "fragment"}}

Exemples:

---
slideshow:
  slide_type: fragment
---
true

---
slideshow:
  slide_type: fragment
---
false

+++ {"slideshow": {"slide_type": "fragment"}}

• regarde() == Vide
• x > 3.14
• 2 <= n and n <= 5

+++ {"slideshow": {"slide_type": "fragment"}}

(operations_booleennes_usuelles)= :::{admonition} Opérations booléennes usuelles

Opération	Exemple	Résultat
comparaison	3 <= 5	true
comparaison stricte	3 < 5	true
comparaison stricte	3 > 5	false
égalité	3 == 5	false
inégalité	3 != 5	true
négation	not 3 <= 5	false
et	3 < 5 and 3 > 5	false
ou	3 < 5 or 3 > 5	true

:::

+++ {"slideshow": {"slide_type": "slide"}}

Variables

+++ {"slideshow": {"slide_type": "fragment"}}

(exemple:calcul_energie_cinetique)= :::{prf:example} :for: expression :good_to_have: cinetic_energy :motivates: variable :name: exemple_variables_énergie_cinétique

Calculer l'énergie cinétique

\frac12 m v^2

d'un objet de masse

14,5

kg selon qu'il aille à

1

,

10

,

100

, ou

1000

m/s. :::

---
slideshow:
  slide_type: fragment
---
1./2 * 14.5 * 1 * 1

---
slideshow:
  slide_type: fragment
---
1./2 * 14.5 * 10 * 10

---
slideshow:
  slide_type: fragment
---
1./2 * 14.5 * 10 * 10

---
slideshow:
  slide_type: fragment
---
1./2 * 14.5 * 100 * 100

+++ {"slideshow": {"slide_type": "fragment"}}

Qu'est-ce qui n'est pas satisfaisant?

---
slideshow:
  slide_type: fragment
---
double v;
double m;

---
slideshow:
  slide_type: fragment
---
v = 1000;
m = 14.5;

---
slideshow:
  slide_type: fragment
---
1.0/2.0 * m * v * v

+++ {"slideshow": {"slide_type": "slide"}}

(variable)= :::{prf:definition} Variables

Une variable est un espace de stockage nommé où le programme peut mémoriser une donnée

:::

+++ {"slideshow": {"slide_type": "fragment"}}

Le nom de la variable est choisi par le programmeur

• Objectif : stocker des informations durant l'exécution d'un programme

• Analogie : utiliser un récipient pour stocker des ingrédients en cuisine :

  • Verser le sucre dans un saladier
  • Ajouter la farine dans le saladier
  • Laisser reposer
  • Verser le contenu du saladier dans ...

+++ {"slideshow": {"slide_type": "slide"}}

:::{admonition} À retenir

En C++, une variable possède quatre propriétés :

• un nom (ou identificateur)
• une adresse
  à préciser la semaine prochaine
• un type
• une valeur

La valeur peut changer en cours d'exécution du programme (d'où le nom de variable)

:::

+++ {"slideshow": {"slide_type": "slide"}}

Notion de type

Les variables peuvent contenir toutes sortes de données différentes :

• nombres entiers, réels, booléens, ...
• textes
• relevés de notes, images, musiques, ...

+++ {"slideshow": {"slide_type": "fragment"}}

(type_informel)= :::{prf:definition} Types

• Une variable C++ ne peut contenir qu'une seule sorte de données.
• On appelle cette sorte le type de la variable.
• On dit que C++ est un langage typé statiquement.

:::

+++ {"slideshow": {"slide_type": "slide"}}

:::{prf:definition} Types de base

Les types de base en C++ sont :

(entier)=

• Les entiers (mots clés int, long int)
  Exemples : 1, 42, -32765 (reel)=
• les réels (mots clés float, double)
  Exemples : 10.43, 1.0324432e22 (caractere)=
• les caractères (mot clé char)
  Exemples : 'a', 'b', ' ', ']' (chaine_de_caractere)=
• les chaînes de caractères (mot clé string)
  Exemples : "bonjour", "Alice aime Bob" (booleen)=
• les booléens (mot clé bool)
  Exemples : true (vrai), false (faux)

(type_ordinal)= Les entiers, les caractères et les booléens forment les types ordinaux.

:::

+++ {"slideshow": {"slide_type": "slide"}}

(declaration)=

La déclaration des variables

Pour chaque variable, il faut donner au programme son nom et son type. On dit que l'on déclare la variable.

:::{admonition} Syntaxe : déclaration des variables

type nomvariable;
type nomvariable1, nomvariable2, ...;

:::

+++ {"slideshow": {"slide_type": "fragment"}}

:::{prf:example}

int x, y, monEntier;
double f, g;
bool b;

:::

+++ {"slideshow": {"slide_type": "fragment"}}

Note : en C++ (compilé) on ne peut pas redéclarer une variable avec le même nom!

+++ {"slideshow": {"slide_type": "slide"}}

(affectation)=

L'affectation

:::{admonition} Syntaxe

identificateur = expression;

:::

+++ {"slideshow": {"slide_type": "fragment"}}

:::{prf:example}

x = 3 + 5;

+++ {"slideshow": {"slide_type": "fragment"}}

:::{admonition} Sémantique

• Calcul (ou évaluation) de la valeur de l'expression
• Stockage de cette valeur dans la case mémoire associée à cette variable.
• La variable et l'expression doivent être de même type! :::

+++ {"slideshow": {"slide_type": "slide"}}

Exemples d'affectations

---
slideshow:
  slide_type: fragment
---
int x, y;

+++ {"slideshow": {"slide_type": "fragment"}}

On affecte la valeur 1 à la variable x :

x = 1;

+++ {"slideshow": {"slide_type": "fragment"}}

On affecte la valeur 3 à la variable y :

y = 3;

+++ {"slideshow": {"slide_type": "fragment"}}

Valeurs des variables après l'affectation :

x

y

+++ {"slideshow": {"slide_type": "slide"}}

Exemple : affecter la valeur d'une variable à une autre variable

x = y;

---
slideshow:
  slide_type: fragment
---
x

---
slideshow:
  slide_type: fragment
---
y

+++ {"slideshow": {"slide_type": "fragment"}}

Note

• Affectation x = y : copie de la valeur

+++ {"slideshow": {"slide_type": "fragment"}}

• y garde sa valeur
• L'ancienne valeur de x est perdue!

+++ {"slideshow": {"slide_type": "fragment"}}

• Différent de transférer un ingrédient d'un récipient à l'autre

+++ {"slideshow": {"slide_type": "slide"}}

Exemple : incrémentation

---
slideshow:
  slide_type: fragment
---
int x;
x = 1;

---
slideshow:
  slide_type: fragment
---
x = x + 1;

x

+++ {"slideshow": {"slide_type": "fragment"}}

Variantes :

---
slideshow:
  slide_type: fragment
---
x -= 2

x--;

x

+++ {"slideshow": {"slide_type": "slide"}}

:::{warning} Affectation et égalité : deux concepts différents

• L'affectation x = 5 :

  Une instruction modifiant l'état de la mémoire.

• Le test d'égalité x == 5 :

  Une expression booléenne (valeur vrai ou faux) :

  « x est égal à 5? »

  Autrement dit : est-ce que la valeur contenue dans la variable x est 5?

:::

+++ {"slideshow": {"slide_type": "slide"}}

Fonctions

+++ {"slideshow": {"slide_type": "fragment"}}

Retour sur notre exemple :

Calculer l'énergie cinétique

\frac12 m v^2

d'un objet de masse

14,5

kg selon qu'il aille à

1

,

10

,

100

, ou

1000

km/h.

Voilà comment nous avions procédé :

m = 14.5;
v = 100;
1./2 * m * v * v

+++ {"slideshow": {"slide_type": "fragment"}}

Comment éviter de retaper chaque fois la formule?

+++ {"slideshow": {"slide_type": "slide"}}

Fonctions

(fonction_informelle)= :::{prf:definition} Fonctions

Informellement, une fonction est un petit programme :

• Entrées
• Traitement
• Sortie

:::

+++ {"slideshow": {"slide_type": "fragment"}}

Exemple :

---
slideshow:
  slide_type: fragment
---
double energie_cinetique(double m, double v) {
    return 0.5 * m * v * v;
}

---
slideshow:
  slide_type: fragment
---
energie_cinetique(14.5, 10)

+++ {"slideshow": {"slide_type": "fragment"}}

• Entrées : la masse et la vitesse (des nombres réels)

• Sortie : l'énergie cinétique (un nombre réel)

• Traitement : 0.5 * m * v * v

+++ {"slideshow": {"slide_type": "slide"}}

Autres exemples de fonctions

:::{prf:example} :for: function, while_loop

Chou-Chèvre-Loup :

void transporter(... T) {
    charger(T);
    traverser();
    decharger(T);
}

Laby :

void avance_tant_que_tu_peux() {
    while ( regarde() == Vide ) {
        avance();
    }
}

:::

+++ {"slideshow": {"slide_type": "slide"}}

Structures de contrôle

+++ {"slideshow": {"slide_type": "slide"}}

Rôle des structures de contrôle

+++ {"slideshow": {"slide_type": "fragment"}}

Rappel

Les instructions sont exécutées de manière séquentielle (les unes après les autres), dans l'ordre du programme.

Exemple :

:::::{grid} :gutter: 0

:::{grid-item-card}

debut()
droite()
avance()
prend()
gauche()
avance()
pose()
droite()
avance()
gauche()
avance()
avance()
droite()
ouvre()

:::

::::{grid-item-card}

:::{image} media/laby0.png :height: 20ex :align: center :::

:::: :::::

+++ {"slideshow": {"slide_type": "fragment"}}

Le problème

On a souvent besoin de rompre l'exécution séquentielle :

+++ {"slideshow": {"slide_type": "fragment"}}

• Des instructions différentes selon le contexte :

  :::{image} media/laby3a.png :height: 5ex :align: center :alt: Le labyrinthe 3a avec petite et grande toile :::

+++ {"slideshow": {"slide_type": "fragment"}}

• Des instructions répétées :

  :::{image} media/laby2a.png :height: 5ex :align: center :alt: Un labyrinthe tout en longueur :::

+++ {"slideshow": {"slide_type": "fragment"}}

Nous avons besoin des structures de contrôle.

+++ {"slideshow": {"slide_type": "slide"}}

(instruction_conditionnelle)=

Instructions conditionnelles

+++ {"slideshow": {"slide_type": "fragment"}}

En fonction d'une condition, on va exécuter ou non un bloc d'instructions.

---
slideshow:
  slide_type: fragment
---
#include <laby/global_fr.hpp>
LABY("3a")

---
slideshow:
  slide_type: fragment
---
debut();
droite();
avance();
gauche();

+++ {"slideshow": {"slide_type": "fragment"}}

Solution complète :

---
slideshow:
  slide_type: fragment
---
LABY("3a")

---
slideshow:
  slide_type: fragment
---
debut()
droite();
avance();
gauche();

if ( regarde() == Toile ) {
    gauche();
    avance();
    avance();
    droite();
    avance();
    avance();
    droite();
    avance();
    gauche();
} else {
    avance();
    avance();
    gauche();
    avance();
    droite();
}
ouvre();

+++ {"slideshow": {"slide_type": "slide"}}

(bloc_d_instruction)= :::{prf:definition} Blocs d'instructions

Un bloc d'instructions est une suite d'instructions à exécuter successivement. Il est décrit par la syntaxe suivante :

{
    instruction 1;
    instruction 2;
    ...
    instruction n;
}

Une instruction toute seule est aussi considérée comme un bloc d'instructions.

:::

+++ {"slideshow": {"slide_type": "slide"}}

Instruction conditionnelle simple : «si ... alors ...»

:::{admonition} Syntaxe :

if ( condition ) {
    bloc d instructions;
}

:::

+++ {"slideshow": {"slide_type": "fragment"}}

:::{admonition} Sémantique

1. Évaluation de la condition
2. Si sa valeur est vraie, exécution du bloc d'instructions :::

+++ {"slideshow": {"slide_type": "fragment"}}

:::{prf:example}

if ( regarde() == Toile ) {     // Au secours, fuyons!
    gauche();
    gauche();
}

if ( x >= 0 ) gauche();

:::

+++ {"slideshow": {"slide_type": "slide"}}

Instruction conditionnelle : «si ... alors ... sinon ...»

:::{admonition} Syntaxe

if ( condition ) {
    bloc d instructions 1;
} else {
    bloc d instructions 2;
}

:::

+++ {"slideshow": {"slide_type": "fragment"}}

:::{admonition} Sémantique

1. Évaluation de la condition
2. Si sa valeur est «Vrai», exécution du bloc d'instructions 1
3. Si sa valeur est «Faux», exécution du bloc d'instructions 2 :::

+++ {"slideshow": {"slide_type": "fragment"}}

Exemples d'instruction alternative

:::{prf:example}

if ( regarde() == Toile ) {     // Au secours, fuyons!
    gauche();
    gauche();
} else {                        // Tout va bien
    avance();
}

:::

+++ {"slideshow": {"slide_type": "slide"}}

Exemples d'instruction alternative (2)

Exemple : Calcul du maximum et du minimum de x et y

---
slideshow:
  slide_type: fragment
---
int x = 3, y = 5;              // Les entrées
int maximum, minimum;          // Les sorties

if ( x > y ) {
    maximum = x;
    minimum = y;
} else {
    maximum = y;
    minimum = x;
}

minimum

maximum

+++ {"slideshow": {"slide_type": "slide"}}

Résumé

:::{admonition} Un aperçu de premiers éléments de programmation :

• Expressions, valeurs et types
• Variables (affectation ≠ égalité!)
• Fonctions
• Instructions conditionnelles (if) :::

+++ {"slideshow": {"slide_type": "fragment"}}

On reviendra dessus!