// 移除代码某个部分,让它工作
// 你不能移除整行的代码!
fn main() {
 let mut s = String::from("hello");
 let r1 = &mut s;
 let r2 = &r1;
 println!("{}, {}", r1, r2);
}

// 注释掉一行代码让它工作
fn main() {
 let mut s = String::from("hello, ");
 let r1 = &mut s;
 r1.push_str("world");
 //r2.push_str("!");
 
 println!("{}",r1);
 let r2 = &mut s;
}

fn main() {
 let x = 5;
 // 填写空白处
 let p = __;
 println!("x 的内存地址是 {:p}", p); // output: 0x16fa3c84
}

fn main() {
 let x = 5;
 let p = &x;//获取指向x的地址
 println!("x 的内存地址是 {:p}", p); // output: 0x16fa3ac84
}

fn main() {
 let x = 5;
 let y = &x;
 // 只能修改以下行
 assert_eq!(5, y);
}

fn main() {
 let x = 5;
 let y = &x;
 // 只能修改以下行
 assert_eq!(5, *y);//解引用获取引用y指向地址的值,也就是x
}

// 修复错误
fn main() {
 let mut s = String::from("hello, ");
 borrow_object(s)
}
fn borrow_object(s: &String) {}

fn main() {
 let mut s = String::from("hello, ");
 borrow_object(&s)//只需要求改这里即可
}
fn borrow_object(s: &String) {}//其实题干已经提示了,在这里要传入的是一个引用,引用不触发所有权矛盾

// 修复错误
fn main() {
 let mut s = String::from("hello, ");
 push_str(s)
}
fn push_str(s: &mut String) {
 s.push_str("world")
}

fn main() {
 let mut s = String::from("hello, ");
 push_str(& mut s)//可以从函数调用中传参的类型来推理此处变量类型
}
fn push_str(s: &mut String) {
 s.push_str("world")
}

fn main() {
 let mut s = String::from("hello, ");
 // 填写空白处,让代码工作
 let p = __;
 
 p.push_str("world");
}

fn main() {
 let mut s = String::from("hello, ");
 // 填写空白处,让代码工作
 let p = &mut s;//p传入的是指向s的地址,且因为下面有要求修改值,所以借用不够,还需要声明可变mut
 
 p.push_str("world");
}

fn main() {
 let mut s = String::from("hello, ");
 let mut p = s.clone();
 
 p.push_str("world");
}

fn main() {
 let c = '中';
 let r1 = &c;
 // 填写空白处,但是不要修改其它行的代码
 let __ r2 = c;
 assert_eq!(*r1, *r2);
 
 // 判断两个内存地址的字符串是否相等
 assert_eq!(get_addr(r1),get_addr(r2));
}
// 获取传入引用的内存地址的字符串形式
fn get_addr(r: &char) -> String {
 format!("{:p}", r)
}

fn main() {
 let c = '中';
 let r1 = &c;
 // 我浅薄理解为:ref在左边使用,&在右边使用
 let ref r2 = c;
 assert_eq!(*r1, *r2);
 
 // 判断两个内存地址的字符串是否相等
 assert_eq!(get_addr(r1),get_addr(r2));
}
// 获取传入引用的内存地址的字符串形式
fn get_addr(r: &char) -> String {
 format!("{:p}", r)
}

// 移除代码某个部分,让它工作
// 你不能移除整行的代码!
fn main() {
 let mut s = String::from("hello");
 let r1 = &mut s;
 let r2 = &mut s;
 println!("{}, {}", r1, r2);
}

fn main() {
 let mut s = String::from("hello");
//一个域里面有一个可变引用后就无法使用其他引用,所以mut必须都去掉
 let r1 = & s;
 let r2 = & s;
 println!("{}, {}", r1, r2);
}

fn main() {
 // 通过修改下面一行代码来修复错误
 let s = String::from("hello, ");
 borrow_object(&mut s)
}
fn borrow_object(s: &mut String) {}

fn main() {
 // String属于不可变对象?又学到了,然后mut自然就不可以用了
 let s = String::from("hello, ");
 borrow_object(& s)
}
fn borrow_object(s: & String) {}

// 注释掉一行代码让它工作
fn main() {
 let mut s = String::from("hello, ");
 let r1 = &mut s;
 r1.push_str("world");
 let r2 = &mut s;
 r2.push_str("!");
 
 println!("{}",r1);
}

// 注释掉一行代码让它工作
fn main() {
 let mut s = String::from("hello, ");
 let r1 = &mut s;
 r1.push_str("world");//调用完这个函数之后,r1就被释放掉了
 let r2 = &mut s;
 r2.push_str("!");
 
 //println!("{}",r1);
}

fn main() {
 let mut s = String::from("hello, ");
 let r1 = &mut s;
 let r2 = &mut s;
	
 // 在下面增加一行代码人为制造编译错误:cannot borrow `s` as mutable more than once at a time
 // 你不能同时使用 r1 和 r2
}

fn main() {
 let mut s = String::from("hello, ");
 let r1 = &mut s;
 let r2 = &mut s;
	r1.push_str("world");//因为一次只有一个可变引用可以改值,所以添加这个编译器就会报错(好家伙,我以为不添加这一行的话按照我的理解也会报错,原来还是需要尝试通过引用改变来触发这个编译error)
}

fn main() {
 let x = 5;
 let p = &x;
 
 println!("{}",*p );
 println!("{}", p );
 
 }

// 注释掉一行代码让它工作
fn main() {
 let mut s = String::from("hello, ");
 let r1 = &mut s;
 r1.push_str("world");
 let r2 = &mut s;
 r2.push_str("!");
 
 // println!("{}",r1);
}