method

[giscus[bot]]

method

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

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

[nasuf]

请教一下，第5题里面，为什么如下写法也可以编译通过并执行成功呢？

fn main() {
    let light = TrafficLight::new();
    assert_eq!(light.get_state(), "red");
}

[colorbeach]

为什么不行呢😂

[edcijn]

因为assert_eq!调用的是类型的PartialEq特征，而String有实现对str和&str类型的PartialEq特征。

[tn233]

回复 @religou：我猜没加解引用符的self是被“自动引用和解引用”了（如果我说的不对还请大佬们指正）

[DrEden33773]

@tn233 正确的，rust具有自动引用和解引用的功能

[studyAction]

这里的自动引用和解引用有条件限制，比如该事例加上*****就不会编译通过：

#![allow(unused)]
enum Message {
    Quit,
    Move{x:i32, y: i32},
    Write(String),
    ChangeColor(i32, i32, i32),
}

impl Message {
    fn call(&self) {
        match *self {
            Message::Write(message) => print!("{}", message),
            _ =>()
        }
    }
}
fn main() {
    let m = Message::Write(String::from("test"));
    m.call();
}

[jeasonnow]

done

[lemonbiscuits-ljw]

最后一题应该返回字面值吧

#[derive(Debug)]
enum TrafficLightColor {
    Red,
    Yellow,
    Green,
}

// 为 TrafficLightColor 实现所需的方法
impl TrafficLightColor {
    fn color(&self) -> &str {
        match *self {
            TrafficLightColor::Red => "red",
            TrafficLightColor::Yellow => "yellow",
            TrafficLightColor::Green => "Green",
        }
    }
}

fn main() {
    let c = TrafficLightColor::Yellow;

    assert_eq!(c.color(), "yellow");

    println!("{:?}",c);
}

[YtxCash]

这样也能通过

impl TrafficLightColor {
    pub fn color(&self) -> &str {
        match *self {
            Self::Red => "red",
            Self::Green => "green",
            Self::Yellow => "yellow",
        }
    }
}

[meimeitou]

fn color(&self) ->&str{
match self {
Yellow => "yellow",
_ => "other"
}
}

[LeeeSe]

self前面加不加*有什么区别？

[LeeeSe]

均通过了测试

[ZLD1819858]

rust的自动引用和解引用机制

[Wan-Yifei]

向match传入一个引用，匹配一个非引用模式（模式前不包含“&”），Rust会尝试copy传入的指针，如果指针不支持copy（例如可变引用就没有实现copy），那么就会move指针，传入的指针被销毁，创建一个相同指向的新指针取代。由此，match获得了指针的“所有权”（指针其实不因该谈所有权，但是借用这个说法好理解）。之后新指针会被解引用，拿到所指向数据的值。

[mrsai]

impl TrafficLightColor {
fn color(&self) -> &str {
match *self {
TrafficLightColor::Red => "red",
TrafficLightColor::Yellow => "yellow",
TrafficLightColor::Green => "Green",
}
}
}

这个能改成 if let 匹配吗？

[ghost]

但题目的目的是针对不同的颜色返回不同的字符串

[somecodework]

done

[matyle]

done

[EXSPIRAVIT1104OFFICIAL]

Done.

[Grapeve]

Done

[AliceThunder]

DONE

[suse-207]

done

[gccdChen]

为什么用 self 也能正常运行?

fn color(&self) -> &str{
        match self {
           Yellow => "yellow",
           Red => "red",
           Green => "red",
           _ => "unknow"
        }
    }

[Nixicodo]

这样写会有警告吧。

[wangyaoyao233]

自动解引用。作者不是说这样写更好吗？让使用者知道这里使用的是引用

[roc-n]

请问这里一定得进行解引用这一步吗（不管是显式还是隐式），代码里

let c = TrafficLightColor::Yellow;

c本身就是TrafficLightColor的一个值，那color函数里的self是值的引用，不可以直接进行模式匹配吗

[XU0618]

lala

[wsj6109118105]

done

[Ghy0202]

1、方法的声明

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    // 完成 area 方法，返回矩形 Rectangle 的面积
    fn area(&self)->u32{
        self.width*self.height
    }
}

fn main() {
    let rect1 = Rectangle { width: 30, height: 50 };

    assert_eq!(rect1.area(), 1500);
}

2、方法中&self和self的区别

// 只填空，不要删除任何代码行!
#[derive(Debug)]
struct TrafficLight {
    color: String,
}

impl TrafficLight {
    pub fn show_state(&self)  {//不可以用self，会导致所有权转移
        println!("the current state is {}", self.color);
    }
}
fn main() {
    let light = TrafficLight{
        color: "red".to_owned(),
    };
    // 不要拿走 `light` 的所有权
    light.show_state();
    // 否则下面代码会报错
    println!("{:?}", light);
}

3、方法中&self和&mut self的用法

struct TrafficLight {
    color: String,
}

impl TrafficLight {
    // 使用 `Self` 填空
    pub fn show_state(&self)  {
        println!("the current state is {}", self.color);
    }

    // 填空，不要使用 `Self` 或其变体
    pub fn change_state(&mut self) {
        self.color = "green".to_string()
    }
}
fn main() {}

4、Self代替对类型的说明

#[derive(Debug)]
struct TrafficLight {
    color: String,
}

impl TrafficLight {
    // 1. 实现下面的关联函数 `new`,
    // 2. 该函数返回一个 TrafficLight 实例，包含 `color` "red"
    // 3. 该函数必须使用 `Self` 作为类型，不能在签名或者函数体中使用 `TrafficLight`
    pub fn new()->Self{
        Self{
            color:String::from("red"),
        }
    }

    pub fn get_state(&self) -> &str {
        &self.color
    }
}

fn main() {
    let light = TrafficLight::new();
    //println!("{:?}",light);
    assert_eq!(light.get_state(), "red");
}

5、每个结构体可以对应多个impl模块

struct Rectangle {
    width: u32,
    height: u32,
}

// 使用多个 `impl` 语句块重写下面的代码
impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }

    
}
impl Rectangle{
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}


fn main() {}

6、

//自己的答案，可以度过，但是很明显逻辑看上去很奇怪
#[derive(Debug)]
enum TrafficLightColor {
    Red,
    Yellow,
    Green,
}

// 为 TrafficLightColor 实现所需的方法
impl TrafficLightColor {
    pub fn color(&self)->&str{
        "yellow"
    }
}

fn main() {
    let c = TrafficLightColor::Yellow;

    assert_eq!(c.color(), "yellow");

    println!("{:?}",c);
}

官方答案

#[derive(Debug)]
enum TrafficLightColor {
    Red,
    Yellow,
    Green,
}

// implement TrafficLightColor with a method
impl TrafficLightColor {
    fn color(&self) -> String {
        //模式匹配赛高
        match *self {
            TrafficLightColor::Red => "red".to_string(),
            TrafficLightColor::Yellow => "yellow".to_string(),
            TrafficLightColor::Green => "green".to_string(),
        }
    }
}

fn main() {
    let c = TrafficLightColor::Yellow;

    assert_eq!(c.color(), "yellow");

    println!("{:?}", c);
}

[chenhai998]

done

[Altriaww]

Done

[Rayd62]

done!

[lSpikeSpiegel]

done

[vickyone0]

done

[NihilisticMotif]

main.rs version 1

// main 1
#![allow(unused)]
#[derive(Debug)] // used for debugging

struct Rectangle01{
    width: u32,
    height: u32,
}

impl Rectangle01 {
    // Complete the area method which return the area of a Rectangle.
    fn area(&self)->u32{
        self.width*self.height
    }
}

struct TrafficLight02 {
    color: String,
}

impl TrafficLight02 {
    pub fn show_state(&self)  {
        println!("the current state is {}", self.color);
    }
}
struct Point {
    x: i32,
    y: i32,
}


fn main() {

    let light = TrafficLight02 {
        color: "red".to_owned(),
    };
    // Don't take the ownership of `light` here
    light.show_state();
    // ..otherwise, there will be an error below
    println!("{:?}", light);

/*
// I get this error
error[E0277]: `TrafficLight02` doesn't implement `Debug`
  --> src/main.rs:39:22
   |
39 |     println!("{:?}", light);
   |                      ^^^^^ `TrafficLight02` cannot be formatted using `{:?}`
   |
   = help: the trait `Debug` is not implemented for `TrafficLight02`
   = note: add `#[derive(Debug)]` to `TrafficLight02` or manually `impl Debug for TrafficLight02`
   = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider annotating `TrafficLight02` with `#[derive(Debug)]`
   |
16 + #[derive(Debug)]
17 | struct TrafficLight02 {
   |
 */

}

/*
cargo run
*/

main.rs version2

// main 1
#![allow(unused)]
#[derive(Debug)] // used for debugging


struct TrafficLight02 {
    color: String,
}

impl TrafficLight02 {
    pub fn show_state(&self)  {
        println!("the current state is {}", self.color);
    }
}
struct Point {
    x: i32,
    y: i32,
}


fn main() {

    let light = TrafficLight02 {
        color: "red".to_owned(),
    };
    // Don't take the ownership of `light` here
    light.show_state();
    // ..otherwise, there will be an error below
    println!("{:?}", light);

/*
// I do not get error.
 */

}

/*
cargo run
*/

Cargo.toml

[package]
name = "the_rust_supper"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

I use MacOS version 12.6.7 and VSCode. Why there is the error? How can I fix it?

imac@iMacs-iMac the_rust_supper % rustc --version
rustc 1.75.0 (82e1608df 2023-12-21)

[NihilisticMotif]

The solution is to write #[derive(Debug)] before the struct (that we want to print).

// main 1
#![allow(unused)]
#[derive(Debug)] // used for debugging

struct Rectangle01{
    width: u32,
    height: u32,
}

impl Rectangle01 {
    // Complete the area method which return the area of a Rectangle.
    fn area(&self)->u32{
        self.width*self.height
    }
}

#[derive(Debug)]
struct TrafficLight02 {
    color: String,
}

impl TrafficLight02 {
    pub fn show_state(&self)  {
        println!("the current state is {}", self.color);
    }
}

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}


fn main() {

    let light = TrafficLight02 {
        color: "red".to_owned(),
    };
    // Don't take the ownership of `light` here
    light.show_state();
    // ..otherwise, there will be an error below
    println!("{:?}", light);

}

/*
cargo run
*/

Also, thank to the ChatGPT that helped me solve this problem.

[BokutoMan]

down

[felipe300]

• done

[restart126]

不得不说比前面模式匹配简单，模式匹配最后那个所有权转移借用什么的问了ai、看了博客还是似懂非懂

[DylanJinx]

assert_eq!()函数可以同时比较String与&str这两个类型具体的内容是否相同。

[DylanJinx]

done~~~