ownership/ownership

[giscus[bot]]

ownership/ownership

Learning Rust By Practice, narrowing the gap between beginner and skilled-dev with challenging examples, exercises and projects.

https://zh.practice.rs/ownership/ownership.html

[sweet2honey]

第3题中的into_bytes会触发move语义，而教程中没有提及into_bytes()或者as_bytes()这种函数，感觉通过注释代码编过的方法不是很好，题解的方法2

[nehcuh]

fn main() {
let s = give_ownership();
println!("{}", s);
}

// 只能修改下面的代码!
fn give_ownership() -> String {
let s = String::from("hello, world");
// convert String to Vec
// 将 String 转换成 Vec 类型
let _s = s.into_bytes();
if let Ok(val) = String::from_utf8(_s) {
val
} else {
panic!()
}
}

[ski9421]

let s = give_ownership();
println!("{}", s);
fn give_ownership() -> String {
let s = String::from("hello world");
//可以使用clone
let _s = s.clone().into_bytes();
s
}

[QIN2DIM]

fn main() {
    let s = give_ownership();
    println!("{}", s);
}

// 只能修改下面的代码!
fn give_ownership() -> String {
    let s = String::from("hello, world");
    // convert String to Vec
    // 将 String 转换成 Vec 类型
    let _s = s.into_bytes();
    String::from_utf8_lossy(&_s).to_string()
}

[sweet2honey]

第7题中，引入了Box::new，相比教程稍有跳跃（还没提及过）；然后题目是需要答题者创建一个能被解引用的变量（引用或者Box），有点难想到哈哈。但是*y的值后面又没有断言或者打印，感觉整个题下来做得稍微蛋疼了一点。（感谢给了我一个机会去看看std::Box哈哈😁

[badpx]

第7题也可以用一种不超纲的方法：
let mut y = &mut 0;

[badpx]

可以简化为：let y = &mut 0;

[asd123wto]

这个*y前面的星号的作用是啥，表示y是interger类型吗？萌新看懵了

[asd123wto]

看了下一章懂了

[suncunqian]

第7题我是这样写的：
'''
let ref mut y = 6; // 完成该行代码，不要修改其它行！
'''

[sweet2honey]

第9题是不是用let (ref s1, ref s2) = t;会更好点啊

[fenglea]

所得s1和s2类型不就不同了吧

[ski9421]

let (s1, s2) = &t;

[be-the-hero]

into_bytes 和 as_bytes 理解不了呢
查了一下
String -> &[u8] | s.as_bytes()
String -> Vec | s.into_bytes()
Vec 是把 String 转成了 Vec，并且触发了 move 语法
&[u8] 能看出来是借用，但它借用的是谁呢？String 本身有没有被转成 Vec 呢？
求解惑，哈哈 ~

[be-the-hero]

看完字符串的章节，似乎明白这个问题了
String 本质是堆上面的 Vec，Vec 的切片引用就是 &[]
所以 &str 和 String，等同于 &[u8] 和 Vec
那么 as_bytes 就是拿到字符串的切片引用 &[u8]，s 本身的所有权没有发生变化
而 into_bytes() 是拿到字符串的 Vec，然后发生了 move 动作，所有权转移了

[sunface]

恭喜你，完成了自我升华

[stanhangzhou]

我也是这样理解的。 我认为关键是

1. string切片引用&[str] or &[u8]，只是类似指针一样的引用，并没有moved 所有权..
2. into_bytes

pub fn into_bytes(self) -> Vec<u8, Global>ⓘ
#![allow(unused)]
fn main() {
let s = String::from("hello");
let bytes = s.into_bytes();

assert_eq!(&[104, 101, 108, 108, 111][..], &bytes[..]);
}

Vec 大哥，是有一个胖指针在Stack (ptr, len, cap)的，是有所有权的，而不是1中的 &[str], &[u8] 纯粹的 堆(heap)上的一个引用（包含了ptr, + len). 看完String, &str str 字符串字面量，会理解更好点。

[fireindark707]

完成 8/9

[RomanSeven7]

done ! ! !

[roushanyyzz]

Done.

[roushanyyzz]

栈中保存了堆指针、字符串长度、字符串容量，因为引用不可变，前面三个的值都是固定的，且在栈中可以快速复制，因此有Copy特征

[cqiang1993]

我在思考一个问题，就从做这些题目的角度来说
就像第9题
我是不是也可以直接使用&t来给s1和s2传递变量?
从实际场景来说，是不是说根据需求使用.clone()这个方法呢？

[shiyivei]

是的，t是在堆上创建的数据，当你确定真的需要复制一份时，就可以使用clone（）

[QuarterHeaven]

对对，我做这道题的时候就是直接使用的&t，这样的话s1和s2分别是t.0和t.1的引用，也就是s1=&t.0，s2=&t.1，不会获得所有权

[makexiao113]

done！不过第5题和第7题感觉超纲了啊！第五题还好点，就算对Copy理解的不透彻也能做，但是第7题明明还没有学习Box和Box的使用方法啊

[badpx]

第7题我是这么写的，没用Box：
let mut y = &mut 0;

[zackshen]

Done.

[QuarterHeaven]

感觉有些题目的题意不太清楚，例如第 8 题我做的时候以为是只修改println!在不用_s的情况下打印出("hello", "world")，想了好久，看了答案才知道只需要改成不出错就行

[mudssky]

第1题还有一种不会报错的

fn main() {
    let x = String::from("hello, world");
    let y = &x;
    println!("{},{}", x, y);
    println!("{}", y);
}

说明println!里面发生了字符串copy，没有移走所有权
下面take_ownership移走所有权就会报错了

fn main() {
    let x = String::from("hello, world");
    let y = &x;
    take_ownership(x);
    println!("{}", y);
}

fn take_ownership(x: String) -> () {}

[mudssky]

借用（引用）之后就不能再移动了

[Archieeeeee]

done

[duke-git]

第九题：

fn main() {
   let t = (String::from("hello"), String::from("world"));

   // 填空，不要修改其它代码
   let (s1, s2) = (&(t.0), &(t.1));

   println!("{:?}, {:?}, {:?}", s1, s2, t); // -> "hello", "world", ("hello", "world")
}

[jychen6688]

结构
let (s1, s2) = &t

[AliceThunder]

DONE

[AliceThunder]

done

done

done

done

done

done

[vickyone0]

done. ownership is so niceeeeeeeeeeeeeeeeeeeeeeeeeeee

[clarkzhang56]

第9题这样也可以：
let (s1, s2) = (t.0.as_str(),t.1.as_str());

[SunFwy]

做第九题的时候发现了一个疑问，这样去访问t.1的时候 是不是造成了t.1的所有权转移，导致后面去print的时候出现了问题。 但是所有权转移是在什么过程发生的，又转移到了哪里呢? 有点费解

fn main() {
let t = (String::from("hello"), String::from("world"));

t.1;
 println!("{}", t.1); 

}

编译器提示
23 | t.1;
| --- value moved here

[BruceBlink]

在Rust中，使用.访问元组的成员时，并不会发生所有权转移。但是，你在代码中使用了 t.1; 这样的语句，它实际上并没有做任何有用的操作，而这可能导致 Rust 编译器给出警告或错误。

如果你只是想访问元组的第二个元素而不进行任何其他操作，可以简单地使用 t.1 作为表达式，而不是单独的语句。这样就不会导致不必要的警告或错误。

chat GPT真好用😁

[felipe300]

• done

[zzzk1]

done

[vickyone0]

done batman

[EmptyBlueBox]

checked!

[develop-build]

Done

[develop-build]

Done

[zhengwengang]

// 第5题
// 不要使用 clone，使用 copy 的方式替代
fn main() {
    let x = (1, 2, (), "hello".to_string());
    let y = (_, _, _, _) = x;
    println!("{:?}, {:?}", x, y);
}

[karapy]

I did this :) (as extra playing with code)

fn main() {
let t : (String, String) = (String::from("hello"), String::from("world"));

// Fill the blanks
let (ref s1, ref s2) = t;

println!("{:?}, {:?}, {:?}", s1, s2, t); // -> "hello", "world", ("hello", "world")

}

[DylanJinx]

done~~~

[TDAkory]

mark finished

[C-RONALDO7V]

d

[rookiejj9]

最后一题这样写不是性能更好：fn main() {
let t = (&String::from("hello"), &String::from("world"));

// 填空，不要修改其它代码
let (s1, s2) = t;

println!("{:?}, {:?}, {:?}", s1, s2, t); // -> "hello", "world", ("hello", "world")

}

[rookiejj9]

fn main() {
let t = (&String::from("hello"), &String::from("world"));

// 填空，不要修改其它代码
let (s1, s2) = t;

println!("{:?}, {:?}, {:?}", s1, s2, t); // -> "hello", "world", ("hello", "world")

}