Accesso valori di enum in Rust

Question

struct Point { x: f64, y: f64 } 

enum Shape { 
    Circle(Point, f64), 
    Rectangle(Point, Point) 
} 

let my_shape = Shape::Circle(Point {x: 0.0, y: 0.0}, 10.0); 

Desidero stampare la seconda proprietà del cerchio, che è 10.0 qui. Ho provato my_shape.last e my_shape.second, ma nessuno dei due ha funzionato.

Cosa devo fare per stampare 10.0 in questo caso?

Grazie

Answer 1

non sono sicuro se c'è un modo migliore per farlo, ma è possibile utilizzare il pattern matching:

use std; 

type point = {x: float, y: float}; 
enum shape { 
    circle(point, float), 
    rectangle(point, point) 
} 

fn main() { 
    let my_shape = circle({x: 0.0, y: 0.0}, 10.0); 
    alt my_shape { 
     circle(_, value) { 
      std::io::println(#fmt("value: %f", value)); 
     } 
    } 
} 

uscita Esempio:

value: 10 

Answer 2

Ecco un altro modo per farlo:

use std; 

type point = {x: float, y: float}; 
enum shape { 
    circle(point, float), 
} 

fn main() { 
    let circle(_, radius) = circle({x: 0.0, y: 0.0}, 10.0); 
    std::io::println(#fmt("value: %f", radius)); 
} 

Funziona solo se il modello let è irrefutabile, ad esempio, se il tipo di enum a cui si sta abbinando ha solo una variante. Per fare questo lavoro, ho dovuto rimuovere la variante rectangle inutilizzata.

Nei casi in cui si dispone di più di una variante, probabilmente si vorrà comunque la massima espressione, dal momento che si presume che maneggi più di un solo tipo di forma.

Answer 3

dal tutorial Rust (il corsivo è mio):

Per i tipi enum con più varianti, destrutturazione è l'unico modo per ottenere al loro contenuto. Tutti i costruttori variante possono essere usati come modelli, come in questa definizione di zona:

fn area(sh: shape) -> float { 
    alt sh { 
     circle(_, size) { float::consts::pi * size * size } 
     rectangle({x, y}, {x: x2, y: y2}) { (x2 - x) * (y2 - y) } 
    } 
} 

http://doc.rust-lang.org/doc/tutorial.html#enum-patterns

Se desideri essere in grado di scrivere funzioni che sono in grado di lavorare su più tipi con diverse rappresentazioni, dare un'occhiata a interfacce:

http://doc.rust-lang.org/doc/tutorial.html#interfaces

Answer 4

Come si è interessati solo a matchin g una delle varianti, è possibile utilizzare un if let espressione:

struct Point { x: f64, y: f64 } 

enum Shape { 
    Circle(Point, f64), 
    Rectangle(Point, Point) 
} 

fn main() { 
    let my_shape = Shape::Circle(Point { x: 0.0, y: 0.0 }, 10.0); 

    if let Shape::Circle(_, radius) = my_shape { 
     println!("value: {}", radius); 
    } 
} 

Questo significa che "se my_shape possono essere destrutturati in una Circle, non fare nulla con il primo indice, ma associare il valore del secondo indice per radius" .