6 Tuplas y Arrays
En la Sección 5.2 ya hemos visto los tipos básicos de datos: reales, enteros, caracteres, booleanos y unitario. Sin embargo, con frecuencia necesitaremos agrupar varios valores para representar una entidad o manejar colecciones de datos. Para ello, Rust define dos tipos de datos compuestos: las tuplas y los arrays.
6.1 Tuplas
Una tupla es una colección ordenada de valores. Sus elementos pueden tener tipos distintos y su longitud no puede cambiar una vez definida. Se escriben entre paréntesis, separados por comas.
fn main() {
let persona = ("Ana", 25, true);
println!("Contenido de la tupla:");
println!("\t{:?}", persona);
println!("Elementos de la tupla:");
println!("\tNombre: {}", persona.0);
println!("\tEdad: {}", persona.1);
println!("\tActivo: {}", persona.2);
}La variable
personacontiene una tupla con tres elementos: una cadena ("Ana"), un entero (25) y un booleano (true).La sentencia
println!("\t{:?}", persona);muestra el contenido completo de la tupla. El especificador
:?indica que el valor debe imprimirse usando su representación de depuración (debug).Los elementos de una tupla se acceden mediante un punto seguido de su posición. El primer elemento es
persona.0, el segundopersona.1y el terceropersona.2.La posición ha de ser un literal numérico (un número tal cual). No puede ser una variable ni una expresión. El índice identifica un campo concreto y debe conocerse en compilación
Las últimas sentencias muestran cada elemento por separado:
println!("\tNombre: {}", persona.0); println!("\tEdad: {}", persona.1); println!("\tActivo: {}", persona.2);El especificador
{}indica dónde debe insertarse el valor que aparece como segundo argumento deprintln!.La secuencia
\trepresenta un carácter de tabulación y se utiliza aquí para mejorar la presentación de la salida.
6.2 La tupla vacía
La tupla vacía se escribe () y no contiene ningún elemento. Como vimos en la Sección 5.2.2 también se le llama valor unitario y es de tipo unitario.
fn main() {
let tupla_vacia = ();
println!("{:?}", tupla_vacia);
}Aunque pueda parecer poco útil, la tupla vacía tiene un papel importante en Rust. Por ejemplo, es el valor que devuelven muchas funciones cuya finalidad es realizar una acción y no producir un resultado.
6.3 Arrays
Al igual que una tupla, un array es una colección ordenada de valores cuya longitud no puede cambiar una vez definido. Pero a diferencia de las tuplas, sus elementos han de ser todos del mismo tipo.
Los elementos de un array se escriben entre corchetes, separados por comas. También se usan los corchetes para acceder a los elementos por su índice. Al igual que en C y muchos otros lenguajes, el primer elemento es el 0, el segundo es el 1, etc. El índice puede ser un literal numérico, una variable o una expresión.
fn main() {
let numeros = [10, 20, 30, 40, 50];
println!("Contenido del array:");
println!("\t{:?}", numeros);
println!("Elementos del array:");
println!("\tPrimero: {}", numeros[0]);
println!("\tSegundo: {}", numeros[1]);
println!("\tTercero: {}", numeros[2]);
}
La variable numeros contiene un array con cinco elementos. Todos ellos son enteros. Si alguno no lo fuera, el compilador mostraría un error. Como en el siguiente ejemplo:
fn main() {
let datos = [10, 20, "azul"]; // ¡ERROR! Los tipos han de ser iguales.
println!("Contenido del array:");
println!("\t{:?}", datos);
}También es posible definir un array indicando su tamaño y el valor que tendrán todos sus elementos. Para ello se escribe el valor inicial, seguido de un punto y coma y del número de elementos:
let ceros = [0; 5];Esto significa que se debe repetir el valor 0 cinco veces. El array ceros contiene cinco elementos, todos ellos iguales a 0. El tipo de los elementos es i32, que es el tipo que Rust deduce para el literal 0. Esta forma de definir arrays resulta especialmente útil cuando todos sus elementos han de comenzar con el mismo valor. Por ejemplo:
fn main() {
let ceros = [0; 5];
println!("Contenido del array:");
println!("\t{:?}", ceros);
}También se puede indicar explícitamente el tipo de los elementos:
let valores: [f64; 5] = [0.0; 5];Aquí valores es un array de cinco elementos de tipo f64, todos ellos inicializados a 0.0.
Para hacer estos ejemplos más sencillos, hemos escrito el tamaño del array como un literal, esto es, como un 5 tal cual. En un programa real, cuando ese valor tiene un significado concreto, nunca deberímos escribirlo así, lo adecuado es una constante:
const TABLE_SIZE: usize = 5;
let valores: [f64; TABLE_SIZE] = [0.0; TABLE_SIZE];Esto tiene dos ventajas principales:
Documenta el significado del valor.
TABLE_SIZEresulta más informativo que un5cuyo significado tenemos que deducir.Permite modificarlo en un único lugar.
Si cambia el tamaño de la tabla, basta con modificar la definición de la constante. De lo contrario, habría que localizar y cambiar el valor en todas las líneas de todos los ficheros del programa donde se utilice.
6.3.1 Inicializar un array con std::array::from_fn
La forma [valor; tamaño] requiere que el valor pueda copiarse para inicializar los elementos. Esto es, que el tipo implemente el trait Copy. Hasta ahora hemos visto tipos sencillos, como i32, f64 o bool, que cumplen este requisito. En la Sección 9.5 hablaremos de los tipos que no lo cumplen.
Si queremos inicializar un array con valores sin trait Copy, podemos usar std::array::from_fn:
use std::array::from_fn;
const TABLE_SIZE: usize = 5;
fn main() {
let mut tabla: [Option<String>; TABLE_SIZE] = from_fn(|_| None);
println!("{:?}", tabla);
tabla[0] = Some(String::from("Hola"));
println!("{:?}", tabla);
}from_fn recibe una función que se ejecuta una vez por cada posición del array. En este caso, todas las posiciones se inicializan con None. La expresión |_| None es una clausura, que trataremos en la Sección 16.5.1.
En cualquier caso, el tamaño siempre forma parte del tipo del array. Por tanto, [i32; 5] y [i32; 10] son tipos distintos, aunque sus elementos sean del mismo tipo.
6.4 Todos los elementos de un array deben estar inicializados
En los ejemplos anteriores, siempre hemos inicializado el array dando valor a todas sus posiciones.
O bien dando valor explícitamente a cada elemento
let numeros = [10, 20, 30, 40, 50];O bien inicializando todos los elementos con el mismo valor
let ceros = [0; 5];O bien usando
std::array::from_fnlet mut tabla: [Option<String>; TABLE_SIZE] = from_fn(|_| None);
Esto no es casual. Una característica importante de los arrays de Rust es que todos sus elementos deben tener un valor desde el momento en que se crea el array. No es posible declarar un array y dejar algunos de sus elementos sin inicializar para asignarles un valor más adelante.
Esto supone una diferencia con lenguajes como C, donde es posible declarar un array y asignar posteriormente valores solamente a algunos de sus elementos:
int numeros[5];
numeros[0] = 10;En este caso, numeros[1], numeros[2], etc. quedan sin un valor definido. En Rust esto no estaría permitido. Esta restricción es una de las medidas de Rust para mejorar la seguridad de los programas: permitir que una variable contenga datos sin inicializar puede dar lugar a que el programa utilice accidentalmente un valor indefinido.
6.5 Option<T> para representar valores no disponibles
En la sección anterior hemos visto tres formas de dar valor a todos los elementos de un array. Veremos aquí una cuarta muy idiomática en Rust: utilizar un Option<T>. Supondremos ahora que ya has estudiado el capítulo Capítulo 12. Si no es el caso, ignora esta sección por el momento.
Como sabes, un Option<T> puede contener un valor de tipo T, mediante Some(valor), o indicar que no hay ningún valor, mediante None. Por tanto, podemos crear un array de Option<T> inicializando todas sus posiciones con None:
let mut numeros: [Option<i32>; 5] = [None; 5];El array está completamente inicializado: cada una de sus posiciones contiene un Option<i32>. Sin embargo, inicialmente todas ellas contienen None, que representa la ausencia de un valor. Posteriormente podemos asignar un valor a una posición concreta:
numeros[0] = Some(10);
numeros[1] = Some(20);Ahora las dos primeras posiciones contienen un valor y las restantes continúan sin tenerlo:
[Some(10), Some(20), None, None, None]
Es importante entender que las posiciones restantes no están sin inicializar. Todas contienen un valor perfectamente válido: None. Lo que ocurre es que ese valor indica que todavía no hay un valor de tipo i32 asociado a ellas.
Esta técnica resulta especialmente útil cuando el array se va a ir rellenando durante la ejecución del programa. Por ejemplo:
let mut tabla: [Option<i32>; 5] = [None; 5];
tabla[0] = Some(100);
tabla[3] = Some(400);El contenido del array será:
[Some(100), None, None, Some(400), None]
De esta forma podemos distinguir entre una posición que todavía no ha recibido un valor y una posición que contiene realmente un valor.
6.6 Comparación entre tuplas y arrays
La Tabla 6.1 resume las similitudes y diferencias entre tuplas y arrays.
| Característica | Tupla | Array |
|---|---|---|
| Longitud fija | Sí | Sí |
| Elementos del mismo tipo | No necesariamente | Sí |
| Delimitadores | Paréntesis () |
Corchetes [] |
| Acceso a elementos | Punto (.0, .1, …) |
Índice ([0], [1], …) |
| Acceso mediante vble o expr. | No | Sí |
| Ejemplo | ("TCP", 443, true) |
[10, 20, 30, 40, 50] |
6.7 Resumen
En este capítulo hemos presentado los dos tipos de datos compuestos básicos que proporciona Rust: las tuplas y los arrays.
Las ideas principales son las siguientes:
- Una tupla agrupa un número fijo de valores que pueden ser de tipos diferentes.
- Los elementos de una tupla se acceden mediante su posición, utilizando la notación
.0,.1,.2, etc. - La tupla vacía
()representa el valor unitario y suele utilizarse como valor de retorno de funciones que realizan una acción pero no producen un resultado. - Un array almacena un número fijo de elementos del mismo tipo.
- Los elementos de un array se acceden mediante un índice entre corchetes, comenzando por el índice
0. - Tanto las tuplas como los arrays tienen un tamaño fijo, pero las tuplas permiten mezclar tipos mientras que los arrays no.
- En los arrays se pueden usar variables o expresiones para los índices. En las tuplas, no. Solo constantes numéricas literales.
std::array::from_fnpermite inicializar un array generando cada uno de sus elementos mediante una función o clausura, y resulta especialmente útil cuando el tipo de los elementos no implementaCopy.
En los próximos capítulos estudiaremos nuevos tipos de datos que permiten representar estructuras más complejas y colecciones de tamaño variable.