Rust基础学习-09-结构体的定义

结构体可以用于组织不同类型的数据，和一些面向对像语言中的 类 是很像的。

这篇博客包含以下内容

• 结构体的定义
• 通过一个函数，创建并返回一个结构体
• 定义一个结构体，但数据来自另外一个结构体
• 元祖结构体

结构体的定义

#[derive(Debug)]  // 加上这一句，就可以使用 println!("{:?}", xxx); 打印
struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

结构体以 struct 开头，后面是我们自定义的这个结构体类型的名字，里面每一个字段，以 字段名: 数据类型 的形式定义

结构体开头那个 #[derive(Debug)] 是为了打印而加的，也可以不加，这个的意思会在后面章节学习到，现在我也不知道具体意思，反正加上就可以使用 {:?} 的形式打印。

下面这段代码创建一个结构体实例

fn main() {
    let mut user = User {
        username: String::from("someone"),
        email: String::from("someone@outlook.com"),
        sign_in_count: 1,
        active: false,
    };
    // 打印这个结构体的内容
    println!("{:?}", user);
    
    // 因为创建 user 的时候加了 mut，所以可以修改里面字段的内容
    user.active = true;
    println!("Changed: {:?}", user);
}

通过一个函数，创建并返回一个结构体

fn build_user(_username: String, _email: String) -> User {
    User {
        username: _username,
        email: _email,
        sign_in_count: 2,
        active: false,
    }
}

// 如果参数名和结构体的字段名相同，则可以直接按下面的方式去赋值，
// 不需要再 aaa:bbb 这样的形式，并且顺序也无所谓
fn build_user2(username: String, email: String) -> User {
    User {
        email,
        username,
        sign_in_count: 2,
        active: false,
    }
}

定义一个结构体，但数据来自另外一个结构体

#[derive(Debug)]
struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let mut user = User {
        username: String::from("someone"),
        email: String::from("someone@outlook.com"),
        sign_in_count: 1,
        active: false,
    };
    println!("{:?}", user);
    
    let user2 = User {
        username: String::from("user2"),
        email: String::from("user2@outlook.com"),
        sign_in_count: user.sign_in_count,  // 使用 user 实例的数据
        active: user.active,  // 这个也使用 user 实例的数据
    };
    
    // 除了 username 和 email, 其他字段都使用 user 的值
    let user3 = User {
        username: String::from("user3"),
        email: String::from("user3@outlook.com"),
        ..user
    };
}

上面的代码，使用其他结构体数据，创建新的结构体时，我们使用的都是 简单 的 数据类型。如果使用 String 类型的字段，例如 username 或 email，则原有结构体实例的数据，会移动到新的结构体实例。看下面的代码。

下面这段代码编译会出错。

#[derive(Debug)]
struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let mut user = User {
        username: String::from("someone"),
        email: String::from("someone@outlook.com"),
        sign_in_count: 1,
        active: false,
    };

    let user2 = User {
        ..user
    };

    // !!!! 这一句编译会出错，因为我们创建 user2 的时候，使用了所有 user的数据，
    // 因为 username 和 email是String类型的，所以 所有权 会移动到 user2的对应字段中
    // 所以这句就会报错 !!!
    println!("{:?}", user.username);
}

如果要修复错误，可以使用我们上一节学到的切片，直接看下面的代码

#[derive(Debug)]
struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let mut user = User {
        username: String::from("someone"),
        email: String::from("someone@outlook.com"),
        sign_in_count: 1,
        active: false,
    };

    let user2 = User {
        username: String::from(&user.username[..]), // !!! 注意看这句
        email: String::from(&user.email[..]),       // !!! 还有这一句
        ..user
    };

    println!("{:?}", user.username);
    println!("{:?}", user);
    println!("{:?}", user2);
}

上面的代码，在创建 user2 时，String类型的字段，我们通过切片，创建了新的 String 数据，所以没有导致 所有权 转移。

元祖结构体

有一种结构体，没有具体的字段名，只有类型，这种结构体，称为 元祖结构体 (tuple structs)。看下面的代码

#[derive(Debug)]
struct Color(i32, i32, i32, i32);

fn main() {
    let bg_color = Color(255, 0, 0, 255);
    println!("{:?}", bg_color);
    
    // 通过所引，访问结构体里的某个元素，与 元祖 的访问方式一样
    let r = bg_color.0;
    let g = bg_color.1;
    let b = bg_color.2;
    let a = bg_color.3;
}

这一节聊了一下结构体的基本知识，下一节将聊一下更多关于结构体的东西。