Rust語言開發基礎（九）複雜數據類型：結構體，枚舉，泛型

1、結構體
結構體是一種複合結構類型，是數個簡單基礎類型的集合體。
struct    Point    {
    x:    i32,
    y:    i32,
}
fn    main()    {
    let    origin    =    Point    {    x:    0,    y:    0    };    //    origin:    Point
    println!("The    origin    is    at    ({},    {})",    origin.x,    origin.y);
}

1. 使用大寫字母開頭而且使用駝峯命名法。
2. 使用圓點來調用結構體裏的變量。
3. 結構體默認值不可變，使用mut使其可變，可是不支持結構體裏面字段的可變性，即mut不能修飾裏面的字段。
4. 使用..拷貝其它結構體的值。
struct    Point3d    {
    x:    i32,
    y:    i32,
    z:    i32,
}
能夠拷貝本身
let    mut    point    =    Point3d    {    x:    0,    y:    0,    z:    0    };
point    =    Point3d    {    y:    1,    ..    point    };
或者也能夠拷貝其它結構體
let    mut    point    =    Point3d    {    x:    0,    y:    0,    z:    0    };
point    =    Point3d    {    y:    1,    ..    point    };
結果是：point    =    Point3d    {    x:    0,    y:    1,    z:    0    };

元組結構體（衍生）
struct    Color(i32,    i32,    i32);
struct    Point(i32,    i32,    i32);

1. 沒有字段名稱。

2. 即便值與結構體相同，二者也是不相等的。
let    black    =    Color(0,    0,    0);
let    origin    =    Point(0,    0,    0);
即black!=origin

3. 比較適合的場景：單元素的元組結構，也稱爲「新類型」。
struct    Inches(i32);
let    length    =    Inches(10);
let    Inches(integer_length)    =    length;
println!("length    is    {}    inches",    integer_length);
意思是let  Inches(integer_length)給    integer_length    賦值爲    10    。

類單元結構體（衍生）
1.無字段，沒有任何成員變量：struct    Electron;
2.用處較少，省略

2、枚舉
枚舉是一個表明數個可能變量的數據的類型
1.能夠攜帶各類類型的變量
enum    Message    {
    Quit, //類單元結構體
    ChangeColor(i32,    i32,    i32), //元組結構體
    Move    {    x:    i32,    y:    i32    }, //結構體
    Write(String), //方法函數
}
上述枚舉相似一個網絡遊戲的消息

2. 能夠經過兩個冒號::來實現枚舉裏的變量的調用及其賦值
Message枚舉的調用：
let    x:    Message    =    Message::Move    {    x:    3,    y:    4    };

enum    BoardGameTurn    {
    Move    {    squares:    i32    },
    Pass,
}
let    y:    BoardGameTurn    =    BoardGameTurn::Move    {    squares:    1    };

3. 典型的使用錯誤
 let    Message::ChangeColor(r,    g,    b)    =    msg;    //    compile-time    error
直接綁定類型的操做不被支持

4. 典型應用：枚舉的構造器能夠當函數同樣使用
這裏會考慮將函數做爲參數傳遞給其餘函 數。
例如，使用迭代器，咱們能夠這樣把一個    String    的vector轉換爲一個    Message::Write    的vector：
let    v    =    vec!["Hello".to_string(),    "World".to_string()];
let    v1:    Vec<Message>    =    v.into_iter().map(Message::Write).collect();
 

3、泛型

泛型類

案例1.標準庫中的一個類型
enum    Option<T>    {
                Some(T),
                None,
}
使用：
let    x:    Option<i32>    =    Some(5);
let    y:    Option<f64>    =    Some(5.0f64);

案例2. Rust內建類型
     
enum    Result<T, E>    {
                Ok(T),
                Err(E),
}

泛型函數

1. 普通單泛型類約束
fn  takes_anything<T>(x:    T)    {
                //    do    something    with    x
}
<T>表明「這個函數帶有一個泛型類型」，而x:T表明「x是T類型的」。

2. 多參數一泛型類型約束

fn    takes_two_of_the_same_things<T>(x:    T,    y:    T)    {
                //    ...
}

3. 多參數多泛型類型約束
fn    takes_two_things<T,    U>(x:    T,    y:    U)    {
                //    ...
}

泛型函數結合「特性約束」時最有用

泛型結構體

struct    Point<T>    {                 x:    T,                 y:    T, } let    int_origin       =    Point    {    x:    0,    y:    0    }; let    float_origin    =    Point    {    x:    0.0,    y:    0.0    };