Votre premier "Hello, world!" avec `cargo new`

Le rite de passage de tout programmeur : le "Hello, world!"

Après avoir installé Rust et configuré votre éditeur de code, le moment est venu de franchir une étape symbolique mais essentielle dans l'apprentissage de tout nouveau langage de programmation : écrire et exécuter votre premier programme "Hello, world!". En Rust, cet exercice est non seulement simple, mais il vous introduit également à Cargo, l'outil de gestion de projet et de build qui sera votre compagnon constant.

L'objectif de ce sous-chapitre est de vous montrer comment utiliser la commande `cargo new` pour initialiser un nouveau projet Rust, de comprendre la structure de base d'un projet généré par Cargo, d'examiner le code minimal pour afficher "Hello, world!", et enfin, de compiler et d'exécuter votre programme. C'est une première incursion pratique qui solidifiera votre configuration et vous donnera un premier aperçu du flux de travail typique en Rust.

Initialisation du projet avec `cargo new`

Cargo simplifie grandement la création de nouveaux projets Rust. Pour commencer, ouvrez votre terminal ou votre invite de commandes.

Naviguez jusqu'au répertoire où vous souhaitez stocker vos projets Rust. Par exemple, si vous avez un dossier `projets` dans votre répertoire personnel, vous pouvez y aller avec une commande comme `cd ~/projets` (sur Linux/macOS) ou `cd C:\Users\VotreNom\Documents\projets` (sur Windows, adaptez le chemin).

Une fois dans le répertoire souhaité, exécutez la commande suivante pour créer un nouveau projet binaire (une application exécutable) nommé `hello_monde` :

cargo new hello_monde

Après avoir exécuté cette commande, Cargo va créer un nouveau répertoire nommé `hello_monde` et y placer quelques fichiers. Vous devriez voir un message de confirmation similaire à celui-ci :

     Created binary (application) `hello_monde` package

Si vous listez le contenu du répertoire `hello_monde` (par exemple, avec `ls hello_monde` ou en l'ouvrant dans votre explorateur de fichiers), vous trouverez la structure suivante :

hello_monde/
├── Cargo.toml
└── src/
    └── main.rs

• `Cargo.toml` : C'est le fichier manifeste de votre package. Il est au format TOML (Tom's Obvious, Minimal Language) et contient les métadonnées de votre projet, comme son nom, sa version, ses auteurs, et ses dépendances. Pour un nouveau projet, il sera assez simple.
• `src/` : C'est le répertoire qui contient votre code source.
• `src/main.rs` : C'est le fichier source principal pour un projet binaire. Par convention, c'est là que la fonction `main`, le point d'entrée de votre application, est définie.

Cargo a également initialisé un dépôt Git dans le répertoire `hello_monde` si vous avez Git installé sur votre système, en y ajoutant un fichier `.gitignore` préconfiguré pour Rust. C'est une bonne pratique pour la gestion de version dès le début.

Examen du code source généré (`src/main.rs`)

Maintenant, ouvrez le fichier `src/main.rs` avec votre éditeur de code configuré (comme VS Code avec `rust-analyzer`). Cargo y a déjà placé un programme "Hello, world!" minimaliste :

fn main() {
    println!("Hello, world!");
}

Décortiquons ce code :

• `fn main() { ... }` : Cette ligne définit une fonction nommée `main`. La fonction `main` est spéciale : c'est toujours le premier code qui s'exécute dans un programme Rust binaire. Le mot-clé `fn` est utilisé pour déclarer une nouvelle fonction. Les parenthèses `()` indiquent qu'il n'y a pas de paramètres pour cette fonction, et les accolades `{}` délimitent le corps de la fonction.
• `println!("Hello, world!");` : Cette ligne effectue le travail d'affichage.
  • `println!` est une macro Rust. Les macros sont une forme de métaprogrammation en Rust qui permet d'écrire du code qui écrit du code. Vous pouvez les reconnaître au point d'exclamation `!` à la fin de leur nom. `println!` est une macro courante pour afficher du texte sur la console (sortie standard).
  • `"Hello, world!"` est une chaîne de caractères littérale (un string literal). C'est le texte que nous voulons afficher.
  • La ligne se termine par un point-virgule `;`. En Rust, la plupart des instructions (statements) doivent se terminer par un point-virgule.
• L'indentation (ici, quatre espaces) est une convention pour améliorer la lisibilité, mais n'est pas syntaxiquement requise par le compilateur comme en Python. Cependant, l'utilisation de `rustfmt` (généralement via `cargo fmt`) formatera automatiquement votre code selon les standards de la communauté.

Compilation et exécution avec `cargo run`

Pour compiler et exécuter votre programme "Hello, world!", retournez à votre terminal. Assurez-vous que vous êtes toujours dans le répertoire racine de votre projet, c'est-à-dire `hello_monde`. Si ce n'est pas le cas, naviguez-y avec la commande `cd hello_monde`.

Ensuite, exécutez la commande suivante :

cargo run

Cette simple commande demande à Cargo de faire deux choses :

1. Compiler votre projet : Cargo invoque `rustc` (le compilateur Rust) pour traduire votre code source en un fichier exécutable. La première fois que vous compilez, cela peut prendre quelques secondes car Cargo doit résoudre les dépendances (même s'il n'y en a pas d'explicites pour ce projet simple) et préparer l'environnement de build. Les fois suivantes, si le code n'a pas changé, la compilation sera beaucoup plus rapide car Cargo ne recompile que ce qui est nécessaire. Les artefacts de compilation (comme le fichier exécutable) sont placés dans un sous-répertoire `target/debug/` (pour les builds de développement non optimisés).
2. Exécuter le binaire compilé : Une fois la compilation réussie, Cargo exécute le programme.

Si tout s'est bien passé, vous devriez voir la sortie suivante dans votre terminal :

   Compiling hello_monde v0.1.0 (/chemin/vers/votre/projet/hello_monde)
    Finished dev [unoptimized + debuginfo] target(s) in Xs
     Running `target/debug/hello_monde`
Hello, world!

(Les temps et les messages exacts peuvent légèrement varier.)

Vous pouvez également séparer les étapes de compilation et d'exécution :

• `cargo build` : Compile le projet. L'exécutable se trouvera dans `target/debug/hello_monde` (ou `target\debug\hello_monde.exe` sur Windows).
• Après un `cargo build` réussi, vous pouvez exécuter le programme manuellement : `./target/debug/hello_monde` (Linux/macOS) ou `target\debug\hello_monde.exe` (Windows).

Pour un build optimisé destiné à la production, vous utiliseriez `cargo build --release`. L'exécutable serait alors dans `target/release/`.

Félicitations ! Vous avez successfully créé, compilé, et exécuté votre premier programme en Rust en utilisant Cargo. Ce flux de travail (`cargo new`, éditer, `cargo run`/`cargo build`, `cargo test`) est celui que vous utiliserez pour tous vos projets Rust. Vous êtes maintenant prêt à explorer des concepts plus avancés du langage.