basic/method

[sunface]

https://course.rs/basic/method.html

[zhangairku]

这里是不是少讲了函数指针，fn类型

[zrll12]

Fn类型在进阶的闭包里讲

[Brankond]

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

impl Rectangle {
pub fn new(width: u32, height: u32) -> Self {
Rectangle { width, height }
}
pub fn width(&self) -> u32 {
return self.width;
}
}

fn main() {
let rect1 = Rectangle::new(30, 50);

println!("{}", rect1.width());

}

这个位置为什么说 rect1.width 是私有的呢？
使用 pub 定义了 Rectangle 结构体后 width 字段不是应该变成 public 了吗？

[Neisseri]

那如果不加public的话在当前文件里能访问吗

[arronKler]

在 mod 中对外导出的时候，外部会无法访问这个 width，但对于和 mod 自身同层级的是可见的。如果是对 enum 设置 pub，则其中的每个值就默认都是 public，无需单独每个都设置一下 pub

[bluecode2017]

我理解是一旦有了公开的get 方法比如Width（）， 那字段就默认变成私有的。

[hello-stone]

加pub在模块内是公开的，在模块外是私有的。
mod my_module { // 在 my_module 模块中定义一个私有结构体 struct PrivateStruct { field: i32, } impl PrivateStruct { // 定义一个公共方法，用于修改私有字段的值 pub fn set_field(&mut self, value: i32) { self.field = value; } } } fn main() { // 创建一个 my_module 模块的作用域 { use my_module::PrivateStruct; let mut struct_instance = PrivateStruct { field: 42 }; // 通过公共方法修改私有字段的值 struct_instance.set_field(24); // 输出私有字段的值 println!("私有字段的值为: {}", struct_instance.field); } }
这个代码汇报错；在 struct PrivateStruct前加上pub，在字段加上pub才能让这个代码运行。

[hello-stone]

mod my_module {
// 在 my_module 模块中定义一个私有结构体
struct PrivateStruct {
field: i32,
}
impl PrivateStruct {
// 定义一个公共方法，用于修改私有字段的值
pub fn set_field(&mut self, value: i32) {
self.field = value;
}
}
}
fn main() {
// 创建一个 my_module 模块的作用域
{
use my_module::PrivateStruct;
let mut struct_instance = PrivateStruct { field: 42 };
// 通过公共方法修改私有字段的值
struct_instance.set_field(24);
// 输出私有字段的值
println!("私有字段的值为: {}", struct_instance.field);
}
}

[wentaotoyou]

只要是定义在impl中的函数就叫关联函数吧？而不管有没有self参数

[bluecode2017]

Rust语言新的概念好多啊，感觉绕的很

[Clazex]

可以看出有些人把答案怼面前了还是只会瞎编，甚至就在同个页面的同一个和下一个自然段都不愿看：

We can define associated functions that don’t have self as their first parameter ...

言下之意：关联函数也可以有 self 参数。

Associated functions that aren’t methods are often used for ...

言下之意：有的关联函数是方法。

实在不能理解什么叫“……的就是方法，否则就是关联函数”，《很明确》。

方法 methods 是关联函数 associated functions 的子集。只要在 impl 块中的都叫 associated functions，其中，有 self 参数的是 methods。

与 associated functions 对应的概念是 free functions 自由函数，即不在 impl 块中的函数，而不是方法。

[ysy]

https://doc.rust-lang.org/reference/items/associated-items.html

Associated functions whose first parameter is named self are called methods and may be invoked using the method call operator, for example, x.foo(), as well as the usual function call notation.

很显然方法(Method)是关联函数(Associated functions)的子集。教程中的表述： 这种定义在 impl 中且没有 self 的函数被称之为关联函数 是错误的，希望可以改下。

[duanyuluo]

Function (Unassociated with type) -> fn main() {}
Asscoiated Functons
-- method (of a object instance) -> fn area(&self) -> usize {}
-- other asscoiated function(of a type) -> impl Rect { fn from(...) {} }

[duanyuluo]

Asscoiated with some type(eg. struct, enum, trait...)

[lsm1998]

关联函数的描述，‘Rust 中有一个约定俗称的规则’，应该是约定俗成

[BiteFoo]

约定好了就遵守吧

[kingwingfly]

这个枚举类型好像Python里的类属性啊，或者__init__下面的东西哦。。。
还有那个can_hold不是很严谨，应该可以考虑旋转

impl Rectangle {	//为Rectangle结构体增加一种方法
    fn can_hold(self, other: Rectangle) -> bool {
        if (self.length >= other.length && self.width >= other.width)||(self.length >= other.width && self.width >= other.length) {
            return true
        }
        false
    }
}

[supernova4869]

Python的__init__下面是它的构造函数，类似这里的new

[ZLD1819858]

emm这里是讲用法，你这样考虑就有点轴了

[bluecode2017]

方法怎么定义和命名还是设计和写code的人说了算嘛

[791045873]

let rect3 = Rectangle { width: 60, height: 45 };
let sq = Rectangle::new(3, 3)；

这两种写法是等价的吗？
如果不等价有啥区别

[whtblktone]

这里展示的没有区别，但是有可能会在new函数中做些参数检查工作

[duanyuluo]

准确的说，你在Rectangle::new()中必须调用Rectangle{}才能构造出结构。

[duanyuluo]

new（）方法是你自己实现的，不是rust实现的。

[duanyuluo]

比如你可以不实现new，只写Rectangle::from()，就不会搞混了，你太熟悉new了。

[Gvhthon]

其结果而言是等价的。但第一个只是简单的创建了一个结构体的实例。而第二个是利用自定义的结构体的new方法创建实例，而在这个new方法中，可以而外的执行一些东西，比如初始化检测错误等等。

[bluecode2017]

”Rust 中有一个约定俗成的规则，使用 new 来作为构造器的名称，出于设计上的考虑，Rust 特地没有用 new 作为关键字“
这个是什么意思呢，看不太懂。 是不是说new在其他语言是操作符，是关键字。而在这里，只是一个普通的构造函数/方法？

[bluecode2017]

好奇为什么不默认把每个struct都自动实现好一个new方法呢？还得自己手写。

[shenyongqing]

我的理解是rust的每一个变量都要求明确的值（不像go），如果结构体成员太多，struct {::::}写起来非常不方便，用一个new函数给出几个关键的成员值，其他就用默认值好了。那么制造一个对象就简洁多了。

[duanyuluo]

第一，在C中，alloc只负责分配内存，结构体的初始化还是要你自己写的。
第二，在Rust中，不推荐出现没有明确初始化的fields。
第三，所谓的默认实现的new都是伪的，因为你在真正使用前不初始化，是不可预测的。
第四，你可以参考Default trait，rust只是不隐藏的默认做而已。

[Vocal-map]

关联函数和方法的区别是啥？

[ka3hun9]

关联函数 : 相当于结构体的静态方法,
方法 : 相当于结构体的实例方法

[duanyuluo]

不必拘泥名词，只要记得
fn main()
impl XX { fn foo() {} } -> XX::foo()
impl XX {fn foo(&self) {} } -> obj.foo()
let f = |x| x+1; -> f(2);

function
method of type
method of object
lamda function

[JoshuaGhost]

大佬可能笔误了吧，方法不需要用@classmethod装饰器啦，而且@classmethod本来就支持直接用类名来调用，而且第一个参数cls是指代本类的。这也就是为啥工厂模式是用这玩意实现的。比如：

Class Foo:
    @classmethod
    def foo_factory(cls, *args, **kwargs) -> "Foo":
        do_something()
        return cls(*args, **kwargs)

而方法就是那些有self不用两个装饰器的方法，比如

Class Bar:
    def do_anything(self, buz) -> int:
        self.do_everything(buz)
        return 42

这个do_anything的函数是方法，就是只能通过instanciation来调用：

bar = Bar()
assert bar.do_anything == 42

[Gvhthon]

我的理解是如果你想在函数里调用实例的字段（属性），那就用方法。如果只是简单的实现一些动作，用关联函数就可以了。比如a.changeNumber(18);

[xbsheng]

看第一个参数是不是&self/&mut self/self就可以区分，是这几个值就代表是方法，不是就代表是关联函数。个人认为rust中的方法就是其他语言中的实例方法，关联函数就是静态方法，不确定这个理解确切不~

[duanyuluo]

ref rustdoc std::ops
Fn
FnMut
FnOnce
Only three types of functions
分别对应
不影响闭包环境
影响闭包环境
影响且只能一次影响闭包环境

https://blog.csdn.net/wowotuo/article/details/80785358#:~:text=Fn%EF%BC%9A%E5%AE%83%E5%8F%AA%E8%83%BD%E4%BB%8E,%E5%BC%95%E5%87%BAFn%EF%BC%8CFnMut%EF%BC%8CFnOnce%3F
这篇文章讲的很好

[duanyuluo]

发错地方了……应该在closure中。。。。

[duanyuluo]

不过我觉得，fn就是给一个闭包命名 ：D

[jieqiyue]

怎么哪里都有你

[tayuqitan]

这章两个概念比较绕，关联函数和方法的区别。这里做个笔记：
1、最大的区别就是，关联函数绑定给类型。方法绑定给实例。
2、关联函数和方法都可以使用obj[Obj]::fn方式调用。只是调用方法的时候需要传入&self参数。eg：Rectangle::width(&rect);
3、关联函数不能通过obj.fn方式调用。只能通过Obj::fn方式调用。

[CListery]

关联函数，就叫构造函数又怎么了嘛，非要取些怪头怪脑的名字让人不便记忆

[tayuqitan]

其实叫静态函数，更贴切一些。但是也不全对，所有绑定给类型的都叫：关联函数。

[CListery]

不敢苟同，以下是个人见解：

1. 静态函数，一般指不需要构建对象的情况下就可以调用该对象的内部函数
2. 关联函数，在rust中指的是用于构建对象的特殊函数
3. 方法，在rust中指的是除关联函数外的函数

[Dmcz]

关联函数也并非用于构建对象

[Dmcz]

错了，应该是并非只用于构建对象...

[liuhq]

@CListery 错了，所有在 impl 块中实现的函数都叫关联函数，其中第一个参数是 Self 类型的关联函数可以称为方法，所以方法是关联函数的子集，而不是互斥的关系

[yanzongt]

关联函数比构造函数更灵活，还不用考虑c++中一系列的继承析构问题；
尤其枚举类型，不仅可以嵌套匹配，还可以定义方法，我们rust真的太强大啦。

[wslzs]

我理解 ‘&self’相当于java中的this

[xbsheng]

俺也一样

[madjxatw]

如果理解正确，对比C++，关联函数类似 static 成员函数，表示与某个类相关的函数；方法类似成员函数，作用于类的实例对象。

[liuhq]

理解错了，所有在 impl 块中实现的函数都叫关联函数，其中第一个参数是 Self 类型的关联函数可以称为方法，所以方法是关联函数的子集，而不是互斥的关系

[madjxatw]

教程中应该加入一些其他语言的类比，帮助加快理解速度。如果只是扣文字和一些简单案例，效率低，还容易造成困惑。

[xbsheng]

但是其他语言太多了，读者不一定熟悉类比的语言

[Rgoogle]

Rust 会自动为 object 添加 &、&mut 或 * 以便使 object 与方法签名匹配。 这句话是错误的，&mut这个不会加，会报错啊！在实现了copy trait的时候 好像又莫名其妙的能调用了，但是前提条件却没有

[Skyfacon]

学习打卡

[Datu1213]

大哥加油。

[TianChen-Yu]

所以自由函数、关联函数、方法这三者在底层实现上是怎样的？在运行和性能上有差异吗？

我的理解是，

• 所谓 关联函数 就是需要 类型::函数名 访问的函数（所以就是 与类型关联 ）
• 所谓 方法 就是 在第一个参数使用 self 关键字 的关联函数（是关联函数的一种）

然而，Rust有个很灵活的特性：类型实例的 方法 实际上也可以通过 关联函数 的形式进行调用，
比如

// 定义所用的结构体
struct S(i32);
// 这是结构体的 实例方法
impl S {
    pub fn add_from(&mut self, other: i32) {
        self.0 += other;
    }
}
// 与之等价的 自由函数
pub fn add_from(s: &mut S, other: i32) {
    s.0 += other;
}

fn main() {
    // 初始化一个结构体
    let mut s = S(0);
    // 以 实例方法 的形式调用
    s.add_from(1);
    // 以 关联函数 的形式调用
    S::add_from(&mut s, 1);
    // 用 自由函数 调用
    add_from(&mut s, 1);
}

这里边的 关联函数 个人觉得已经很像 自由函数 了（除了加个类型作为命名空间区分），
实际编译的时候是否也会有 自由函数 的性能？
或者是否可以说，
实际上整个 关联函数 实例方法 的机制，
都是Rust 零成本抽象 的语法糖？

[qiyuewuyi2333]

自由函数和关联函数的性能没什么区别的。（来自微量的benchmarks）

[hamsterjiang23]

 // 可以为枚举实现方法
        enum Message{
            Quit {boolean : bool},
            Move {x : i32, y : i32},
            Write(String),
            ChangeColor(i32, i32, i32)
        }

        impl Message{
           fn call(&self) -> (){
            // 输出write里的string
            match self {
                Message::Write(string) => {
                    println!("Message string is {}", string)
                },
                Message::ChangeColor(x, y , z) => {
                    println!("Message change color is ({}, {}, {})", x, y, z)
                }
                _ => ()
            }
           }
        }

        let msg1 = Message::Write("Hello".to_string());
        let msg2 = Message::ChangeColor(1,2,3);
        msg1.call();
        msg2.call();

[feiandre]

Trait 其他教材翻译成特型, 这里翻译成特征. 感觉怪怪的

[Hello-world150]

是不是我还没学到难点，至少目前觉得还挺简单的😉

[xbsheng]

这章类比其他语言的静态方法、实例方法学习比较容易理解~

[typed-sigterm]

在 C/C++ 语言中，有两个不同的运算符来调用方法：. 直接在对象上调用方法，而 -> 在一个对象的指针上调用方法，这时需要先解引用指针。换句话说，如果 object 是一个指针，那么 object->something() 和 (*object).something() 是一样的。

其实 -> 才是语法糖

[jkbody]

done