Rust by Example - Collective of authors читать книгу онлайн полностью

На первую страницу

>println!("one element tuple: {:?}", (5u32,));

>println!("just an integer: {:?}", (5u32));

>//tuples can be destructured to create bindings

>let tuple = (1, "hello", 4.5, true);

>let (a, b, c, d) = tuple;

>println!("{:?}, {:?}, {:?}, {:?}", a, b, c, d);

>let matrix = Matrix(1.1, 1.2, 2.1, 2.2);

>println!("{:?}", matrix);

>}

>הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

>XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Activity

1. Recap: Add the fmt::Display trait to the Matrix struct in the above example, so that if you switch from printing the debug format {:?} to the display format {}, you see the following output:

>( 1.1 1.2 )

>( 2.1 2.2 )

You may want to refer back to the example for print display.

2. Add a transpose function using the reverse function as a template, which accepts a matrix as an argument, and returns a matrix in which two elements have been swapped. For example:

>println!("Matrix:\n{}", matrix);

>println!("Transpose:\n{}", transpose(matrix));

results in the output:

>Matrix:

>( 1.1 1.2 )

>( 2.1 2.2 )

>Transpose:

>( 1.1 2.1 )

>( 1.2 2.2 )

Arrays and Slices

An array is a collection of objects of the same type T, stored in contiguous memory. Arrays are created using brackets [], and their length, which is known at compile time, is part of their type signature [T; length].

Slices are similar to arrays, but their length is not known at compile time. Instead, a slice is a two-word object, the first word is a pointer to the data, and the second word is the length of the slice. The word size is the same as usize, determined by the processor architecture eg 64 bits on an x86-64. Slices can be used to borrow a section of an array, and have the type signature &[T].

>use std::mem;

>// This function borrows a slice

>fn analyze_slice(slice: &[i32]) {

>println!("first element of the slice: {}", slice[0]);

>println!("the slice has {} elements", slice.len());

>}

>fn main() {

>// Fixed-size array (type signature is superfluous)

>let xs: [i32; 5] = [1, 2, 3, 4, 5];

>// All elements can be initialized to the same value

Перейти на страницу

Rust by Example | страница 11