Warum warnt der Compiler vor einer nicht initialisierten Variablen, obwohl ich jedes Feld dieser Variablen zugewiesen habe?

Hernán

Ich ordne die Felder der MyStructInstanz, die xin jeder möglichen Klammer der Übereinstimmung genannt werden, vollständig zu :

enum MyEnum {
    One,
    Two,
    Three,
}

struct MyStruct {
    a: u32,
    b: u32,
}


fn main() {
    f(MyEnum::One);
    f(MyEnum::Two);
    f(MyEnum::Three);
}

fn f(y: MyEnum) -> MyStruct {
    let mut x: MyStruct;

    match y {
        MyEnum::One => {
            x.a = 1;
            x.b = 1;
        }
        MyEnum::Two => {
            x.a = 2;
            x.b = 2;
        }
        MyEnum::Three => {
            x.a = 3;
            x.b = 3;
        }
    }

    x
}

Warum gibt der Compiler den folgenden Fehler zurück?

error[E0381]: use of possibly uninitialized variable: `x`
  --> src/main.rs:37:5
   |
37 |     x
   |     ^ use of possibly uninitialized `x`

Ich denke, dies ist ein bekanntes Problem (siehe auch das zugehörige Problem).

red75prime

let x: MyStruct;setzt keinen xleeren Wert, sondern deklariert eine Variable. Sie müssen ihm noch einen Wert zuweisen.

fn f(y: MyEnum) -> MyStruct {
    let x;

    match y {
        MyEnum::One => {
            x = MyStruct { a: 1, b: 1 };
        }
        MyEnum::Two => {
            x = MyStruct { a: 2, b: 2 };
        }
        MyEnum::Three => {
            x = MyStruct { a: 3, b: 3 };
        }
    }

    x
}

Mit anderen Worten, let x;erstellt eine ungebundene Variable, eine Variable, der kein Wert zugeordnet ist. Daher müssen Sie später einen Wert daran binden.

Wenn Sie nur einen Wert von der Funktion zurückgeben möchten, können Sie die Tatsache nutzen, dass fast jede Anweisung in Rust einen Wert erzeugt und ein Wert der letzten Anweisung der Rückgabewert einer Funktion ist.

fn f(y: MyEnum) -> MyStruct {
    use MyEnum::*;

    let x = match y {
        One   => MyStruct { a: 1, b: 1 },
        Two   => MyStruct { a: 2, b: 2 },
        Three => MyStruct { a: 3, b: 3 },
    };
    x
}

Sie können auch vollständig eliminieren x, wenn Sie dies wünschen.

fn f(y: MyEnum) -> MyStruct {
    use MyEnum::*;

    match y {
        One   => MyStruct { a: 1, b: 1 },
        Two   => MyStruct { a: 2, b: 2 },
        Three => MyStruct { a: 3, b: 3 },
    }
}

Verwandte Artikel

Warum ist der Wert, den ich einer Variablen zugewiesen habe, weg?

Eric Ich habe den Wert von a einem variableAanderen Formular zugewiesen variableB. Warum sind beide Variablen leer, nachdem ich das gelöscht habe variableA? Before execute entries.clear() After execute entries.clear() Jon Skeet Beide frm5.entriesund entriesv

Warum warnt der Compiler nicht vor der Umwandlung in Enumeration?

Peter Varo Ich war ziemlich schockiert, als mir klar wurde, dass D es dem Benutzer ermöglicht, einen kompatiblen Wert in a umzuwandeln enumund somit einen ungültigen enumWert zu erzeugen , was meiner Meinung nach in vielen Ebenen problematisch ist. Wenn ich zu