basic/compound-type/struct #1154

2023-02-27T07:16:23Z

giscus[bot]
bot Feb 27, 2023

basic/compound-type/struct

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

cddsgtc · 2023-02-27T07:16:24Z

cddsgtc
Feb 27, 2023 — with giscus

新加的内容？

0 replies

pluschen-stack · 2023-02-27T07:29:44Z

pluschen-stack
Feb 27, 2023 — with giscus

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）默认是在堆中呢？

6 replies

eason-777 Mar 13, 2023 — with giscus

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

pluschen-stack Mar 14, 2023

我现在有一个问题，结构体创建的时候，基本类型就放在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 Apr 12, 2023 — with giscus

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

0xDamn Apr 12, 2023 — with giscus

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

ysy May 26, 2023 — with giscus

其实跟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 · 2023-03-12T06:22:11Z

SeddonShen
Mar 12, 2023 — with giscus

打卡

2 replies

0xDamn Apr 12, 2023 — with giscus

Question:

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

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

ysy May 26, 2023 — with giscus

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

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

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

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

Reid00 · 2023-05-11T06:27:43Z

Reid00
May 11, 2023 — with giscus

#[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

6 replies

Reid00 May 15, 2023

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

Icemans007 Apr 16, 2024 — with giscus

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

dxcodehub Aug 13, 2024 — with giscus

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

dxcodehub Aug 13, 2024 — with giscus

#[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;
}
···

dxcodehub Aug 13, 2024 — with giscus

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

p 是 Person 可变对象
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 · 2023-06-19T07:12:59Z

timnick-snow
Jun 19, 2023 — with giscus

访问结构体字段，当更新了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]");

5 replies

wsj6109118105 Jun 24, 2023 — with giscus

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

timnick-snow Jun 24, 2023

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

wsj6109118105 Jun 25, 2023 — with giscus

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

}

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

csychenci Jan 22, 2025 — with giscus

这里是有问题的，原因在于 String 在栈上存储的是一个胖指针结构，它由三部分组成，指向堆内存实际数据的指针(ptr)、长度(len)、容量(cap)，所以它实际上在栈上是有一个地址的，而 let t = &user1.email; 实际上让 t 存储的数据是 user1.email 绑定的胖指针的地址，所以你这里 s 和 t 始终指向的都是栈上的位置，并不是实际的堆内存上的地址

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

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

    println!(
        "原来的堆内存地址: {:p}, 原来的数据的容量：{1}, 新的数据的长度：{2}",
        user.email.as_ptr(),
        user.email.capacity(),
        "1.com".len()
    );
    user.email = String::from("1.com");

    println!("新的堆内存地址: {:p}", user.email.as_ptr());
}
// 原来的堆内存地址: 0x125606a90, 原来的数据的容量：19, 新的数据的长度：5
// 新的堆内存地址: 0x125606a10

你可以用这种方式去看堆内存的地址，可以发现 rust 重新分配了内存空间，并且将胖指针的指向(ptr）指向了新的内存空间

csychenci Jan 22, 2025 — with giscus

这里放错代码了，抱歉，应该是下面这段

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

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

    println!("初始堆内存地址: {:p}", user.email.as_ptr());
    user.email = String::from("[email protected]");

    println!("新的堆内存地址: {:p}", user.email.as_ptr());
}

korterling · 2023-10-13T05:45:08Z

korterling
Oct 13, 2023 — with giscus

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

1 reply

clean-master Oct 16, 2023

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

qianxiaoming · 2023-10-20T01:49:59Z

qianxiaoming
Oct 20, 2023 — with giscus

请问这个代码：

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变量在哪里呢？

0 replies

zhangbyby · 2023-11-04T13:01:37Z

zhangbyby
Nov 4, 2023 — with giscus

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

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
}

1 reply

ZtionJam Jan 8, 2024 — with giscus

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

zrll12 · 2024-01-10T02:50:32Z

zrll12
Jan 10, 2024 — with giscus

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

1 reply

GangJust Feb 28, 2024 — with giscus

一般来说，涉及到模块才会给内部字段增加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 · 2024-05-10T02:36:59Z

TDAkory
May 10, 2024 — with giscus

dbg! 真好用

0 replies

0xSchnappi · 2024-06-30T10:25:48Z

0xSchnappi
Jun 30, 2024 — with giscus

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

1 reply

0xSchnappi Jun 30, 2024 — with giscus

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

lhylyrr · 2024-07-09T03:33:18Z

lhylyrr
Jul 9, 2024 — with giscus

#[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 一个呢？
还是说这个引用有什么深意吗？

1 reply

Magic-cxf Sep 13, 2024 — with giscus

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

Veng0923 · 2024-08-31T15:50:55Z

Veng0923
Aug 31, 2024 — with giscus

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

1 reply

zrll12 Aug 31, 2024

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

Veng0923 · 2024-09-01T11:02:56Z

Veng0923
Sep 1, 2024 — with giscus

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

1 reply

Magic-cxf Sep 13, 2024 — with giscus

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

bellingham07 · 2024-09-28T08:25:03Z

bellingham07
Sep 28, 2024 — with giscus

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

0 replies

vbingbingv · 2025-03-05T07:10:33Z

vbingbingv
Mar 5, 2025 — with giscus

我有个疑问，我不知道dbg宏的实现原理。它可以定位出代码位于文件的位置。这个是类似于SourceMap那种实现吗？这样不会损失运行时的性能吗？

0 replies

basic/compound-type/struct #1154

giscus[bot] bot Feb 27, 2023

basic/compound-type/struct

Replies: 16 comments · 26 replies

cddsgtc Feb 27, 2023 — with giscus

pluschen-stack Feb 27, 2023 — with giscus

eason-777 Mar 13, 2023 — with giscus

pluschen-stack Mar 14, 2023

zhenzhenChange Apr 12, 2023 — with giscus

0xDamn Apr 12, 2023 — with giscus

ysy May 26, 2023 — with giscus

SeddonShen Mar 12, 2023 — with giscus

0xDamn Apr 12, 2023 — with giscus

ysy May 26, 2023 — with giscus

Reid00 May 11, 2023 — with giscus

Reid00 May 15, 2023

Icemans007 Apr 16, 2024 — with giscus

dxcodehub Aug 13, 2024 — with giscus

dxcodehub Aug 13, 2024 — with giscus

dxcodehub Aug 13, 2024 — with giscus

timnick-snow Jun 19, 2023 — with giscus

wsj6109118105 Jun 24, 2023 — with giscus

timnick-snow Jun 24, 2023

wsj6109118105 Jun 25, 2023 — with giscus

csychenci Jan 22, 2025 — with giscus

csychenci Jan 22, 2025 — with giscus

korterling Oct 13, 2023 — with giscus

clean-master Oct 16, 2023

qianxiaoming Oct 20, 2023 — with giscus

zhangbyby Nov 4, 2023 — with giscus

ZtionJam Jan 8, 2024 — with giscus

zrll12 Jan 10, 2024 — with giscus

GangJust Feb 28, 2024 — with giscus

TDAkory May 10, 2024 — with giscus

0xSchnappi Jun 30, 2024 — with giscus

0xSchnappi Jun 30, 2024 — with giscus

lhylyrr Jul 9, 2024 — with giscus

Magic-cxf Sep 13, 2024 — with giscus

Veng0923 Aug 31, 2024 — with giscus

zrll12 Aug 31, 2024

Veng0923 Sep 1, 2024 — with giscus

Magic-cxf Sep 13, 2024 — with giscus

bellingham07 Sep 28, 2024 — with giscus

vbingbingv Mar 5, 2025 — with giscus

giscus[bot]
bot Feb 27, 2023

Replies: 16 comments 26 replies

cddsgtc
Feb 27, 2023 — with giscus

pluschen-stack
Feb 27, 2023 — with giscus

SeddonShen
Mar 12, 2023 — with giscus

Reid00
May 11, 2023 — with giscus

timnick-snow
Jun 19, 2023 — with giscus

korterling
Oct 13, 2023 — with giscus

qianxiaoming
Oct 20, 2023 — with giscus

zhangbyby
Nov 4, 2023 — with giscus

zrll12
Jan 10, 2024 — with giscus

TDAkory
May 10, 2024 — with giscus

0xSchnappi
Jun 30, 2024 — with giscus

lhylyrr
Jul 9, 2024 — with giscus

Veng0923
Aug 31, 2024 — with giscus

Veng0923
Sep 1, 2024 — with giscus

bellingham07
Sep 28, 2024 — with giscus

vbingbingv
Mar 5, 2025 — with giscus