Tutoriales

Arreglos y tuplas en Rust

En el artículo anterior, aprendió sobre los tipos de datos escalares en Rust. Son números enteros, números de punto flotante, caracteres y valores booleanos.

En este artículo, veremos los tipos de datos compuestos en el lenguaje de programación Rust.

¿Qué son los tipos de datos compuestos en Rust?

Los tipos de datos compuestos consisten en almacenar múltiples valores en una variable. Los valores pueden ser del mismo tipo de datos escalares o de diferentes tipos escalares.

El lenguaje de programación Rust tiene dos tipos de datos de este tipo:

  • formación: Almacena múltiples valores del mismo tipo.
  • tupla: Almacena múltiples valores, que pueden ser del mismo tipo o de diferentes tipos.

¡Así que vamos a echarles un vistazo!

Matrices en Rust

Las matrices en el lenguaje de programación Rust tienen las siguientes propiedades:

  • Cada elemento debe tener el mismo tipo.
  • Los arreglos tienen una longitud fija
  • Las matrices se almacenan en la pila, es decir, se puede acceder a los datos almacenados en ella Rápidamente

La sintaxis para crear una matriz es la siguiente:

// without type annotation
let variable_name = [element1, element2, ..., elementn];

// with type annotation
let variable_name: [data_type; array_length] = [element1, element2, ..., elementn];

Los elementos de una matriz se declaran entre corchetes. Para acceder a un elemento de una matriz, el índice al que se accede se especifica entre corchetes.

Veamos un programa de muestra para entender esto mejor.

fn main() {
    // without type annotation
    let greeting = ['H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '!'];

    // with type annotation
    let pi: [i32; 10] = [1, 4, 1, 5, 9, 2, 6, 5, 3, 5];

    for character in greeting {
        print!("{}", character);
    }

    println!("\nPi: 3.1{}{}{}{}", pi[0], pi[1], pi[2], pi[3]);
}

Aquí, defino una matriz de caracteres y otra tienda i32 ingresarlo.este greeting array contiene los caracteres de la cadena «¡Hola mundo!». almacenados en él como caracteres individuales.formación pi Almacene los primeros 10 valores de Pi después del punto decimal como números individuales en él.

Luego imprimo cada caracter greeting uso de matriz for anillo. (Entraré en el ciclo en breve). Luego, imprimo los primeros 4 valores pi grandes lotes.

Hello world!
Pi: 3.11415

Si desea crear una matriz donde cada elemento es y pasar X Muchas veces, puede usar los siguientes atajos para hacer esto en Rust:

let variable_name = [y; x];

Veamos una demostración…

fn main() {
    let a = [10; 5];

    for i in a {
        print!("{i} ");
    }
    println!("");
}

creo una variable a La longitud es de 5. Cada elemento de esta matriz es «10».Verifiqué esto imprimiendo cada elemento de la matriz usando for anillo.

Tiene la siguiente salida:

10 10 10 10 10

🤸

Como ejercicio, intente crear una matriz de longitud X y visita x+1Yingshi elementos de la matriz. Ya veremos.

Tuplas en Rust

Las tuplas en el lenguaje de programación Rust tienen las siguientes propiedades:

  • Las tuplas tienen una longitud fija como matrices
  • los elementos pueden ser del mismo/diferente tipo de datos escalares
  • Las tuplas se almacenan en la pila, es decir, se accede más rápido

La sintaxis para crear una tupla es la siguiente:

// without type annotation
let variable_name = (element1, element2, ..., element3);

// with type annotation
let variable_name: (data_type, ..., data_type) = (element1, element2, ..., element3);

Los elementos de la tupla se escriben entre paréntesis. Para acceder a un elemento, utilice el operador punto, seguido del índice de dicho elemento.

fn main() {
    let a = (38, 923.329, true);
    let b: (char, i32, f64, bool) = ('r', 43, 3.14, false);

    println!("a.0: {}, a.1: {}, a.2: {}", a.0, a.1, a.2);
    println!("b.0: {}, b.1: {}, b.2: {}, b.3: {}", b.0, b.1, b.2, b.3);

    // destructuring a tuple
    let pixel = (50, 0, 200);
    let (red, green, blue) = pixel;
    println!("red: {}, green: {}, blue: {}", red, green, blue);
}

En el código anterior, declaro dos tuplas en las líneas 2 y 3. Estos solo contienen valores aleatorios que inventé en el acto. Pero fíjate bien, el tipo de datos de cada elemento en las dos tuplas es diferente. Luego, en las líneas 5 y 6, imprimo cada elemento de las dos tuplas.

En la línea 9, declaro un pixel Hay 3 elementos en él. Cada elemento tiene el tamaño de los colores rojo, verde y azul que componen un píxel. El rango es de 0 a 255.Entonces, idealmente, anotaría el tipo como (u8, u8, u8) Pero no necesitas optimizar mientras aprendes 😉

Luego, en la línea 10, «desestructuro» el pixel tupla y almacenarla en variables individuales red, green y blueEntonces, en lugar de imprimir el valor pixel tupla, los valores que imprimo red, green y blue variable.

Veamos la salida…

a.0: 38, a.1: 923.329, a.2: true
b.0: r, b.1: 43, b.2: 3.14, b.3: false
red: 50, green: 0, blue: 200

Me parece bien 🙂

Recompensa: rebanada

Estrictamente hablando, los segmentos no son un tipo de datos compuesto en Rust. En cambio, las rebanadas son… pedazo Tipos de datos compuestos existentes.

Un segmento consta de tres elementos:

  1. Índice de comienzo
  2. El operador de corte (.. o ..=)
  3. índice final

A continuación se muestra un ejemplo que usa el corte de matriz.

fn main() {
    let my_array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
    let my_slice = &my_array[0..4];

    for element in my_slice {
        println!("{element}");
    }
}

Al igual que en C y C++, el símbolo & se usa para almacenar referencias (en lugar de punteros sin procesar) a variables.entonces &my_array representa una referencia a una variable my_array.

Ahora, llegando a las rebanadas.rebanado por [0..4]. aquí, es el índice donde comienza el segmento.y 4 es donde termina la rebanada. Aquí 4 es un índice no inclusivo.

Aquí está la salida del programa para entender mejor lo que está pasando:

0
1
2
3

si quieres uno incluido rango, puede usar en su lugar ..= Como operador de división para rangos inclusivos.

fn main() {
    let my_array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
    let my_slice = &my_array[0..=4];

    for element in my_slice {
        println!("{element}");
    }
}

Ahora, el rango es de 0día elementos a 4día elementos y el siguiente es el resultado de la prueba:

0
1
2
3
4

en conclusión

Este artículo sobre el lenguaje de programación Rust cubre hasta cierto punto los tipos de datos compuestos. Aprendió a declarar y acceder a valores almacenados en tipos Array y Tuple. Además, observó el «tipo» de Slice y cómo se desestructuran las tuplas.

En el próximo capítulo, aprenderá a usar funciones en los programas de Rust. Manténganse al tanto.

LEER  Uso del comando de pantalla en Linux: una pastilla al día

Publicaciones relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Botón volver arriba