rotz gründlicher Lektüre der Dokumentation bin ich ziemlich verwirrt über die Bedeutung des& und* -Zeichen in Rust und allgemeiner darüber, was genau eine Rust-Referenz ist.

In diesem Beispiel ähnelt es einer C ++ - Referenz (dh einer Adresse, die bei Verwendung automatisch dereferenziert wird):

fn main() {
    let c: i32 = 5;
    let rc = &c;
    let next = rc + 1;
    println!("{}", next); // 6
}

Der folgende Code funktioniert jedoch genauso:

fn main() {
    let c: i32 = 5;
    let rc = &c;
    let next = *rc + 1;
    println!("{}", next); // 6
}

Using*, um eine Referenz zu dereferenzieren, wäre in C ++ nicht korrekt. Ich würde gerne verstehen, warum dies in Rust richtig ist.

Mein bisheriges Verständnis ist das Einfügen von* vor einer Rust Referenz dereferenziert es, aber die* ist ohnehin implizit eingefügt, so dass Sie es nicht hinzufügen müssen (während es in C ++ implizit eingefügt ist und wenn Sie es einfügen, wird ein Kompilierungsfehler angezeigt).

Allerdings kompiliert so etwas nicht:

fn main() {
    let mut c: i32 = 5;
    let mut next: i32 = 0;
    {
        let rc = &mut c;
        next = rc + 1;
    }
    println!("{}", next);
}

error[E0369]: binary operation `+` cannot be applied to type `&mut i32`
 --> src/main.rs:6:16
  |
6 |         next = rc + 1;
  |                ^^^^^^
  |
  = note: this is a reference to a type that `+` can be applied to; you need to dereference this variable once for this operation to work
  = note: an implementation of `std::ops::Add` might be missing for `&mut i32`

Aber das funktioniert:

fn main() {
    let mut c: i32 = 5;
    let mut next: i32 = 0;
    {
        let rc = &mut c;
        next = *rc + 1;
    }
    println!("{}", next);  // 6
}

Es scheint, dass die implizite Dereferenzierung (a la C ++) für unveränderliche Referenzen korrekt ist, aber nicht für veränderbare Referenzen. Warum ist das