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哈哈😁

[asd123wto]

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

[asd123wto]

看了下一章懂了

[suncunqian]

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

[169LI]

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

0 是一个字面量，它不能有可变引用。你无法对字面量使用可变借用。rust编译器为甚能通过？

[169LI]

相比于let ref mut y = 6; let mut y = Box::new(6);更能符合编译理解

[sweet2honey]

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

[fenglea]

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

[ski9421]

let (s1, s2) = &t;

[Wyatex]

好像let (ref s1, ref s2) = t;和let (s1, s2) = &t;效果一样

[169LI]

语法上的不同：let (ref s1, ref s2) = t; 使用 ref 关键字直接在模式匹配中创建引用；let (s1, s2) = &t; 则对整个 t 取不可变引用，然后解构出内部元素的引用。
使用场景上的微小差异：虽然效果相似，但在更复杂的模式匹配中，ref 可以直接用于创建部分引用，而无需对整个值取引用。

[169LI]

使用 ref 可以精确控制引用的粒度，避免对整个值的不可变借用，从而让代码更具弹性和更高效。

[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

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

}

[sjunepark]

Done

[gluonicboom]

HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH

[GeneralK1ng]

半夜脑子不是很清醒
第五题我也不知道为什么我会写出这种惊世骇俗的东西😁

// 不要使用 clone，使用 copy 的方式替代
    println!("{:?}, {:?}", y, y);

[woshisbb43]

第9题我直接解构引用，就不会有所有权变更了
let (s1, s2) = (&t.0, &t.1);

[lhylyrr]

DONE!

[lichenbuliren]

第七题有点迷糊，回头再看

[XueHua-s]

fn main() {
let x = Box::new(5);

let mut y = Box::new(*x);      // 完成该行代码，不要修改其它行！

*y = 4;

assert_eq!(*x, 5);

} 感觉第七题应该是想考解引用。应该是这么写的。

[zzzk1]

day2

[Paul-from-NJTech]

// 不要修改 main 中的代码
fn main() {
let s1 = String::from("hello, world");
let s2 = take_ownership(s1);

println!("{}", s2);

}

// 只能修改下面的代码!
fn take_ownership(s: String) -> String {
println!("{}", s);
s
}

take_ownership里面是对s1进行拷贝，还是所有权转移

[ivaaneoski]

the take_ownership fn (drops the ownership from s1 and transfers it to s2)

[Glessy-nf]

done

[bansal-harsh-2504]

✅

[bansal-harsh-2504]

✅

[CamaroW]

第9题是不是可以有3种解法：

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

    let (ref s1, ref s2) = t;

    println!("{:?}, {:?}, {:?}", s1, s2, t);
}

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

    let (s1, s2) = &t;

    println!("{:?}, {:?}, {:?}", s1, s2, t);
}

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

    let (s1, s2) = t.clone();

    println!("{:?}, {:?}, {:?}", s1, s2, t);
}

前两种方法中，s1 和 s2 的类型是 &str（所以这两种方法是完全等价的吗？）。第三种方法中，s1 和 s2 的类型是 String。

[mdShakilHossainNsu2018]

done