7月4日学习笔记

1、枚举与模式匹配

1.1 类似于c语言的方式定义

  enum IpAddKind {    
     V4,
     V6,
  };

  struct IpAddr {
     kind: IpAddKind,
     address: String,
  };

  let i1 = IpAddr {
     kind: IpAddKind::V4,
     address: String::from("127.0.0.1"),
  };

  let i2 = IpAddr {
     kind: IpAddKind::V6,
     address: String::from("::1"),
  };

1.2 rust语言提倡的方式定义

  enum IpAddr2 {    
     V4(String),
     V6(String),
  };
  let i1 = IpAddr2::V4(String::from("127.0.0.1"));
  let i2 = IpAddr2::V6(String::from("::1"));

1.3 可以是不同类型

  enum IpAddr3 {    
     V4(u8, u8, u8, u8), 
     V6(String),   
  };
  
  let i1 = IpAddr3::V4(127, 0, 0, 1);
  let i2 = IpAddr3::V6(String::from("::1"));

1.4 经典用法

  enum Message {
     Quit,
     Move{x:i32, y:i32},
     Write(String),
     Change(i32, i32, i32),
  };
  //等同于
  //Struct QuitMessage;//类单元结构体
  //struct MoveMessage {
  //   x: i32,
  //   y: i32,
  //}
  //struct WriteMessage (String)
  //struct Change(i32, i32, i32)

1.5 枚举类型的方法以及match

  enum IpAddKind {
     V4,
     V6,
  };
  struct IpAddr {
     kind: IpAddKind,
     address: String,
  };
  enum IpAddr2 {
     V4(String),
     V6(String),
  };
  enum IpAddr3 {
     V4(u8, u8, u8, u8),
     V6(String),
  };
  enum Message {
     Quit,
     Move{x:i32, y:i32},
     Write(String),
     Change(i32, i32, i32),
  };
 
   //5 枚举类型的方法以及match
   impl Message {
      fn prin(&self){
         match *self {  //简引用
            Message::Quit => println!("Quit"),
            Message::Move{x, y} => println!("Move x = {}, y = {}", x, y),
            Message::Change(a, b, c) => println!("Change a = {}, b = {}, c =     {}", a, b, c),
            _ => println!("Write"), //default
            //Message::Write(&s) => println!("Write = {}",s),   //为什么这里传的是引用?
          }
      }
   }


  fn main() {

     let i1 = IpAddr {
        kind: IpAddKind::V4,
        address: String::from("127.0.0.1"),
     };
 
     let i2 = IpAddr {
        kind: IpAddKind::V6,
        address: String::from("::1"),
     };

     let i1 = IpAddr2::V4(String::from("127.0.0.1"));
     let i2 = IpAddr2::V6(String::from("::1"));
 
     let i1 = IpAddr3::V4(127, 0, 0, 1);
     let i2 = IpAddr3::V6(String::from("::1"));

     let quit = Message::Quit;
     quit.prin();

     let mo = Message::Move{x:10,y:20};
     mo.prin();

     let wri = Message::Write(String::from("Hello"));
     wri.prin();

     let change = Message::Change(1, 2, 3);
     change.prin();

     println!("Hello, world!");
  }

2 枚举：option类型

2.1 Option是标准库定义的一个枚举，形式：

   enum Option<T> {   //T是泛型
      Some(T),
      None,
   }

2.2 使用方式

第一种使用方法：

   fn main() {
     
      let some_number = Some(5);  //这里有类型推导
    
      let some_string = Some(String::from("a string"));
     
      let absent_number: Option<i32> = None;
    
      let x: i32 = 5;
      let y: Option<i32> = Some(5);
      let mut temp = 0;
   
      match y {
         Some(i) => { temp = i;}
         None => {println!("do nothing");}
      }
      let sum = x+temp;
      println!("sum = {}",sum);
    
      println!("Hello, world!");
   }

第二种使用方法：在函数中使用Option

   fn main() {
      let y: Option<i32> = Some(5);

      let result = plus_one(y);
      match result {
         Some(i) => println!("result = {}",i),
         None => println!("nothing"),
      }
 
      println!("Hello, world!");
   }
 
   fn plus_one(x: Option<i32>) ->Option<i32> {
      match x {    //在match的时候必须将所有的情况都匹配到
         None => None,
         Some(x) => Some(x+1),
      }
   }

2.3 在match的时候必须将所有情况都匹配到，还可以使用if来处理

   fn main() {
      let y: Option<i32> = Some(5);

      if let Some(value) = plus_one(y){
         println!("value = {}", value);
      }
    
      if let Some(value) = plus_one(y){
         println!("value = {}", value);
      }else{
         println!("do nothing");
      }

      println!("Hello, world!");
   }
 
   fn plus_one(x: Option<i32>) ->Option<i32> {
      match x {    //在match的时候必须将所有的情况都匹配到
         None => None,
         Some(x) => Some(x+1),
      }
   }

//从此做个俗人，贪财好色，一身正气～