Cours de programmation séquentielle

Variables

Orestis Malaspinas

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.


  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
  }

En rust le type d’une variable est inféré (quand c’est possible).

Sinon il faut le donner explicitement:

let symbole: type = valeur.


  fn main() {
      let x: i32 = 5; // entier 32 bits
      println!("La valeur de x est: {}", x); // affichage
  }

Quelques règles (1/2)

Les mot-clés du langage sont interdits pour nommer les variables.
```
  fn main() {
      let if = 7;
  }
  
```

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


  fn main() {
      println!("La valeur de x est: {}", x); // affichage
  }

Quelques règles (2/2)

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


  fn main() {
      let x: i32;
      println!("La valeur de x est: {}", x); // affichage
  }

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


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
}

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).


fn main() {
  let x = 5; 
  {
      println!("La valeur de x est: {}", x);
  }
}


fn main() {
  {
      let x = 5; 
      println!("La valeur de x est: {}", x);
  }

  println!("La valeur de x est: {}", x);
}

Portée (2/2)

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


fn main() {
  let x = 1000; 
  {
      let x = 5; 
      println!("La valeur de x est: {}", x);
  }

  println!("La valeur de x est: {}", x);
}

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.


fn main() {
  let x = 5;
  println!("La valeur de x est: {}", x);

  x = 6;
  println!("La valeur de x est: {}", x);
}

Mutiabilité/Immutabilité

Pour rendre une variable mutable il faut utilise la forme:
let mut symbole = valeur.

Une variable mutable peut être modifiée.


fn main() {
  let mut x = 5;
  println!("La valeur de x est: {}", x);

  x = 6;
  println!("La valeur de x est: {}", x);
}

Constantes

Les variables immutables ressemblent aux constantes.
On les déclare avec la forme:
const SYMBOLE: type = valeur;
Plusieurs différences notables:
1. On ne peut pas utiliser mut
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.
```
const PI: f64 = 3.14159265359;
fn main() {
  println!("La valeur de pi est: {}", PI);
}
  
```

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.


fn main() {
  let x = 5;
  let x = x + 1;
  println!("La valeur de x est: {}", x);
}

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


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);
}