---
title: Cours de programmation séquentielle
subtitle: Variables
author: Orestis Malaspinas
<!-- date: 25 avril 2018 -->
sansfont: Sans Serif
<!-- header-includes:
	<link rel="stylesheet" href="reveal.js/lib/css/zenburn.css" >
  	<link rel="stylesheet" href="reveal.js/css/theme/simple.css" id="theme">
  	<link rel="stylesheet" href="css/console.css" id="theme">
  	<script src="jquery/dist/jquery.min.js"></script> -->
    <!-- <script src="reveal.js/lib/js/classList.js"></script> -->
    <!-- <script src="reveal.js/plugin/zoom-js/zoom.js"></script> -->
    <!-- <script src="reveal.js/plugin/highlight/highlight.js"></script> -->
    <!-- <script src="js/remote-diagrams.js"></script> -->
    <!-- <script src="reveal.js/plugin/notes/notes.js"></script> -->
<!-- include-after:
	<script src="js/playRust.js"></script>
	<script src="js/remote-code.js"></script>
	<script src="js/remote-diagrams.js"></script>
	<script src="js/em-artiste.js"></script> -->
<!-- slide-numbers: true -->
---

# Les variables

## Lien entre une valeur et un symbole

- Symbole liant un *identifiant* avec une *valeur*.
- Le *type* de la valeur peut être quelconque.
- Pour *déclarer* une variable il faut utiliser la forme:
	
	`let symbole = valeur`{.rust}.
    <pre><code data-trim="hljs rust" class="lang-rust">
    fn main() {
        let x = 5; // entier 32 bits
        println!("La valeur de x est: {}", x); // affichage

        let y = "La valeur 5 est liée avec la variable x"; // Chaîne de caractères
        println!("La valeur de y est: {}", y); // affichage
    }
    </code></pre>
- En rust le type d'une variable est **inféré** (quand c'est possible).
- Sinon il faut le donner explicitement:

	`let symbole: type = valeur`{.rust}.
    <pre><code data-trim="hljs rust" class="lang-rust">
    fn main() {
        let x: i32 = 5; // entier 32 bits
        println!("La valeur de x est: {}", x); // affichage
    }
    </code></pre>

## Quelques règles (1/2)

- Les mot-clés du langage sont interdits pour nommer les variables.

    <pre><code data-trim="hljs rust" class="lang-rust">
    fn main() {
        let if = 7;
    }
    </code></pre>

- Une variable ne peut pas être utilisée si elle n'est pas *déclarée*.

    <pre><code data-trim="hljs rust" class="lang-rust">
    fn main() {
        println!("La valeur de x est: {}", x); // affichage
    }
    </code></pre>

## Quelques règles (2/2)

- Une variable ne peut pas être utilisée si elle n'est pas *initialisée*.

    <pre><code data-trim="hljs rust" class="lang-rust">
    fn main() {
        let x: i32;
        println!("La valeur de x est: {}", x); // affichage
    }
    </code></pre>

- On peut déclarer une variable, puis l'initialiser en 2 étapes.

    <pre><code data-trim="hljs rust" class="lang-rust">
fn main() {
    let x; // Déclaration
    x = 5; // Assignation, on préfère écrire `let x = 5;`
    println!("La valeur de x est: {}", x); // affichage

    let y = "La valeur 5 est liée avec la variable x"; // Chaîne de caractères
    println!("La valeur de y est: {}", y); // affichage
}
    </code></pre>

## Portée (1/2)

- La **portée** (scope) d'une variable est le *bloc* dans lequel elle est déclarée (et tous les blocs inclus).

    <pre><code data-trim="hljs rust" class="lang-rust">
fn main() {
    let x = 5; 
    {
        println!("La valeur de x est: {}", x);
    }
}
    </code></pre>
    <pre><code data-trim="hljs rust" class="lang-rust">
fn main() {
    {
        let x = 5; 
        println!("La valeur de x est: {}", x);
    }

    println!("La valeur de x est: {}", x);
}
    </code></pre>

## Portée (2/2)

- La redéclarantion d'une variable dans un bloc intérieur **masque** (shadow) la variable extérieure.

    <pre><code data-trim="hljs rust" class="lang-rust">
fn main() {
    let x = 1000; 
    {
        let x = 5; 
        println!("La valeur de x est: {}", x);
    }

    println!("La valeur de x est: {}", x);
}
    </code></pre>

## Mutabilité/**Immutabilité**

- Les variables sont **immutables** par défaut.
- Une variable immutable **ne peut pas** être modifiée.
- Si on essaie le compilateur refuser de compiler le programme.
    <pre><code data-trim="hljs rust" class="lang-rust">
fn main() {
    let x = 5;
    println!("La valeur de x est: {}", x);

    x = 6;
    println!("La valeur de x est: {}", x);
}
    </code></pre>

## **Mutiabilité**/Immutabilité

- Pour rendre une variable **mutable** il faut utilise la forme:

    `let mut symbole = valeur`{.rust}.
- Une variable mutable **peut** être modifiée.
    <pre><code data-trim="hljs rust" class="lang-rust">
fn main() {
    let mut x = 5;
    println!("La valeur de x est: {}", x);

    x = 6;
    println!("La valeur de x est: {}", x);
}
    </code></pre>

## Constantes

- Les variables immutables ressemblent aux *constantes*.
- On les déclare avec la forme:

    `const SYMBOLE: type = valeur;`{.rust}
- Plusieurs différences notables:
	1. On ne peut pas utiliser `mut`{.rust}
    2. On doit explicitement déclarer le *type* d'une constante.
    3. La valeur d'une constante doit être déterminée à la compilation.
    4. Valides durant toute la durée d'un programme.

    <pre><code data-trim="hljs rust" class="lang-rust">
const PI: f64 = 3.14159265359;
fn main() {
    println!("La valeur de pi est: {}", PI);
}
    </code></pre>

## Masquage (Shadowing)

- Possibilité de déclarer une variable avec le même nom qu'une variable précédente.
- La nouvelle déclaration **masque** la précédente.

    <pre><code data-trim="hljs rust" class="lang-rust">
fn main() {
    let x = 5;
    let x = x + 1;
    println!("La valeur de x est: {}", x);
}
    </code></pre>

- La nouvelle variable n'a pas forcément le même type que la variable d'origine¨.

    <pre><code data-trim="hljs rust" class="lang-rust">
fn main() {
    let x = "La variable d'origine";
    println!("La valeur de x est: {}", x);
    let x = x.len();
    println!("La valeur de x est: {}", x);
}
    </code></pre>




