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

Fait partie de la section Logic & Flow du Journey Rust de Coddy — leçon 46 sur 66.

Lorsque vous travaillez avec des fonctions qui retournent Result, vous avez souvent besoin de gérer les erreurs soit en les traitant localement, soit en les transmettant à la fonction appelante. Rust fournit un opérateur élégant pour ce motif courant : l'opérateur point d'interrogation ?.

L'opérateur ? offre un moyen propre de propager les erreurs sans écrire d'instructions match verbeuses. Lorsque vous placez ? après un Result, il déballe automatiquement une valeur Ok ou retourne immédiatement de 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, retourne l'erreur
    Ok(number * 2) // En cas de succès, double le nombre
}

Ceci équivaut à é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'assigne à number. S'il renvoie un Err, le ? renvoie immédiatement cette erreur de l'ensemble de la fonction.

Notez la syntaxe ::<i32> — cela s'appelle un turbofish, et elle indique à Rust dans quel type analyser la chaîne de caractères. La fonction renvoie Result<i32, std::num::ParseIntError>, où i32 est le type de succès et std::num::ParseIntError est le type d'erreur renvoyé en cas d'échec de l'analyse.

L'opérateur ? ne peut être utilisé que dans des fonctions qui retournent un Result (ou Option), car il doit pouvoir retourner une erreur.

Défi

Facile

Vous recevrez deux entrées. La première entrée est une chaîne de caractères qui doit être analysée en un entier, et la deuxième entrée est une autre chaîne qui doit également être analysée en un entier. Créez une fonction appelée add_numbers qui prend deux tranches de chaînes (string slices) en paramètres et renvoie un Result<i32, std::num::ParseIntError>. À l'intérieur de 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 en utilisant match.

Exigences :

Lire la première entrée (le premier nombre sous forme de chaîne) et supprimer les espaces blancs
Lire la deuxième entrée (le deuxième nombre sous forme de chaîne) et supprimer les espaces blancs
Créer une fonction add_numbers qui prend deux paramètres &str et renvoie Result<i32, std::num::ParseIntError>
À l'intérieur de la fonction, analyser la première chaîne en i32 en utilisant l'opérateur ?
Analyser la deuxième chaîne en i32 en utilisant l'opérateur ?
Renvoyer Ok(sum) où sum est l'addition des deux nombres analysés
Appeler la fonction avec les deux chaînes d'entrée
Utiliser une expression match pour gérer le Result
Dans la branche Ok(value), afficher : Sum: [value]
Dans la branche Err(_), afficher : Parsing error

Entrée :

Première ligne : Une chaîne représentant un nombre (par exemple, 15)
Deuxième 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 des chaînes 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)
    // Affichez "Parsing error" pour Err(_)
}