basic/compound-type/struct

[giscus[bot]]

basic/compound-type/struct

https://course.rs/basic/compound-type/struct.html

[cddsgtc]

新加的内容？

[pluschen-stack]

struct Struct{
    a:i32,
    b:String,
}
fn make() -> Struct{
    Struct{
        a:3,
        b:String::from("hello"),
    }
}

fn main(){
    let a = make();
}

在这里，我make出来的struct的所有权最后给了a，那么是否说明struct中的内容（它的a和b）默认是在堆中呢？

[eason-777]

在 make 函数里，你创建了一个结构体，其中的成员 a 存放在 stack 上， b 作为可变长字符串存放在 heap 上。返回该结构体时，根据字段是否有 Copy 性质来进行直接复制或所有权转移。

[pluschen-stack]

我现在有一个问题，结构体创建的时候，基本类型就放在stack上，复杂类型比如String，指针留在stack上，内容留在heap上。然后构造用的关联函数返回结构体所有权的时候，结构体应该在栈顶。
那么加入当外界的函数调用这个构造的关联函数的时候，如果返回这个创建的结构体，那么假如在创建结构体之前存在一些复杂类型，那么那些复杂类型不是要被drop掉吗，那stack上的空间不久被浪费了？
比如下面这个例子

#[allow(dead_code)]
struct Struct{
    a:i32,
    b:String,
}
fn make() -> Struct{
    Struct{
        a:3,
        b:String::from("hello"),
    }
}

fn foo() -> Struct{
    let _a = String::from("this string will be dropped");
    //do something about _a
    make()
}
fn main(){
    let _b = foo();
}

这样子_a先创建那么它在正常的内存模型里一般在后面创建的结构体的下面，结构体在栈顶。这样foo()函数返回时stack上_a的空间不就被浪费了？

[zhenzhenChange]

不会吧，foo执行结束后，make()创建的结构体最终移动到外面，也就是由_b接收了，那么此时foo的生命周期到头了就只剩下_a，最后_a自动执行drop。

[0xDamn]

我的理解是当结构体作为函数返回值时因为有可变类型成员String所以内存大小不能在编译时确定，它会被分配到堆上，stack上只留指向这个结构体的指针，这样返回时只是返回这个指针。

[ysy]

其实跟Struct里的字段类型没有关系，Struct 默认是没有Copy特性的，所以都是move，以及Struct是存在栈上的，但存在栈上不表示就可以Copy。

#[derive(Debug)]
struct Struct{
a:i32,
b:i32,
}
fn make() -> Struct{
Struct{
a:3,
b:4
}
}

fn main(){
let x = 1000;

let a = make();
    // - move occurs because `a` has type `Struct`, which does not implement the `Copy` trait
println!("{:p}", &a);  
let b = a;
    // - value moved here
println!("{:?}, {:?}", a, b); //编译报错:

} ^ value borrowed here after move

[SeddonShen]

打卡

[0xDamn]

Question:

还有一个简单的输出 debug 信息的方法，那就是使用 dbg! 宏，它会拿走表达式的所有权，然后打印出相应的文件名、行号等 debug 信息，当然还有我们需要的表达式的求值结果。

在下面的示例代码中：dbg!(&rect1); 在这里&rect1只是rect1的一个不可变引用，为什么会涉及到所有权转移呢？

[ysy]

dbg!(&rect1); 这一句没有转移rect1的所有权。

这个例子里这一句不是关键，而是以下代码，用于说明dbg!() 会返回所有权

let rect1 = Rectangle { 
        width: dbg!(30 * scale), 
        height: 50, 
};``` 

但例子也不太好，因为 30 * scale 的值是基本类型，是move by Copy的。用String 类型会好点。

[Reid00]

#[derive(Debug)]
struct Person{
name: String,
age: i32,
} 

let mut p = Person{name: String::from("junmajinlong"), age: 23,};

let t = &mut p;
let name= t.name;

有个疑惑，这段代码中，有点不太理解，t 是p 的可变引用，t 本身是不可变变量，let name = t.name 确实不对。
但是为什么let name = &t.name 就对了呢? 这不相当于对p 同时有可变引用和不可变引用了吗？

如果后面改成 下面同时多个可变借用也是对的

    let s= &mut t.name;
    
    println!("s: {}", s)

而且如果

let name = &mut t.name 
println!("t: {:?}, s: {}", t, s)

又会报错如下:
error[E0502]: cannot borrow t as immutable because it is also borrowed as
mutable

[Reid00]

是我之前理解错了。对于struct 而言 t.name 解引用之后获取的是String 类型。我之前认为t 是&mut Person 类型，t.name 应该是&mut String类型呢。所以不太理解，let name = t.name 为何会涉及move

[Icemans007]

我不明白，rust 语言各种运算符优先级是怎样的，例如本例中
let name= &t.name;
这个取引用符 & 和 . 哪个优先级级别高，rust有自动解引用机制但导致我不好确定他们到底谁是优先级高的
let name = (&t).name; 还是 let name = &(t.name);

[aswangc]

#[derive(Debug)]
struct Person {
    age: i32,
    name: String,
}

#[test]
fn main3() {
    // 创建 Person 可变对象
    let mut p: Person = Person {
        age: 23, // 分配于栈上
        name: String::from("123"), // 分配于堆上，栈上存储指针
    };

    // p 持有所有权,可通过 p 访问和修改 Person 的字段
    p.age = 24;
    p.name = String::from("456");

    println!("p 存储的值: \t\t{:?}", p);
    println!("p 自身的内存地址: \t{:p}", &p);
    println!("p 所占的内存大小: \t{} 字节", std::mem::size_of_val(&p));

    println!("");
    println!("p.age 的值: \t\t{}", p.age);
    println!("p.age 自身的内存地址: \t{:p}", &p.age);
    println!("p.age 所占的内存大小: \t{} 字节", std::mem::size_of_val(&p.age));

    println!("");
    println!("p.name 的值: \t\t{}", p.name);
    println!("p.name 自身的内存地址: \t{:p}", &p.name);
    println!("p.name 指向的内存地址: \t{:p}", p.name.as_ptr());
    println!("p.name 所占的内存大小: \t{} 字节", std::mem::size_of_val(&p.name));
    

    let t: &mut Person = &mut p; // 获取对 p 的可变引用


    println!("");
    println!("t 存储的值: \t\t{:?}", t);
    println!("t 指向的地址: \t\t{:p}", t);
    println!("t 自身的内存地址:\t{:p}", &t);
    println!("t 所占的内存大小:\t{} 字节", std::mem::size_of_val(&t));

    println!("");
    println!("p.age 的值: \t\t{}", p.age);
    println!("p.age 自身的内存地址: \t{:p}", &p.age);
    println!("p.age 所占的内存大小: \t{} 字节", std::mem::size_of_val(&p.age));

    println!("");
    println!("p.name 的值: \t\t{}", p.name);
    println!("p.name 自身的内存地址: \t{:p}", &p.name);
    println!("p.name 指向的内存地址: \t{:p}", p.name.as_ptr());
    println!("p.name 所占的内存大小: \t{} 字节", std::mem::size_of_val(&p.name));
}

[aswangc]

#[derive(Debug)]
struct Person {
    age: i32,
    name: String,
}

#[test]
fn main3() {
    // 创建 Person 可变对象
    let mut p: Person = Person {
        age: 23, // 分配于栈上
        name: String::from("123"), // 分配于堆上，栈上存储指针
    };

    // p 持有所有权,可通过 p 访问和修改 Person 的字段
    p.age = 24;
    p.name = String::from("456");

    println!("p 存储的值: \t\t{:?}", p);
    println!("p 自身的内存地址: \t{:p}", &p);
    println!("p 所占的内存大小: \t{} 字节", std::mem::size_of_val(&p));
    
    let t: &mut Person = &mut p; // 获取对 p 的可变引用

    println!("");
    println!("t 存储的值: \t\t{:?}", t);
    println!("t 指向的地址: \t\t{:p}", t);
    println!("t 自身的内存地址:\t{:p}", &t);
    println!("t 所占的内存大小:\t{} 字节", std::mem::size_of_val(&t));

    // 尝试修改 t 指向的 Person 的字段
    // 这里报错: move occurs because `t.name` has type `String`, which does not implement the `Copy` trait
    // 这是因为: t.name 将会转移 name 字段的所有权。此时，name 的类型为 String，一旦获取，t 将不再有效，不能再使用（悬空指针）。
    // let name: String= t.name;
}
···

[aswangc]

问题分析
上述代码清晰地反映：

1. p 是 Person 可变对象
2. t 是 p 的可变引用

• 变量t 指向 变量p，且变量p的大小为32字节，变量t的大小为8 字节，充分说明变量p是个完整的对象，而变量t只是个指针
  补充问题：
• let name = t.name; 为什么这里所有权转以后t就不能用了
• 虽然字段t.name的所有权被转移但是t与t.age的所有权还在，为什么t就不能用了
  解释：
• 当let t = &mut p; 创建了对 p 的可变引用 t。在这个上下文中，t 可以用来修改 p 的字段。然而，通过 t 访问结构体字段时，如果你直接获取某个字段的所有权，比如 let name = t.name;，这会导致 name 的所有权转移，但是，t 仍然是一个有效的引用，只是在访问转移的字段后，不能再使用t访问该字段了。因为 t 的所有权没有被转移，只是它对 name 字段的访问权限丢失了。
• 虽然 t 的所有权仍然有效，但一旦你通过 t 获取了某个字段的所有权（例如 name），那么 t 就不能再被用来访问该字段了。这是 Rust 为了保持内存安全和防止数据竞争而设定的规则。
• 总之：如果可变引用结构体中某个字段的所有权被转移后，会导致原来的可变引用变量无法再正确的访问这个字段，这就造成了悬空指针，好在Rust编译器在编译阶段就进行了检查。

[timnick-snow]

访问结构体字段，当更新了user1的email字段后，原本email指向的内存会被自动释放吗？"[email protected]"这个字符串还在吗？

    let mut user1 = User {
        email: String::from("[email protected]"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };

    user1.email = String::from("[email protected]");

[wsj6109118105]

我感觉像是在原本内存的地方直接进行了修改

[timnick-snow]

我觉得不太像吧，String::from内部实现会分配堆内存存储字符串，而之前some字符串肯定是存储在堆内存的另一处地方。重新赋值给user1.email后，就不知道之前的会不会成为垃圾而变成内存泄漏

[wsj6109118105]

struct User {
active: bool,
username: String,
email: String,
sign_in_count: u64,
}

fn main() {
let mut user1 = User {
email: String::from("[email protected]"),
username: String::from("someusername123"),
active: true,
sign_in_count: 1,
};

let t = &user1.email;

println!("{:p}",t);

user1.email = String::from("[email protected]");

let s = &user1.email;

println!("{:p}",s);

}

这里打印了修改之前和之后的地址，是同一个地址，在修改的过程中应该只是在原来的地址进行了修改，并没有再次进行内存的分配的操作。

[korterling]

fn main() {

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}


let user1 = User {
    email: String::from("[email protected]"),
    username: String::from("someusername123"),
    active: true,
    sign_in_count: 1,
};

struct abc{
    a:i32,
    b:u32,
    c:User,
}
let mut abc1=abc{
    a:1,
    b:2,
    c:user1,
};


println!("{}",abc1.c.email);
// user1.email= "[email protected]".to_string();// error
abc1.c.email = "[email protected]".to_string();//ok
println!("{}",abc1.c.email);

}

为什么user1不可以修改email，而通过abc1对象就可以修改email

[clean-master]

user1是不可变的，abc1是可变的。

[qianxiaoming]

请问这个代码：

let f1_length = &f1.data.len();

.运算符的优先级是高于&的吧，这样f1_length不就是len()函数返回值的引用吗？但是这个返回值不是一个临时变量吗？还是说这里f1_length直接就拥有了返回的变量？
我试着用如下代码查看变量的地址：

let len1 = &f.data.len();
let len2 = &f.data.len();
let addr1 = len1 as *const usize as usize;
let addr2 = len2 as *const usize as usize;

发现addr1和addr2的值是不一样的，说明它们引用的是不同的变量。那返回并被引用的这两个usize变量在哪里呢？

[zhangbyby]

关于结构体更新语法这一节，如何拿到旧对象中没有被转移的字段呢？示例代码：

struct Struct {
    a: String,
    b: String,
}

impl Struct {
    fn from(from: Self) -> Self {
        Struct {
            a: "new_a".to_string(),
            ..from
        }
    }
}

fn main() {
    let v1 = Struct {
        a: "old_a".to_string(),
        b: "b".to_string(),
    };
    let v2 = Struct::from(v1);
    // 请问之后的代码如何拿到v1里边的a字段呢？
    // todo: 想使用 old_a
}

[ZtionJam]

fn from(from: Self)入参需要所有权，let v2 = Struct::from(v1);这里v1的所有权送走了，v1不再有效

[zrll12]

请问在什么情况下需要给结构体内部字段加pub修饰，如果不加那么在什么情况下可以直接访问

[GangJust]

一般来说，涉及到模块才会给内部字段增加pub修饰。

//user.rs
pub struct User { //这里如果没有pub，main方法中无法访问到该结构体
    /* pub */ name: String, //这里如果没有pub，main方法中无法直接为name赋值
}

impl User {
    // 通过pub它来创建User
    pub fn new(name: &str) -> User {
        return User {
            name: name.to_string(),
        };
    }
}

//--------------------------------------------------------------------------------//

//main.rs
use crate::user::User;

mod user;

fn main() {
    let u = User {
        name: String::from("Jay"), //field `name` of struct `User` is private
    };

    let u1 = User::new("Jay"); //successful
}

但如果是在同一个 rs 文件下，pub 就可有可无了 。

区别在于某个实现结构体、方法等，是否需要被外部使用

//main.rs

//该结构体作用域范围在 main.rs 外部模块无法使用
struct User {
    name: String,
}

fn main() {
    let u = User {
        name: String::from("Jay"), //successful
    };
}

[TDAkory]

dbg! 真好用

[0xSchnappi]

fn build_user(email: String, username: String) -> User {
User {
email: email,
username: username,
active: true,
sign_in_count: 1,
}
}
// 该函数返回User实例，但是按照作用域来说，该实例在函数结束时就不应该释放吗？我哪里理解有误还需大佬指点

[0xSchnappi]

对不起，我搞错了，所有权是根据传参和返回值转移的，在函数的参数不返回时，这个参数就会被释放

[lhylyrr]

#[derive(Debug)]
struct File {
    name: String,
    data: Vec<u8>,
}

fn main() {
    let f1 = File {
        name: String::from("f1.txt"),
        data: Vec::new(),
    };

    let f1_name = &f1.name;
    let f1_length = &f1.data.len();

    println!("{:?}", f1);
    println!("{} is {} bytes long", f1_name, f1_length);
}

这段代码中，let f1_length = &f1.data.len(); 为什么要对 len() 的返回值进行引用呢？len() 的返回值是 usize 类型，那么不是实现了 Copy trait 吗，与其对其进行引用，为什么不直接 copy 一个呢？
还是说这个引用有什么深意吗？

[Magic-cxf]

可以直接去掉引用符号吧 结果都一样

[Veng0923]

请问下, 结构体支持成员的类型是函数吗?

[zrll12]

可以用闭包类型，但是一般建议用impl实现函数

[Veng0923]

结构体可以 解构吗? let {age, name} = person;

[Magic-cxf]

貌似 不可以 得指明解构的类型 let Person { a, b } = person;

[bellingham07]

天下无敌的剑士往往也因为他有一柄无双之剑，盖聂？