Version 0.6

etape5/ex5_1.rs

@@ -0,0 +1,15 @@
+struct Member { // créer une structure
+id : i32, // member : type
+name : String,
+working : bool,
+}
+fn main() {
+let clerk = Member { // initialiser la structure
+id : 016320, // membre : valeur
+name : "Smith".to_string(), 
+working : true,
+} ;
+	println ! ("ID = {}", clerk.id ) ; // accès aux membres
+	println ! ("Nom est {}", clerk.name ) ;
+	println ! ("Working vaut {}", clerk.working ) ;
+}

etape5/ex5_2.rs

@@ -0,0 +1,8 @@
+struct Square { // crée une structure
+len : i32,
+wid : i32,
+}
+fn main() {
+let table = Square { len : 10, wid : 8 } ; // initialisation
+println ! ("La surface vaut {}", table.len*table.wid ) ; // accès
+}

etape5/ex5_3.rs

@@ -0,0 +1,20 @@
+enum Langage { // définit un enum
+JS, // membre
+Rust,
+VB
+}
+fn programme(var : Langage){
+   match var{ // utilisation de l'instruction match
+        Langage::JS=> println ! ("Java Script"),
+        Langage::Rust=> println ! ("Rust"),
+        Langage::VB=> println ! ("Visual Basic"),
+   }
+}
+fn main(){
+        print!("Je n'aime pas le ") ;
+        programme( Langage::VB ) ; // accès au membre
+        print!("Je ne programme pas en ") ;
+        programme( Langage::JS ) ; // accès au membre
+        print!("Je programme en ") ;
+        programme( Langage::Rust ) ; // accès au membre
+}

etape5/ex5_4.rs

@@ -0,0 +1,7 @@
+fn main(){
+
+let x = String::from("E2L") ; // x est propriétaire de "E2L".
+let y = x ; // Attention ! La propriété de x passe à y
+
+	println ! ("{}", x) ; // Erreur ! x n'est plus disponible
+}

etape5/ex5_5.rs

@@ -0,0 +1,14 @@
+fn main() {
+let s =String::from("Il fait beau") ; // s est propriétaire 
+							   // de "Il fait beau".
+let n=cal( s ) ; // Attention ! s perdra sa propriété 
+			  // après avoir été utilisé
+
+println ! ("Contenu de s : {}", s ) ; // s n'est plus disponible
+println ! ("La longueur de la chaîne est : {}",n) ;
+
+}
+
+fn cal(s : String) -> usize {
+   s.len() // obtient la longueur de la chaîne de caractères
+}

etape5/ex5_6.rs

@@ -0,0 +1,10 @@
+fn main()  {
+let s=String :: from("Vive le Rust !");
+let n=cal( &s );     // reference
+	println ! ("Contenu de s : {}",s);
+	println ! ("Longueur de la chaîne : {}",n);
+}
+
+fn cal(s :&String ) -> usize {      // reference
+	s.len()    // retourne la longueur de la chaine
+}

etape6/ex6_1.rs

@@ -0,0 +1,8 @@
+mod mon_module { // définit un module
+   pub fn test(){ // pub signifie attribut public
+      println ! ("Bonjour mes amis ! ") ;
+   }
+}
+fn main(){
+   mon_module::test() ; // exécute le module
+}

etape6/ex6_2.rs

@@ -0,0 +1,14 @@
+mod m1{
+   pub fn a(){
+   println ! ("module m1") ;
+   }
+   pub mod m2 { // module embarqué
+      pub fn b(){
+          println ! ("module m2") ;
+      }
+   }
+}
+fn main(){
+m1::a() ;
+m1::m2::b() ; // exécute le module et la fonction embarqués
+}

etape6/ex6_3.rs

@@ -0,0 +1,3 @@
+pub fn ex_fun() {
+	println ! ("{}", "Texte externe") ;
+}

etape6/ex6_4.rs

@@ -0,0 +1,5 @@
+mod ex6_3 ; // charge un fichier externe
+use ex6_3::ex_fun ; // charge une fonction externe
+fn main () {
+  ex_fun() ; // appelle la fonction externe
+}

etape6/ex6_5.rs

@@ -0,0 +1,12 @@
+mod mon_module {
+     pub fn a() { // la fonction est publique
+        println ! ("fonction a") ;
+     }
+     fn b(){ // la fonction b est privée
+        println ! ("fonction b") ;
+     }
+}
+fn main() {
+	mon_module::a() ;
+	mon_module::b() ; // appelle une fonction privée
+}

etape6/ex6_6.rs

@@ -0,0 +1,12 @@
+mod mon_module {
+     pub fn a() { 
+        println ! ("fonction a") ;
+        b() ; // appelle la fonction privée b
+     }  
+     fn b() { // la fonction b est privée 
+        println ! ("fonction b") ;
+     } 
+} 
+fn main() { 
+   mon_module::a() ;  
+}

etape6/ex6_7.rs

@@ -0,0 +1,15 @@
+mod sup_module{ // module parent
+   fn a() -> i32 {        
+      100
+   }  
+   pub mod sub_module { // module enfant
+      use super::a ; // accès à la fonction parentale a
+      pub fn b() {
+       println ! ("{}", a() ) ; // appelle la fonction parentale a
+      }
+   }
+} 
+
+fn main() { 
+sup_module::sub_module::b() ; // appelle la fonction b
+}