From 0f392aa376d681ba5ff65a37b25f7d02afc1a975 Mon Sep 17 00:00:00 2001 From: patrick Date: Wed, 21 Dec 2022 20:07:28 +0100 Subject: [PATCH] Version 0.6 --- etape5/ex5_1.rs | 15 +++++++++++++++ etape5/ex5_2.rs | 8 ++++++++ etape5/ex5_3.rs | 20 ++++++++++++++++++++ etape5/ex5_4.rs | 7 +++++++ etape5/ex5_5.rs | 14 ++++++++++++++ etape5/ex5_6.rs | 10 ++++++++++ etape6/ex6_1.rs | 8 ++++++++ etape6/ex6_2.rs | 14 ++++++++++++++ etape6/ex6_3.rs | 3 +++ etape6/ex6_4.rs | 5 +++++ etape6/ex6_5.rs | 12 ++++++++++++ etape6/ex6_6.rs | 12 ++++++++++++ etape6/ex6_7.rs | 15 +++++++++++++++ 13 files changed, 143 insertions(+) create mode 100644 etape5/ex5_1.rs create mode 100644 etape5/ex5_2.rs create mode 100644 etape5/ex5_3.rs create mode 100644 etape5/ex5_4.rs create mode 100644 etape5/ex5_5.rs create mode 100644 etape5/ex5_6.rs create mode 100644 etape6/ex6_1.rs create mode 100644 etape6/ex6_2.rs create mode 100644 etape6/ex6_3.rs create mode 100644 etape6/ex6_4.rs create mode 100644 etape6/ex6_5.rs create mode 100644 etape6/ex6_6.rs create mode 100644 etape6/ex6_7.rs diff --git a/etape5/ex5_1.rs b/etape5/ex5_1.rs new file mode 100644 index 0000000..2292998 --- /dev/null +++ b/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 ) ; +} diff --git a/etape5/ex5_2.rs b/etape5/ex5_2.rs new file mode 100644 index 0000000..95bc143 --- /dev/null +++ b/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 +} diff --git a/etape5/ex5_3.rs b/etape5/ex5_3.rs new file mode 100644 index 0000000..0ecd862 --- /dev/null +++ b/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 +} diff --git a/etape5/ex5_4.rs b/etape5/ex5_4.rs new file mode 100644 index 0000000..4bb8dd8 --- /dev/null +++ b/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 +} diff --git a/etape5/ex5_5.rs b/etape5/ex5_5.rs new file mode 100644 index 0000000..a3d4777 --- /dev/null +++ b/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 +} diff --git a/etape5/ex5_6.rs b/etape5/ex5_6.rs new file mode 100644 index 0000000..ca9df16 --- /dev/null +++ b/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 +} diff --git a/etape6/ex6_1.rs b/etape6/ex6_1.rs new file mode 100644 index 0000000..73a0450 --- /dev/null +++ b/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 +} diff --git a/etape6/ex6_2.rs b/etape6/ex6_2.rs new file mode 100644 index 0000000..97bcd66 --- /dev/null +++ b/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 +} diff --git a/etape6/ex6_3.rs b/etape6/ex6_3.rs new file mode 100644 index 0000000..2ff7764 --- /dev/null +++ b/etape6/ex6_3.rs @@ -0,0 +1,3 @@ +pub fn ex_fun() { + println ! ("{}", "Texte externe") ; +} diff --git a/etape6/ex6_4.rs b/etape6/ex6_4.rs new file mode 100644 index 0000000..a02b7b1 --- /dev/null +++ b/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 +} diff --git a/etape6/ex6_5.rs b/etape6/ex6_5.rs new file mode 100644 index 0000000..b90ee87 --- /dev/null +++ b/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 +} diff --git a/etape6/ex6_6.rs b/etape6/ex6_6.rs new file mode 100644 index 0000000..54b689e --- /dev/null +++ b/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() ; +} diff --git a/etape6/ex6_7.rs b/etape6/ex6_7.rs new file mode 100644 index 0000000..89a58ca --- /dev/null +++ b/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 +}