Rust

Any donation is very welcome
Fork me on GitHub

I. Les bases de la programmation en Rust

8. Les fonctions

Jusqu'à présent, nous n'utilisions qu'une seule fonction : main. Pour le moment c'est amplement suffisant, mais quand vous voudrez faire des programmes beaucoup plus gros, ça deviendra vite ingérable. Je vais donc vous montrer comment créer des fonctions en Rust.

Commençons avec un exemple :

Runfn addition(nb1: i32, nb2: i32) -> i32;

Ceci est donc une fonction appelée addition qui prend 2 variables de types i32 en paramètre et retourne un i32. Rien de très différent de ce que vous connaissez déjà donc. Maintenant un exemple d'utilisation :

Runfn main() {
    println!("1 + 2 = {}", addition(1, 2));
}

fn addition(nb1: i32, nb2: i32) -> i32 {
    nb1 + nb2
}

Ce qui affiche :

1 + 2 = 3

Ceux ayant bien compris le chapitre précédent se demanderont sans doute : "Tu nous avais parlé du mot clé return mais tu ne t'en sers pas ! Comment les valeurs ont-elles été retournées ? D'ailleurs il manque pas un point-virgule là ?".

Le fait de ne pas mettre de point-virgule signifie que l'on veut que "nb1 + nb2" soit interprété comme une expression. Cependant on pourrait tout aussi bien écrire :

Runfn addition(nb1: i32, nb2: i32) ->  i32 {
    return nb1 + nb2;
}

Ne vous inquiétez pas si vous ne comprenez pas tout parfaitement, nous verrons les expressions dans le chapitre suivant. Un autre exemple pour illustrer cette différence :

Runfn get_bigger(nb1: i32, nb2: i32) ->  i32 {
    if nb1 > n2 {
        return nb1;
    }
    nb2
}

Cette façon de faire n'est cependant pas recommandée en Rust, il aurait mieux valu écrire :

Runfn get_bigger(nb1: i32, nb2: i32) ->  i32 {
    if nb1 > nb2 {
        nb1
    } else {
        nb2
    }
}

Une autre différence que certains d'entre vous auront peut-être noté (surtout ceux ayant déjà codé en C/C++) : je n'ai pas "déclaré" ma fonction addition et pourtant la fonction main l'a trouvée sans problème. Sachez juste que les déclarations de fonctions ne sont pas nécessaires en Rust (contrairement au C ou au C++ qui ont besoin de fichier "header" par exemple).

Voilà pour les fonctions, rien de bien nouveau par rapport aux autres langages que vous pourriez déjà connaître.

Il reste cependant un dernier point à éclaircir : println! et tous les appels ayant un '!' ne sont pas des fonctions, ce sont des macros.

Si vous pensez qu'elles ont quelque chose à voir avec celles que l'on peut trouver en C ou en C++, détrompez-vous ! Elles sont l'une des plus grandes forces de Rust, elles sont aussi très complètes et permettent d'étendre les possibilités du langage. Par-contre, elles sont très complexes et seront le sujet d'un autre chapitre.

Pour le moment, sachez juste que :

Runfonction!(); // c'est une macro
fonction(); // c'est une fonction

Enfin, une dernière chose : si vous souhaitez déclarer une fonction qui ne retourne rien (parce qu'elle ne fait qu'afficher du texte par exemple), vous pouvez la déclarer des façons suivantes :

Runfn fait_quelque_chose() {
    println!("Je fais quelque chose !");
}
// ou bien :
fn fait_quelque_chose() -> () {
    println!("Je fais quelque chose !");
}

"Le type () ? C'est une sorte de null ?"
Oui... Et non. En Rust, c'est un tuple vide. Son équivalent le plus proche en C/C++ est le type void.

Voilà, qui clôture ce chapitre. Il est maintenant temps de s'attaquer aux expressions !