C++与Rust的另一处对比

在C++中，当你有一个指向了类cls的对象的指针pObj时，如果你要调用cls的成员函数f，就需要用pObj->f()的语法，而不再是pObj.f()了。这是因为，pObj有可能是C++的某种智能指针，例如shared_ptr。而智能指针作为一个类，也是有它自己的成员函数的。换句话说，若pObj的类型是shared_ptr<cls>，则pObj.f()调用的不是cls::f，而是shared_ptr<cls>::f。恐怕正是因此，所以C++才需要->操作符。
然而在Rust中，并没有->操作符。不论pObj是cls的实例本身，还是指向cls的一个实例的引用或指针，pObj.f()都被Rust看作是调用cls的f；这是通过方法的self参数实现的：
In C and C++, two different operators are used for calling methods: you use . if you’re calling a method on the object directly and -> if you’re calling the method on a pointer to the object and need to dereference the pointer first. In other words, if object is a pointer, object->something() is similar to (*object).something().

Rust doesn’t have an equivalent to the -> operator; instead, Rust has a feature called automatic referencing and dereferencing. Calling methods is one of the few places in Rust with this behavior.

Here’s how it works: when you call a method with object.something(), Rust automatically adds in &, &mut, or * so object matches the signature of the method.
This automatic referencing behavior works because methods have a clear receiver—the type of self. Given the receiver and name of a method, Rust can figure out definitively whether the method is reading (&self), mutating (&mut self), or consuming (self). The fact that Rust makes borrowing implicit for method receivers is a big part of making ownership ergonomic in practice.