Version 0.8

etape7/ex7_1.rs

@@ -0,0 +1,7 @@
+fn main() {     
+let v = vec ![100, 200, 300, 400] ; // crée un vecteur
+println ! ("Le premier élément est : {}",v[0]) ; // accède au premier élément
+println ! ("Le deuxième élément est : {}",v[1]) ;    
+println ! ("Le troisième élément est : {}",v[2]) ; 
+println ! ("Le quatrième élément est : {}",v[3]) ; 
+}

etape7/ex7_2.rs

@@ -0,0 +1,6 @@
+fn main() {     
+let v =vec ! [8 ; 3] ; // répété trois fois
+	println ! ("Le premier élément est : {}",v[0]) ; 
+	println ! ("Le deuxième élément est : {}",v[1]) ; 
+	println ! ("Le troisième élément est : {}",v[2]) ; 
+}

etape7/ex7_3.rs

@@ -0,0 +1,11 @@
+fn main() {
+let mut v=Vec::new() ; // crée un vecteur
+v . push('R') ; // définit R comme le premier élément du vecteur
+v . push('U') ;
+v . push('S') ;
+v . push('T') ;
+v . push('\n') ;
+    for n in v {
+       print ! ("{}",n) ;
+    }
+}

etape7/ex7_4.rs

@@ -0,0 +1,8 @@
+fn main(){
+let num = 3 ;
+   match num {
+   1 => println ! ("un"),
+   2 | 3 => println ! ("deux ou trois"), // motifs multiples
+   _ => println ! ("autres"),
+   }
+}

etape7/ex7_5.rs

@@ -0,0 +1,7 @@
+fn main(){
+let x = 3 ;
+	match x {
+	2 ... 6 => println ! ("de 2 à 6"), // correspondance de 2 à 6
+	_ => println ! ("autres"),
+	}
+}

etape7/ex7_6.rs

@@ -0,0 +1,7 @@
+fn main(){
+let x = 5 ;
+	match x {
+	var @ 2 ... 6 => println ! ("{}",var), // liaison
+	_ => println ! ("autres"),
+	}
+}

etape7/ex7_7.rs

@@ -0,0 +1,22 @@
+fn main(){
+  let x : Option<bool> = Some(true) ; // paramètres génériques
+  let y : Option<i32> = Some(10) ;
+  let z : Option<f64> = Some(20.88) ;
+  let n : Option<i32> = None ;
+  match x {
+    Some(x) => { println ! ("x = {}", x) },
+    None => { println ! ("x = Vide") },
+  }
+  match y {
+    Some(y) => { println ! ("y = {}", y) },
+    None => { println ! ("y = Vide") },
+  }
+  match z {
+    Some(z) => { println ! ("z = {}", z) },
+    None => { println ! ("z = Vide") },
+  }
+  match n {
+    Some(n) => { println ! ("n = {}", n) },
+    None => { println ! ("n = Vide") },
+  }
+}

etape8/ex8_1.rs

@@ -0,0 +1,14 @@
+struct Circle{ // création d'une structure de type
+	radius : f32, // membre de la structure
+}
+impl Circle{ // implémente la structure
+	fn area(&self) -> f32 { // définit une méthode
+		std::f32::consts::PI * self.radius * self.radius
+	}     // corps de la méthode
+}
+
+fn main(){
+let obj = Circle { radius : 2000.00} ; // crée un objet structuré
+  println ! ("L'aire du cercle est : {}", obj.area()) ; // appelle
+											//la méthode
+}

etape8/ex8_2.rs

@@ -0,0 +1,19 @@
+struct Cercle{ // créez une structure de type
+	rayon : f32, // membre de la structure
+}
+
+trait Calculate { // définir un trait
+	fn aire(&self) -> f32 ; // Définit une méthode de trait.
+}
+
+impl Calculate for Cercle { // implémente la fonction
+	fn aire(&self) -> f32 { // implémente la méthode du trait   
+		std::f32::consts::PI * self . rayon * self.rayon
+	}  
+}
+
+fn main(){
+let obj = Cercle { rayon : 2000.00} ; // crée un objet structuré
+	println ! ("L'aire du cercle est : {}", obj.aire()) ;
+    // dans le println on appelle la méthode
+}

etape8/ex8_3.rs

@@ -0,0 +1,12 @@
+pub trait Show { // définit un trait
+  fn show(&self) ; // définition d'une méthode de trait
+}
+impl<T> Show for T // implémente le trait avec un générique
+where T : ToString{ // spécifie le type String
+  fn show (&self) { // implémente la méthode de trait de caractère
+     print ! ("{}",self . to_string()) ;
+  }
+}
+fn main(){
+String :: from("Tout fonctionne !\n") . show() ; // appel de la méthode
+}

etape8/ex8_4.rs

@@ -0,0 +1,14 @@
+struct Jeu {
+   numero : i32,
+}
+impl Drop for Jeu {
+   fn drop(&mut self) { // Définit une méthode d'abandon.
+      println ! ("Le numéro gagnant est le { } !", self.numero) ;
+   }
+}
+
+fn main() {
+let _baseball = Jeu { numero : 3 } ;
+let _football = Jeu { numero : 2 } ;
+let _basketball = Jeu { numero : 1 } ;
+}

etape8/ex8_5.rs

@@ -0,0 +1,5 @@
+fn main(){
+let ma_fermeture = | num : i32 | { num+200 }; //crée une fermeture
+let num = 100 ;
+	println ! ("{}", ma_fermeture(num) ) ; // appelle la fermeture
+}

etape8/ex8_6.rs

@@ -0,0 +1,9 @@
+fn main() {
+let mut capacity = "Capacité du disque dur : 5000".to_string() ;
+ {
+ let mut maferm = | c : char | {capacity.push(c)} ; // fermeture
+  maferm('G') ; // appel de la fermeture
+ }
+ println ! ("{:}", capacity) ; // {:} est utilisé pour sortir
+						   // une chaîne de caractères
+}