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

[xjy12345654]

let name = t.name ，这个属于转移所有权了，t还是可变引用直接报错！， let name = &t.name ，你后面并没有使用&t做什么，所以 &t在这一行结束后已经挂了，死了！ 非词法作用域生命周期，这地方始终只有一个可变引用 就是t

[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);

[timnick-snow]

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

    let mut user1 = User {
        email: String::from("someone@example.com"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };

    user1.email = String::from("anotheremail@example.com");

[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("someone@example.com"),
username: String::from("someusername123"),
active: true,
sign_in_count: 1,
};

let t = &user1.email;

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

user1.email = String::from("anotheremail@example.com");

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("someone@example.com"),
    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= "aaa@aaa.com".to_string();// error
abc1.c.email = "aaa@aaa.com".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! 真好用