Valeurs de retour

Fait partie de la section Fundamentals du Journey Rust de Coddy — leçon 51 sur 75.

L'instruction return dans une méthode est utilisée pour spécifier la ou les valeurs que la méthode doit produire en tant que sortie. Par exemple, la méthode suivante produira 100 :

fn function_name() -> i32 {
	return 100;
}

Remarquez que la fonction renvoie un type de données i32 en raison du signe flèche ->.

Pour passer la valeur de retour à une variable, écrivez :

let number: i32 = function_name();

Maintenant, la variable number contiendra 100 car c'est ce que la méthode a retourné.

Notez que le type de retour de la méthode (i32 dans ce cas) doit correspondre au type de données de la variable dans laquelle vous stockez la valeur retournée.

Défi

Facile

Chaque cas de test comporte trois entrées.

La première entrée indique le nombre d'itérations à effectuer, et les deux dernières entrées sont les nombres sur lesquels nous allons effectuer des opérations.

Créez une méthode qui reçoit deux arguments et renvoie le plus grand des deux nombres. Si les deux sont égaux, renvoyez l'un d'eux.

Itérez iterations fois et pour chaque itération, faites ce qui suit :

Appelez la méthode avec num1, num2, et enregistrez le résultat dans une variable.
Divisez le plus grand nombre des deux par 2, puis remplacez la variable d'origine la plus grande par la nouvelle valeur du résultat.
Affichez la nouvelle valeur.
Continuez ainsi jusqu'à ce que le programme ait itéré iterations fois ou que l'un des nombres soit inférieur à 2.

Notez que vous avez déjà le squelette du code !

Aide-mémoire

L'instruction return spécifie la valeur qu'une fonction produit en sortie :

fn function_name() -> i32 {
    return 100;
}

Utilisez la flèche -> pour spécifier le type de retour. Stockez la valeur retournée dans une variable :

let number: i32 = function_name();

Le type de retour doit correspondre au type de données de la variable dans laquelle vous stockez la valeur retournée.

Essayez vous-même

use std::io;

fn bigger(arg1: f64, arg2: f64) -> f64 {
    // Complétez la fonction

}

fn main() {
    let mut input_iter = String::new();
    let mut input_num1 = String::new();
    let mut input_num2 = String::new();

    io::stdin().read_line(&mut input_iter).unwrap();
    io::stdin().read_line(&mut input_num1).unwrap();
    io::stdin().read_line(&mut input_num2).unwrap();

    let iter: i32 = input_iter.trim().parse().unwrap();
    let mut num1: f64 = input_num1.trim().parse().unwrap();
    let mut num2: f64 = input_num2.trim().parse().unwrap();

    for _ in 0..iter {
        // Écrivez votre code ci-dessous
    }
}