---

0 引入

在这里我们需要介绍Rust和数据结构有点关系的语法，如结构体、枚举以及集合。

---

1、结构体

1. 1 结构体

结构体字C语言中是很重要概念，Rust 中的结构体（Struct）与元组（Tuple）都可以将若干个类型不一定相同的数据捆绑在一起形成整体，但结构体的每个成员和其本身都有一个名字，这样访问它成员的时候就不用记住下标了。元组常用于非定义的多值传递，而结构体用于规范常用的数据结构。结构体的每个成员叫做"字段"。。

//定义一个结构体
struct Animal{
    name: String,             //后面是，而不是；
    size: u32,
    belong: String,
    home: String
}

//实例化
let dog = Animal{
    name: String::from("dog")
    size: 15,
    belong: String::from("I"),
    home: String::from("Anhui")
}


//结构体可以这么用
let name = String::from("dog");
let belong= String::from("I");
let dog= Animal {
    name,
    size: 15,
    belong,
    home: String::from("Anhui")
};

//输出结构体

#[derive(Debug)]
fn main() {
    let dog2 = Animal{
	    name: String::from("dog2")
	    size: 15,
	    belong: String::from("I"),
	    home: String::from("Anhui")
    }

    println!("rect1 is {:?}", dog2 );    //如果属性较多的话可以使用另一个占位符 {:#?} 。

注：

• 不能声明实例，结尾不需要 ; 符号，而且每个字段定义之后用 , 分隔。
• 实例化结构体的时候用 JSON 对象的 key: value 语法来实现定义。
• 一定要导入调试库 #[derive(Debug)] ，之后在 println 和 print 宏中就可以用 {:?} 占位符输出一整个结构体：

也可以使用一个结构体去初始化另一个结构体，但是与C语言不一样的是，就是这两个结构体不能完全一样，至少有一个字段不一样，如下：

let dog= Animal {
    name,
    size: 15,
    belong,
    home: String::from("Anhui")
};

let cat = Animal{
    name = String::from("cat")
    ..dog                        //注意格式
}

1. 2 结构体方法

Rust 语言不是面向对象的，但是面向对象的珍贵思想可以在 Rust 实现。
结构体方法的第一个参数必须是 &self，不需声明类型，因为 self 不是一种风格而是关键字。
在调用结构体方法的时候不需要填写 self ，这是出于对使用方便性的考虑。

struct Rectangle {
    width: u32,
    height: u32,
}
   
impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

fn main() {
    let rect1 = Rectangle { width: 30, height: 50 };
    println!("rect1's area is {}", rect1.area());
}



//上述也可以这么实现
impl Rectangle {
    fn create(width: u32, height: u32) -> Rectangle {
        Rectangle { width, height }
    }
}
fn main() {
    let rect = Rectangle::create(30, 50);  //结构体关联函数，在impl块中省略&self，但是在用的时
                           			       //  候需要声明
    println!("{:?}", rect);
}

1. 3 元组结构体

有一种更简单的定义和使用结构体的方式：元组结构体。
元组结构体是一种形式是元组的结构体。
与元组的区别是它有名字和固定的类型格式。它存在的意义是为了处理那些需要定义类型（经常使用）又不想太复杂的简单数据：

struct Color(u8, u8, u8);
struct Point(f64, f64);

let black = Color(0, 0, 0);
let origin = Point(0.0, 0.0);

元组结构体每个对象可以像结构体那样用下标去访问

  println!("black = ({}, {}, {})", black.0, black.1, black.2);

---

2、枚举类

2.1 match

枚举类在 Rust 中并不像其他编程语言中的概念那样简单，有着自己不一样的概念和用法，枚举的目的是对某一类事物的分类，分类的目的是为了对不同的情况进行描述。基于这个原理，往往枚举类最终都会被分支结构处理（许多语言中的 switch ）
定义一个简单的枚举

enum Book {
    Papery(u32),                 //纸质书   
    Electronic(String)           //电子书
}

fn main() {
    enum Book {
        Papery {index: u32},
        Electronic {url: String},
    }
   
    let book = Book::Papery{index: 1001};
    let ebook = Book::Electronic{url: String::from("url...")};
   
    match book {
        Book::Papery { index } => {
            println!("Papery book {}", index);
        },
        Book::Electronic { url } => {
            println!("E-book {}", url);
        }
    }
}

2.2 Option 枚举类

Option 是 Rust 标准库中的枚举类，这个类用于填补 Rust 不支持 null 引用的空白。

enum Option<T> {
    Some(T),
    None,
}

使用方法

fn main() {
    let opt = Option::Some("Hello");
    match opt {
        Option::Some(something) => {
            println!("{}", something);
        },
        Option::None => {
            println!("opt is nothing");
        }
    }
}

//省略Option 简介写法

fn main() {
        let t = Some(64);
        match t {
                Some(64) => println!("Yes"),
                _ => println!("No"),
        }
}

// 也可以用 if let 语法再一次简洁，有点语法糖的感觉
fn main() {
    enum Book {
        Papery(u32),
        Electronic(String)
    }
    let book = Book::Electronic(String::from("url"));
    if let Book::Papery(index) = book {
        println!("Papery {}", index);
    } else {
        println!("Not papery book");
    }
}

---

3、集合

集合（Collection）是数据结构中最普遍的数据存放形式，Rust 标准库中提供了丰富的集合类型帮助开发者处理数据结构的操作。

3.1 向量（Vector）

向量（Vector）是一个存放多值的单数据结构，该结构将相同类型的值线性的存放在内存中。
向量是线性表，在 Rust 中的表示是 Vec。
向量的使用方式类似于列表（List），我们可以通过这种方式创建指定类型的向量：

let vector: Vec<i32> = Vec::new(); // 创建类型为 i32 的空向量
let vector = vec![1, 2, 4, 8];     // 通过数组创建向量

vector.push(16);                    //追加
    let mut v1: Vec<i32> = vec![1, 2, 4, 8];
    let mut v2: Vec<i32> = vec![16, 32, 64];
    v1.append(&mut v2);              //拼接
             

取出数据使用 get，当然也可以像数组那样，使用下标（注意越界）

fn main() {
    let mut v = vec![1, 2, 4, 8];
    println!("{}", match v.get(0) {
        Some(value) => value.to_string(),
        None => "None".to_string()
    });
}
             

3.2 字符串（String）

字符串的使用和C差不多，很方便可以作为各种数据的转换，拼接，切片等

let string = String::new();

let one = 1.to_string();         // 整数到字符串

let hello = String::from("Hello");

let mut s = String::from("run");
s.push_str("oob");             // 追加字符串切片
s.push('!');                   // 追加字符
             

3.1 映射表（Map）

映射表（Map）在其他语言中广泛存在。其中应用最普遍的就是键值散列映射表（Hash Map）。

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert("color", "red");
    map.insert("size", "10 m^2");
    println!("{}", map.get("color").unwrap());

     //遍历打印

	    for p in map.iter() {
        println!("{:?}", p);
    }
}

map中如果在insert有相同的数据，则会覆盖掉原先数据，如果想安全插入

map.entry("color").or_insert("red");

---

4、总结

关于数据结构这块，Rust能够使用部分的数据结构，在枚举这一块稍微不一样。

–