@@ -157,61 +157,89 @@ Quelques autres liens utiles :
\subsection{Hello World!}
\begin{lstlisting}[style=Rust, language=Rust]
// Dans le fichier \texttt{hello\_world.rs}
fn main() {
println!("Hello World"); // "Hello World"
println!("Hello World");
}
\end{lstlisting}
Pour compiler ce programme, on va directement utiliser \texttt{rustc}, grâce à la commande shell suivante : \texttt{rustc helloWorld.rs}.
Le binaire généré sera nommé en fonction du fichier.
Pour compiler ce programme on va directement utiliser \texttt{rustc}, avec la commande
shell suivante :
\texttt{rustc hello\_world.rs}
Le binaire généré sera nommé en fonction du fichier si on ne précise pas explicitement
un autre nom avec l'option \texttt{-o BINAIRE}.
On peut ensuite exécuter normalement \texttt{./hello\_world} qui affichera le texte
\texttt{Hello World} (avec un retour à la ligne).
\subsection{Quelques notions basiques}
Il existe les types numériques suivants en Rust :
Comme C, Rust a de nombreux types numériques de différentes tailles. Contrairement à C
les noms sont unifiés : \texttt{i}/\texttt{u}/\texttt{f} pour ``integer'', ``unsigned integer'',
``floating point'', suivi du nombre de bits.
\begin{itemize}
\item Entiers signés: \texttt{i8}, \texttt{i16}, \texttt{i32}, \texttt{i64} et \texttt{i128}.
\item Entiers non-signés: \texttt{u8}, \texttt{u16}, \texttt{u32}, \texttt{u64} et \texttt{u128}.
\item Flottants: \texttt{f32}, \texttt{f64}.
\item Entiers "tailles": \texttt{isize} et \texttt{usize}. (Équivalent de \texttt{intptr\_t} et \texttt{uintptr\_t})
\item entiers signés : \texttt{i8}, \texttt{i16}, \texttt{i32}, \texttt{i64} et \texttt{i128}.
\item entiers non signés : \texttt{u8}, \texttt{u16}, \texttt{u32}, \texttt{u64} et
\texttt{u128}.
\item flottants : \texttt{f32}, \texttt{f64}.
\item entiers de la taille de la machine : \texttt{isize} et \texttt{usize}.\\
(sont égaux à des \texttt{i32}/\texttt{u32} sur système 32 bits, et
\texttt{i64}/\texttt{u64} sur système 64 bits)
\end{itemize}
\begin{lstlisting}[style=Rust, language=Rust]
fn main() {
// Par défaut, les variables sont non-modifiable (keyword \textbf{const} en C).
let x: i8 = 1;
// Par défaut, les variables sont non-modifiables (tout comme un \texttt{let} en OCaml).
let x: i8 = 1; // x vaut 1
// \textit{variable shadowing} : nouvelle définition d'une même variable.
let x: i32 = 1;
// \texttt{let} peut redéfinir une variable qui écrase la précédente
let x = x + 1; // x vaut 2, le type est inféré à partir de l'expression
// Cette expression est donc impossible, car \textbf{x} ne peut pas être modifié.
// x = 2;
{
// une variable est visible uniquement à l'intérieur du bloc qui la définit
let x = 5; // x vaut 5
let y = 4; // y vaut 4
}
// x vaut de nouveau 2
// y n'existe plus
// pour mettre à jour une variable d'une manière visible en dehors du bloc,
// il faut la déclarer \texttt{mut} (mutable)
// Le mot clé \textbf{mut} permet de rendre modifiable une variable.
let mut y: i32 = 1;
y = 4;
let mut z: i32 = 1; // similaire à \texttt{let z = ref 1} en OCaml
z = 4;
// \textit{Note :} ici le linter génère un avertissement que z n'a pas besoin
// d'être mutable et que sa première valeur 1 est inutile.
// Appel de fonction.
let result = add(x, y);
// z vaut 4
{
z += 1;
}
// z vaut 5
// La variable \textbf{result} n'a aucune annotation sur son type.
// En effet, le type de \textbf{result} est inféré depuis la signature de la fonction \textbf{add()}.
// Appel de fonction
// (la fonction peut être définie plus tard dans le fichier,
// il n'est pas nécessaire de la déclarer)
let result = add(x, y); // ici aussi le type est deviné grâce à la signature de add
// \textit{Note :} chaque exemple explicitera les types.
// \textit{Note :} dans ce document on explicitera les types plus que nécessaire
// la plupart des fonctions en Rust peuvent s'écrire avec pour unique annotation
// de type la signature de la fonction.
println!("Result: {}", result); // "Result: 5"
}
// La fonction prend deux arguments qui sont des \textbf{i32} et retourne un \textbf{i32}.
fn add(x: i32, y: i32) -> i32 {
return x + y;
x + y // pas besoin de mot-clé return, la dernière expression est renvoyée
}
\end{lstlisting}
Le linter inclus dans le compilateur va générer un avertissement sur la variable \texttt{y}, en précisant qu'il est inutile de faire le premier assignement.
Le linter va même détecter qu'il est inutile de rendre \texttt{y} modifiable.
