Rust : Structs

<source lang='rust'> //Récupérer le trait debug...

1. [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>