Justine : Page créée avec «  //Récupérer le trait debug... #[derive(Debug)] //Mon struct rectangle avec ses attributs struct Rectangle { w: u32, h: u32 } //L'implémentation du rectangle, avec ses méthodes //ce sont des méthodes parce qu'elles ont &self en paramètre //sans ça c'est des "associated functions" impl Rectangle { fn area(&self) -> u32 { self.w * self.h } fn can_hold(&self, other_rect: &Rectangle) -> bool { if other_... »

2022-11-03T09:12:20Z

Page créée avec « <source lang='rust'> //Récupérer le trait debug... #[derive(Debug)] //Mon struct rectangle avec ses attributs struct Rectangle { w: u32, h: u32 } //L'implémentation du rectangle, avec ses méthodes //ce sont des méthodes parce qu'elles ont &self en paramètre //sans ça c'est des "associated functions" impl Rectangle { fn area(&self) -> u32 { self.w * self.h } fn can_hold(&self, other_rect: &Rectangle) -> bool { if other_... »

Nouvelle page

<source lang='rust'>
//Récupérer le trait debug...
#[derive(Debug)]
//Mon struct rectangle avec ses attributs
struct Rectangle {
w: u32,
h: u32
}

//L'implémentation du rectangle, avec ses méthodes
//ce sont des méthodes parce qu'elles ont &self en paramètre
//sans ça c'est des "associated functions"
impl Rectangle {
fn area(&self) -> u32 {
self.w * self.h
}

fn can_hold(&self, other_rect: &Rectangle) -> bool {
if other_rect.area() <= self.area() {
return true;
} else {
return false;
}
}

fn w(&self) -> String {
let ret_str = String::from("You called the w method. Rust is weird.");
return ret_str;
}
}

//On peut avoir plusieurs blocs impl si on veut
impl Rectangle {
//Ici, une fonction associée
//C'est un constructeur, elle me sert à construire un carré en l'occurence
//Self est un alias pour le type qui est marqué derrière impl, donc ici
//Rectangle
fn square(size: u32) -> Self {
Self {
w: size,
h: size
}
}
}

//On a plusieurs types de structs...
//Un unit struct, vide, au même titre qu'un unit tuple ()
struct Unitaire;
//
//Le struct classique donc
struct PlutotNormal {
x: i32,
y: u32
}
//
//Et le tuple Struct
struct UnSeulTruc(String);
struct PlusieursTrucs(i32, i32, i32);

fn main() {
let rect1 = Rectangle {
w: 500,
h: 1000
};

let rect2 = Rectangle {
w: 400,
h: 1000
};

//Debug en pretty-print
//{:?} signifie debug, soit afficher la variable telle qu'écrite dans le code
//{:#?} Pareil mais en plus joli
//Il existe la macro dbg! qui fait la même chose
//...cependant l'objet doit avoir le trait debug
println!("Mon rectangle : {:#?}", rect1);

//Utiliser la méthode
println!("Area : {}", rect1.area());

if rect1.can_hold(&rect2) {
println!("Rect1 est plus grand que rect2");
}

//Une méthode de struct peut avoir le même nom qu'un des attributs
//Ce sont alors les parenthèses qui font la diff.
println!("rect1.w => {}", rect1.w);
println!("rect1.w() => {}", rect1.w());

//Utiliser mon constructeur de carré
let moncarre = Rectangle::square(200);
dbg!(moncarre);

}
</source>

Rust : Structs - Historique des versions