7.13.1. Structure definition #

This is a structure definition:

struct Site {
    domain: String,
    name: String,
    nation: String,
    found: u32
}

Note: if you use CCompact Clippers, please remember that in Rust `` struct``statement is only used for definition, the instance cannot be declared, theend is not required; symbols, and each field is separated after definition.

7.13.2. Structure instance #

Rust is influenced by JavaScript in many places. When instantiating a structure, it uses the JSON object’s key : value syntax to implement the definition:

let runoob = Site {
    domain: String::from("www.runoob.com"),
    name: String::from("RUNOOB"),
    nation: String::from("China"),
    found: 2013
};

Structure class name {
    Field Name: Field Value,
    ...
}

let domain = String::from("www.runoob.com");
let name = String::from("RUNOOB");
let runoob = Site {
    domain,  // Equivalent to domain : domain,
    name,    // Equivalent to name : name,
    nation: String::from("China"),
    traffic: 2013
};

let site = Site {
    domain: String::from("www.runoob.com"),
    name: String::from("RUNOOB"),
    ..runoob
};

7.13.3. Tuple structure #

There is a simpler way to define and use structures: tuple structures.

A tuple structure is a form that is a tuple structure.

It differs from tuples in that it has a name and a fixed type format. It exists to deal with simple data that needs to be defined (often used) and does not want to be too complex:

struct Color(u8, u8, u8);
struct Point(f64, f64);

let black = Color(0, 0, 0);
let origin = Point(0.0, 0.0);

“Color” and “point coordinates” are two commonly used data types, but Rust won’t leave this problem if you write curly braces and two names in instantiation at the expense of convenience for readability. Tuple structureobjects are used in the same way as tuples, through. And subscript to access:

fn main() {
    struct Color(u8, u8, u8);
    struct Point(f64, f64);
    let black = Color(0, 0, 0);
    let origin = Point(0.0, 0.0);
    println!("black = ({}, {}, {})", black.0, black.1, black.2);
    println!("origin = ({}, {})", origin.0, origin.1);
}

black = (0, 0, 0)
origin = (0, 0)

7.13.4. Ownership of structure #

The structure must have ownership of the field value, because all fields arereleased when the structure fails.

This is why the case in this chapter is used String type without using the &str reason.

However, this does not mean that reference fields are not defined in the structure, which needs to be achieved through the “lifecycle” mechanism.

However, it is difficult to explain the concept of “life cycle”, so it canonly be explained in later chapters.

7.13.5. Output structure #

In debugging, it is useful to show a complete instance of a structure. But if we write a format manually, it will be very inconvenient. So Rust provides a convenient way to output an entire structure:

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}
fn main() {
    let rect1 = Rectangle { width: 30, height: 50 };
    println!("rect1 is {:?}", rect1);
}

rect1 is Rectangle { width: 30, height: 50 }

rect1 is Rectangle {
    width: 30,
    height: 50
}

7.13.6. Structural body method #

The method (Method) is similar to the function, except that it isused to manipulate the structure instance.

If you have learned some object-oriented languages, you must be well aware that functions are generally placed in class definitions and used in functions. this represents the instance of the operation.

The Rust language is not object-oriented, as can be seen from the innovationof its ownership mechanism. But the precious idea of object-oriented can beimplemented in Rust.

The first parameter of the structure method must be &self there is no need to declare the type, because self not a style, but a keyword.

Calculate the area of a rectangle:

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!("rect1's area is {}", rect1.area());
}

rect1's area is 1500

struct Rectangle {
    width: u32,
    height: u32,
}
impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
    fn wider(&self, rect: &Rectangle) -> bool {
        self.width > rect.width
    }
}
fn main() {
    let rect1 = Rectangle { width: 30, height: 50 };
    let rect2 = Rectangle { width: 40, height: 20 };
    println!("{}", rect1.wider(&rect2));
}

false

7.13.7. Structure correlation function #

The reason why “structure method” is not called “structure function” is because the name “function” is left to this function: it is in the impl , but &self parameters is not in the block. .

This function does not depend on the instance, but you need to declare whereto use it impl in the block.

Always in use. String::from a function is a “correlation function”.

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}
impl Rectangle {
    fn create(width: u32, height: u32) -> Rectangle {
        Rectangle { width, height }
    }
}
fn main() {
    let rect = Rectangle::create(30, 50);
    println!("{:?}", rect);
}

Rectangle { width: 30, height: 50 }

7.13.8. Unit structure #

A structure can be used only as a symbol without any member:

struct UnitStruct;

We call this structure without a body a Unit Struct.