Name: Rust Développez des programmes robustes et sécurisés
Rating: 4.75 (4 reviews)

Installation et exploration

1. L’outil rustup

La méthode vivement encouragée, quel que soit le système d’exploitation que vous utilisez (Windows, macOS ou Linux), s’appelle rustup.

En vous rendant à l’URL https://rustup.rs, le site web détectera votre système d’exploitation et vous pourrez alors aisément installer Rust sur votre machine.

À titre d’exemple, voici la ligne de commande à utiliser pour installer Rust sur une machine fonctionnant sous Linux ou macOS. Comme on peut le constater, cette ligne de commande d’installation utilise le programme de requêtes HTTP cURL :

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Sur Windows, il faut télécharger un exécutable d’installation, puis le lancer.

Si votre système est très spécifique et que vous voulez adapter l’installation précisément à votre installation, cette page d’aide vous sera très utile : https://rust-lang.github.io/rustup/installation/other.html

Une fois installée, la mise à jour, c’est-à-dire l’installation de la version stable la plus récente disponible, se fera simplement avec la ligne de commande suivante dans un terminal :

rustup update

Ci-dessous, l’installation de la version stable la plus récente sur une machine macOS en novembre 2021 :

(base) benprieur@macbook-air-de-benoit ~ % rustup update 
info: syncing channel updates for 'stable-x86_64-apple-darwin' 
info: latest update on 2021-11-01, rust version 1.56.1 
(59eed8a2a 2021-11-01) 
info: downloading component 'rls' 
  7.3 MiB /   7.3 MiB (100 %) 787.2 KiB/s in  9s ETA:  0s 
info: downloading component 'rust-src' 
  2.3 MiB /   2.3 MiB (100 %) 824.0 KiB/s in  3s ETA:  0s 
info: downloading component 'rust-analysis' 
  2.8 MiB /   2.8 MiB (100 %) 824.2 KiB/s in  3s ETA:  0s 
info: downloading component 'cargo' 
  4.4 MiB /   4.4 MiB (100 %) 791.9 KiB/s in  5s ETA:  0s 
info: downloading component 'clippy' 
  1.7 MiB /   1.7...

Premiers travaux en Rust

1. Un premier exemple de programme Rust

On commence par créer un nouveau projet Rust de type exécutable :

cargo new --bin plus_loin

La création se passe correctement, comme en témoigne la réponse dans le terminal :

Created binary (application) `plus_loin` package

Prenons un exemple simple pour découvrir peu à peu le langage Rust et les premiers éléments utiles. Le but est d’offrir un jeu de quatre fonctions de calcul relatif au cercle et à la sphère :

Une première fonction qui calcule le périmètre d’un cercle.
Une deuxième fonction qui calcule la surface d’un cercle.
Une troisième fonction qui calcule la surface d’une sphère.
Une quatrième fonction qui calcule le volume d’une sphère.

Lorsque l’on compile avec le compilateur Rust (indifféremment via cargo ou rustc), les erreurs et les avertissements (warnings) seront détectés. Si vous voulez désactiver les warnings, parfois plutôt verbeux, il suffit d’écrire cette ligne en début de programme :

#![allow(unused)]

On commence par une fonction main, point d’entrée de notre exécutable dans lequel on appelle une autre fonction en charge de calculer le périmètre d’un cercle connaissant son rayon :

fn main() { 
   let p = perimetre_cercle(5.0); 
   println!("Le périmètre du cercle est égal à : {}", p); 
}

On voit que l’on appelle la fonction perimetre_cercle de façon assez classique avec une valeur de rayon égale à 5.0. On peut également constater que cet appel se ferait de façon syntaxiquement similaire en C++ ou en JavaScript par exemple. On range le résultat dans une variable p grâce au mot-clé let.

Nous détaillerons l’usage de let et son fonctionnement par la suite mais nous pouvons préciser les points suivants pour le moment.

Par défaut, une définition avec let est constante. On ne peut pas changer la valeur pointée, sauf à utiliser le mot-clé mut, qui permet justement d’avoir stricto sensu une variable. Dans notre exemple, le langage reconnaît lui-même...

Outils complémentaires autour du projet réalisé

1. Un mot sur les tests unitaires en Rust

Les tests unitaires ayant pris une importance certaine depuis quelques années, notamment grâce à la popularité du Test Driven Development (TDD), il peut être intéressant d’en parler très tôt dans cet ouvrage. D’autant que leur mise en place est plutôt simple en Rust.

Un test unitaire est un dispositif permettant de tester une fonction donnée dans un cas précis. On va vérifier qu’elle renvoie bien tel résultat, dans un cas bien précis, avec des paramètres d’entrée définis. Il en faut plusieurs pour utiliser toutes les disjonctions de la fonction (if else notamment) et ainsi avoir une couverture de test de qualité.

Le Test Driven Development (TDD), en français « développements pilotés par les tests », consiste à rédiger les tests unitaires avant même de coder le corps des fonctions testées. On s’intéresse ainsi aux entrée/sorties de la fonction avant même de réfléchir à son implémentation. Cette approche permet d’améliorer sensiblement la qualité des développements.

Nous allons écrire un premier test qui vérifie que le volume de la sphère de rayon 5.0 est bien compris entre 523 et 524 (ce qui nous permet de nous affranchir des chiffres après la virgule).

Une fonction pour chaque test sera mise en place. On sait que c’est une fonction de test unitaire car on l’indique avec l’attribut #[test] qui précède la fonction elle-même :

#[test]

Ensuite, on code notre test en utilisant un assert qui se déclenche si le résultat n’est pas attendu.

On peut ajouter ce test par exemple :

#[test] 
fn test_volume_sphere(){ 
   let resultat = volume_sphere(5.0); 
   let mut test = false; 
   if resultat > 523.0 && resultat < 524.0 
   { 
      test = true; 
   } 
   assert_eq!(test, true); 
}

On voit que :

on utilise le mot-clé mut car on fait varier la valeur contenue dans...

Nommons les choses - Un peu de vocabulaire

1. Introduction

Les chapitres qui suivent vont aborder de façon théorique, pratique et de manière approfondie chacun des concepts et notions qui font Rust. Mais il n’est pas inutile de définir plus généralement chacune de ces notions. Nous proposons une sorte de lexique, donc, auquel il sera aisé de se référer lorsqu’un aspect est évoqué de manière périphérique. En effet, tout ne peut pas être développé en même temps ; immanquablement, on se heurte parfois à l’écueil de la référence circulaire. Notons enfin que ce petit lexique, pour des raisons pédagogiques, n’est pas ordonné de façon alphabétique.

2. Petit lexique du langage Rust

a. Mutabilité

Nous avons déjà évoqué cette notion. Par défaut, en Rust, une variable est immuable. C’est évidemment une volonté de consolider la sécurité de la gestion de la mémoire avec Rust. Quand on veut notre variable mutable (muable), c’est là que l’on utilise le mot-clé mut.

b. Structure (struct)

Les structures en Rust sont (relativement) similaires à ce type d’objet en C/C++, notamment du point de vue de la contiguïté de son contenu en mémoire. Il...

Conclusion

Le chapitre suivant va nous permettre d’étudier les types en Rust, y compris les pointeurs et les références, ce qui nous permettra de parler de la gestion de la mémoire en Rust. Une fois terminé ce troisième chapitre, il sera temps d’approfondir les notions fondamentales de propriété (ownership) et d’emprunt en Rust (cf. chapitre Possession et emprunt en Rust).

Commençons à utiliser concrètement Rust