Créer un premier projet

Plutôt que de travailler dans des fichiers épars, Rust nous propose de structurer des projets (crates).

Organisation des codes sources

Pour illustrer ce propos, créons notre premier projet.

Par exemple dans ~/mesprojets, je saisis la commande

cargo new mon_premier_projet

Retour commande :

    Creating binary (application) `mon_premier_projet` package
note: see more `Cargo.toml` keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

Cargo s’est chargé de créer une structure de fichiers minimale qui se présente sous cette forme :

mon_premier_projet/
├── .git/
├── .gitignore
├── Cargo.toml
└── src/
    └── main.rs

Les deux éléments clefs que nous apprendrons à modifier bientôt sont :

• Cargo.toml : fichier de configuration du projet ;
• src/ : dossier de travail où nous disposons les codes sources de notre projet (pour le moment, un simple fichier main.rs).

(Compilation et) exécution du projet

Nous nous plaçons dans le dossier du projet pour travailler

cd mon_premier_projet

puis nous exécutons le projet avec

cargo run

Cargo se charge alors de compiler le projet puis de l’exécuter.

Retour commande :

   Compiling mon_premier_projet v0.1.0 (/home/user/mesprojets/mon_premier_projet)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.13s
     Running `target/debug/mon_premier_projet`

Affichage de notre programme :

Hello, world!

Il n’est pas possible de donner certains noms à nos projets du fait de l’organisation de Cargo. Par exemple, la commande cargo new test échoue avec un message explicatif très clair.

Organisation des fichiers et produits de compilation (build)

Si nous observons à nouveau l’arborescence de notre projet, elle se présente ainsi :

.
├── Cargo.lock
├── Cargo.toml
├── src
│   └── main.rs
└── target
    ├── CACHEDIR.TAG
    └── debug
        ├── build
        ├── deps
        │   ├── mon_premier_projet-0df163ce36d1f442
        │   └── mon_premier_projet-0df163ce36d1f442.d
        ├── examples
        ├── incremental
        │   └── mon_premier_projet-3quxu937gaaqi
        │       ├── s-hk8vkx5abq-15mx0e1-39psxwbzqm6jzctvvnaremlic
        │       │   ├── 6ebmlgxseqwl0atvo8e8mx1rq.o
        │       │   ├── 8orpsbst6x8f7sbtomzkztbr1.o
        │       │   ├── crwrq2j5zh4baxwcfl0gv3ic5.o
        │       │   ├── dep-graph.bin
        │       │   ├── eguk8f1vvf17rgcamp001y1cw.o
        │       │   ├── ewm5sh4zvjz3w4hyzio35bf8y.o
        │       │   ├── ey68lrkqdl5whqctqqc5tomw5.o
        │       │   ├── query-cache.bin
        │       │   └── work-products.bin
        │       └── s-hk8vkx5abq-15mx0e1.lock
        ├── mon_premier_projet
        └── mon_premier_projet.d

10 directories, 18 files

Rust a généré ses fichiers de travail dans le nouveau dossier target/ à la racine du projet.

Le fichier binaire compilé exécutable est target/debug/mon_premier_projet. Nous pouvons le copier ou le déplacer et l’exécuter à loisir (tout comme le fichier compilé que nous avions créé avec notre premier programme compilé avec rustc).

Mode debug et mode release

Comme son nom l’indique clairement, le dossier target/debug/ contient des fichiers destinés au débogage / développement du programme.

Le fichier binaire compilé exécutable target/debug/mon_premier_projet, quoique parfaitement utilisable, n’est pas le fichier qu’il est recommandé d’utiliser.

Création du fichier release

Lorsque nous y sommes prêts, nous pouvons passer à la construction d’une version release de notre programme.

Pour ce faire, nous pouvons utiliser :

cargo build --release # compilation (build) uniquement
# ET / OU
cargo run --release # compilation et exécution (run)

Le fichier ainsi généré, target/release/mon_premier_projet, est le fichier binaire de notre programme final.

Affichage des modes de compilation

Le retour commande est différent :

Version par défaut (debug)

Retour commande :

    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.09s

Version release

Retour commande :

    Finished `release` profile [optimized] target(s) in 0.06s