A pesar de leer detenidamente la documentación, estoy bastante confundido sobre el significado de& y* símbolo en Rust, y más generalmente sobre qué es exactamente una referencia de Rust.

En este ejemplo, parece ser similar a una referencia de C ++ (es decir, una dirección que se desreferencia automáticamente cuando se usa):

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

Sin embargo, el siguiente código funciona exactamente igual:

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

Utilizando* desreferenciar una referencia no sería correcta en C ++. Entonces me gustaría entender por qué esto es correcto en Rust.

Mi comprensión hasta ahora, es que, insertando* frente a una referencia de Rust lo desreferencia, pero el* se inserta implícitamente de todos modos, por lo que no necesita agregarlo (mientras que en C ++, se inserta implícitamente y si lo inserta obtendrá un error de compilación).

Sin embargo, algo como esto no se compila:

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`

Pero esto funciona:

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

Parece que la desreferenciación implícita (a la C ++) es correcta para referencias inmutables, pero no para referencias mutables. ¿Por qué es esto?