L'opérateur point d'interrogation '?'

Fait partie de la section Logique & Flux du Journey Rust de Coddy. Leçon 46 sur 66.

Lorsque vous travaillez avec des fonctions qui renvoient Result, vous devez souvent gérer les erreurs soit localement, soit en les transmettant à la fonction appelante. Rust fournit un opérateur élégant pour ce schéma courant : l’opérateur point d’interrogation ?.

L’opérateur ? offre un moyen clair de propager les erreurs sans écrire d’instructions match verbeuses. Lorsque tu places ? après un Result, il décompacte automatiquement une valeur Ok ou retourne immédiatement depuis la fonction actuelle avec l’Err :

fn parse_and_double(s: &str) -> Result<i32, std::num::ParseIntError> {
    let number = s.parse::<i32>()?; // Si l'analyse échoue, renvoyer l'erreur
    Ok(number * 2) // Si réussi, doubler le nombre
}

Cela revient à écrire une instruction match complète, mais de manière beaucoup plus concise. Si s.parse::<i32>() renvoie un Ok, le ? extrait la valeur et l’affecte à number. Si elle renvoie un Err, le ? renvoie immédiatement cette erreur depuis toute la fonction.

Notez la syntaxe ::<i32>. C’est ce qu’on appelle un turbofish, et elle indique à Rust dans quel type analyser la chaîne. La fonction renvoie Result<i32, std::num::ParseIntError>, où i32 est le type en cas de réussite et std::num::ParseIntError est le type d’erreur renvoyé lorsque l’analyse échoue.

L’opérateur ? peut uniquement être utilisé dans des fonctions qui renvoient un Result (ou Option), puisqu’il doit pouvoir renvoyer une erreur.

Défi

Facile

Vous recevrez deux entrées. La première entrée est une chaîne qui doit être analysée comme un entier, et la seconde entrée est une autre chaîne qui doit également être analysée comme un entier. Créez une fonction appelée add_numbers qui prend deux tranches de chaînes comme paramètres et renvoie un Result<i32, std::num::ParseIntError>. Dans la fonction, utilisez l’opérateur ? pour analyser les deux chaînes et renvoyer leur somme enveloppée dans Ok. Appelez la fonction avec les deux entrées et gérez le résultat à l’aide de match.

Exigences :

Lisez la première entrée (premier nombre sous forme de chaîne) et supprimez les espaces superflus
Lisez la seconde entrée (second nombre sous forme de chaîne) et supprimez les espaces superflus
Créez une fonction add_numbers qui prend deux paramètres &str et renvoie Result<i32, std::num::ParseIntError>
Dans la fonction, analysez la première chaîne en i32 à l’aide de l’opérateur ?
Analysez la seconde chaîne en i32 à l’aide de l’opérateur ?
Renvoyez Ok(sum), où sum est l’addition des deux nombres analysés
Appelez la fonction avec les deux chaînes d’entrée
Utilisez une expression match pour gérer le Result
Dans le bras Ok(value), affichez : Sum: [value]
Dans le bras Err(_), affichez : Parsing error

Entrée :

Première ligne : une chaîne représentant un nombre (par exemple, 15)
Seconde ligne : une chaîne représentant un autre nombre (par exemple, 27)

Sortie :

Si les deux chaînes sont des nombres valides : Sum: [result]
Si l’une ou l’autre chaîne ne peut pas être analysée : Parsing error

Essayez vous-même

use std::io;

// TODO: Créez la fonction add_numbers ici
// Elle doit prendre deux paramètres &str et retourner Result<i32, std::num::ParseIntError>


fn main() {
    // Lire la première entrée
    let mut input1 = String::new();
    io::stdin().read_line(&mut input1).expect("Failed to read line");
    let input1 = input1.trim();
    
    // Lire la deuxième entrée
    let mut input2 = String::new();
    io::stdin().read_line(&mut input2).expect("Failed to read line");
    let input2 = input2.trim();
    
    // TODO: Appelez add_numbers avec input1 et input2
    // TODO: Utilisez match pour gérer le Result
    // Affichez "Sum: [value]" pour Ok(value)
    // Print "Parsing error" for Err(_)
}