Types
Orestis Malaspinas
4 + 12; // = 16 (entier)
1 + "a"; // aucun sens erreur de compilation (ou pas)
Il est parfois nécessaire d’annoter le type explicitement.
fn main() {
let x:i32 = 5; // entier 32 bits dont le type est annoté
let y = 5; // entier 32 bits dont le type est inféré
println!("Ces deux lignes sont équivalentes x={} et y={}", x, y); // affichage
}
isize
entier signé 32 ou 64 bits.usize
entier non-signé 32 ou 64 bits.Longueur | Signé | Non-signé |
---|---|---|
8 bits | i8 |
u8 |
16 bits | i16 |
u16 |
32 bits | i32 |
u32 |
64 bits | i64 |
u64 |
128 bit | i128 |
u128 |
32 ou 64 bits | isize |
usize |
i32
.isize
et usize
sont typiquement pour indéxer des collections.42u8
est un entier 8 bits non signé.42isize
est un entier de 32 ou 64 bits signé.1000000
comme 1_000_000
On ne peut pas convertir implicitement d’un type à un autre.
fn main() {
let x:i64 = 5i32; // entier 32 bits dans une variable 64 bits
}
On peut convertir entre les entiers à l’aide de as
.
fn main() {
let x:i64 = 5i32 as i64; // entier 32 bits dans une variable 64 bits
println!("Conversion de 32 en 64 bits pour x={}.", x); // affichage
}
fn main() {
let x = 12341324;
let y = 12341234;
println!("L'entier x vaut {}.", (x*y) as i32); // affichage
}
fn main() {
let x:i32 = 12345678;
let y:i32 = 12345678;
println!("L'entier x vaut {}.", x*y); // affichage
}
f32
,f64
.f64
On ne peut pas convertir implicitement d’un type à un autre.
fn main() {
let x:f64 = 3.14159265359f32; // flottant 32 bits en flottant 64 bits
}
On peut convertir entre les types de base avec as
.
fn main() {
let x = 3.14159265359f64 as f32; // flottant 64 bits en flottant 32 bits
println!("Conversion de pi en 32 bits, x = {}.", x); // affichage
let y = 3.14159265359f64 as isize; // flottant 64 bits en entier
println!("Conversion de pi en entier 64 bits, y = {}.", y); // affichage
}
+, -, *, /, %
fn main() {
let addition = 3 + 8;
println!("La valeur de l'addition est: {}", addition);
let soustraction = 3.5 - 8.1;
println!("La valeur de la soustraction est: {}", soustraction);
let multiplication = -3.33 * 3.33;
println!("La valeur de la multiplication est: {}", multiplication);
let division = 7 / 2; // division entière
println!("La valeur de la division est: {}", division);
}
+=, -=, *=, /=, %=
.
fn main() {
let mut addition = 3;
addition += 5;
println!("La valeur de l'addition est: {}", addition);
let mut multiplication = 3.5;
multiplication *= - 8.1;
println!("La valeur de la multiplication est: {}", multiplication);
}
bool
.true
false
if
, while
, …
fn main() {
let x = true; // Booléen inféré vrai
println!("La variable x est {}.", x); // affichage
let x: bool = false; // Booléen faux
println!("La variable x est {}.", x); // affichage
let x = false as i32; // Booléen faux
let y = true as i32; // Booléen faux
println!("False est {}, et True est {}.", x, y); // affichage
}
Comparaisons logiques ==, !=, &&, ||, <, >, <=, >=
fn main() {
let x = 3;
let y = 8;
println!("{} est-il égal à {}? {}", x, y, x == 8);
println!("{} est-il différent de {}? {}", x, y, x != 8);
}
&
^
Comparaisons bit à bit et assignations: &=, ^=
.
char
.String
.
fn main() {
let x = 'a'; // Le charactère a
println!("La variable x est {}.", x); // affichage
let chat = '😻';
println!("La variable chat est {}.", chat); // affichage
}
Struct
Tuple
Enum
Array
Vec
String