Rust语言开发基础（九）复杂数据类型：结构体，枚举，泛型

2019独角兽企业重金招聘Python工程师标准>>>

一、结构体
结构体是一种复合结构类型，是数个简单基础类型的集合体。
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.用处较少，省略

二、枚举
枚举是一个代表数个可能变量的数据的类型
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();
 

三、泛型

泛型类

案例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    };

 

转载于:https://my.oschina.net/pagecorrect/blog/731801