Estruturas

Existem três tipos de estruturas ("structs") que podem ser criadas usando a palavra-chave struct:

• Estruturas de tupla, que são, basicamente, tuplas nomeadas.
• A estruturas de C clássicas,
• Estruturas unitárias, que são sem campo, são úteis para genéricos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
// Um atributo para esconder avisos de código não usado.
#![allow(dead_code)]
#[derive(Debug)]
struct Person {
    name: String,
    age: u8,
}
// Uma estrutura unitária
struct Unit;
// Um estrutura de tupla
struct Pair(i32, f32);
// Uma estrutura com dois campos
struct Point {
    x: f32,
    y: f32,
}
// As estruturas podem ser reutilizadas como campos duma outra estrutura
struct Rectangle {
    // Um retângulo pode ser especificado pela posição dos cantos
    // superior esquerdo e inferior direito no espaço.
    top_left: Point,
    bottom_right: Point,
}
fn main() {
    // Criar a estrutura com a abreviatura de inicialização de campo
    let name = String::from("Peter");
    let age = 27;
    let peter = Person { name, age };
    // Imprimir em depuração a estrutura
    println!("{:?}", peter);
    // Instanciar um `Point`
    let point: Point = Point { x: 10.3, y: 0.4 };
    // Acessar os campos do ponto
    println!("point coordinates: ({}, {})", point.x, point.y);
    // Criar um novo ponto usando a sintaxe de atualização de estrutura
    // para usar os campos do nosso outro
    let bottom_right = Point { x: 5.2, ..point };
    // `bottom_right.y` será o mesmo que `point.y` porque usamos este campo
    // a partir de `point`
    println!("second point: ({}, {})", bottom_right.x, bottom_right.y);
    // Desestruturar o ponto usando uma vínculo `let`
    let Point { x: left_edge, y: top_edge } = point;
    let _rectangle = Rectangle {
        // A instanciação da estrutura também é uma expressão
        top_left: Point { x: left_edge, y: top_edge },
        bottom_right: bottom_right,
    };
    // Instanciar uma estrutura unitária
    let _unit = Unit;
    // Instanciar uma estrutura de tupla
    let pair = Pair(1, 0.1);
    // Acessar os campos duma estrutura de tupla
    println!("pair contains {:?} and {:?}", pair.0, pair.1);
    // Desestruturar uma estrutura de tupla
    let Pair(integer, decimal) = pair;
    println!("pair contains {:?} and {:?}", integer, decimal);
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Atividade

1. Adicione uma função rect_area que calcula a área dum Rectangle (tente usar desestruturação encaixada).
2. Adicione uma função square que recebe um Point e um f32 como argumentos, e retorna um Rectangle com o seu canto superior esquerdo no ponto, e uma largura e altura correspondendo ao f32.

Consulte também

attributes, e desestruturação