Structs in trust

1. introduction

In the previous article , We have introduced in detail Rust Basic syntax ：

In many languages , We have all been exposed to the composite data type structure for a long time , In an object-oriented language , The concept of class is very similar , stay rust In language , Structs are also a useful and powerful data type , that , stay rust In language , How to define and use the data type structure ？

2. Definition of structure

stay rust in , Tuples 、 Array 、 Structures are composite structures of data , The difference between them is ：

1. Array ： Each element must have the same data type ;
2. Tuples ： Each element has its own type ;
3. Structure ： Each element has its own type , And each element needs to be named .

The following is the definition of a typical structure ：

struct User {
    username: String,
    email: String,
    active: bool
}

Copy

It seems that in addition to the field naming and type, it depends on rust Unique language format , Other aspects are not very different from the definition of structure in other languages .

rust It is also allowed to declare structures that do not name any fields , Such a structure is called “ Tuple structure ”, Equivalent to a named tuple ：

struct Color(i32, i32, i32);

Copy

• It should be noted that , Defined here uses String type , instead of &str type , because rust Unique life cycle issues , Will cause the use of &str Types can cause some trouble , The following chapters will cover .

3. The use of structures

3.1 Example

let user1 = User {
    email: String::from("[email protected]"),
    username: String:from("Amy"),
    active: true
};

println!("{}'s email is {}", user1.username, user1.email);

Copy

This is the use of a typical structure .

3.2 variability

If we want to modify a field of a structure variable , You must declare the structure variable as mutable mut：

let mut user1 = User {
    email: String::from("[email protected]"),
    username: String:from("Amy"),
    active: false
};


user1.active = true;

Copy

• It should be noted that ,rust It is not supported to declare some fields individually , Once the instance is declared mutable , It means that any field in the whole structure is variable .

3.3 The use of sugar to simplify the structure

1. Simplification of variable name and field name

fn build_user(email: String, username: String) -> User {
    User {
        email,
        username,
        active: true
    }
}

Copy

2. Fields from other instances

let user2 = User {
    email: String::from("[email protected]"),
    username: String::from("Tom"),
    ..user1
}

Copy

Here grammar ..user1 Indicates that the remaining fields are from user1 example .

4. Method

In an object-oriented language , Objects have their own properties , Often there are many behaviors , These behaviors are generally defined as classes method, That's the method .

Even in C In a non object-oriented language like C , You can also add behavior to the structure through function pointers , stay rust in , It also supports adding methods to structures .

4.1 Define methods

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!(
        "The area of the rectangle is {} square pixels.",
        rect1.area()
    );
}

Copy

In the above code ,struct Keyword defines a structure Rectangle, And then through impl Bind several methods to the structure , By way of example . The operator , We can implement the method call .

stay impl In block , We can use Self As an alias of the original type .

For a structure ,impl Blocks do not have only one , A structure can have many impl block , You can even create a separate for each method or correlation function impl block .

4.2 correlation function

And in the impl Defined in does not need to be passed &self The function of the parameter is called ” correlation function “, Very similar to java In language static Method , for example ：

impl Rectangle {
    fn square(size: u32) -> Rectangle {
        Rectangle {
            width: size,
            height: size,
        }
    }
}

fn main() {
   let rectangle = Rectangle::square(4);
}

Copy

As in the example above , The association function of the structure needs to be connected with the structure type name through :: Symbol to call .