Guía de Vectores en Rust

En Rust, un lenguaje de programación de sistemas que se destaca por su seguridad y rendimiento, puedes almacenar una lista de valores utilizando el tipo de dato Vec. Este tipo de dato representa un vector dinámico, que es esencialmente una lista que puede crecer o contraerse según sea necesario. Para utilizar un Vec en Rust, primero debes importar el módulo std::vec::Vec. Luego, puedes crear un nuevo vector utilizando la macro vec![] o llamando al constructor Vec::new().

Por ejemplo, supongamos que deseamos almacenar una lista de números enteros en un vector. Podemos hacerlo de la siguiente manera:

rustCopy code
// Importar el módulo std::vec::Vec
use std::vec::Vec;

// Crear un nuevo vector de números enteros
let mut numeros: Vec<i32> = Vec::new();

// Agregar valores al vector
numeros.push(10);
numeros.push(20);
numeros.push(30);

// Imprimir el vector
println!("{:?}", numeros);

En este código, hemos creado un nuevo vector llamado numeros que puede contener números enteros (i32). Luego, agregamos algunos valores al vector utilizando el método push(). Finalmente, imprimimos el vector utilizando la macro de depuración {:?} para visualizar su contenido.

Otra forma común de inicializar un Vec con valores predefinidos es utilizando la macro vec![]. Por ejemplo:

rustCopy code
// Crear un nuevo vector con valores predefinidos
let frutas = vec!["manzana", "banana", "naranja"];

// Imprimir el vector de frutas
println!("{:?}", frutas);

En este caso, hemos creado un vector llamado frutas que contiene las cadenas «manzana», «banana» y «naranja».

Es importante destacar que los vectores en Rust son homogéneos, lo que significa que todos los elementos dentro de un vector deben ser del mismo tipo. Sin embargo, Rust proporciona la capacidad de almacenar valores de diferentes tipos mediante el uso de un tipo de dato enum o utilizando el tipo de dato Any del módulo std::any, aunque esto último suele requerir un manejo más complejo.

Además de agregar elementos al final del vector con el método push(), también puedes acceder y modificar elementos específicos utilizando la indexación de vectores. Por ejemplo:

rustCopy code
// Acceder y modificar elementos específicos del vector
let mut colores = vec!["rojo", "verde", "azul"];
println!("El primer color es: {}", colores[0]); // Acceder al primer elemento
colores[1] = "amarillo"; // Modificar el segundo elemento
println!("El segundo color es: {}", colores[1]); // Acceder al segundo elemento modificado

Es importante tener en cuenta que si intentas acceder a un índice que está fuera del rango del vector, Rust generará un error en tiempo de ejecución. Para evitar esto, puedes utilizar métodos como get() que devuelven una opción (Option) en lugar de un valor directo, lo que te permite manejar de manera segura los casos en los que el índice está fuera del rango.

En resumen, en Rust puedes almacenar una lista de valores utilizando el tipo de dato Vec, que proporciona un vector dinámico que puede crecer o contraerse según sea necesario. Puedes agregar elementos al vector, acceder y modificar elementos específicos, y trabajar con diferentes tipos de datos dentro del mismo vector. Esto hace que los vectores sean una estructura de datos versátil y útil en Rust para almacenar y manipular colecciones de elementos.

Por supuesto, profundicemos más en el uso de vectores en Rust y exploremos algunas de sus características adicionales.

1. Iteración sobre un Vector:
   Una forma común de trabajar con los elementos de un vector en Rust es mediante la iteración. Puedes utilizar un bucle for o métodos como iter() y iter_mut() para iterar sobre los elementos del vector. Por ejemplo:

   rustCopy code
   let numeros = vec![1, 2, 3, 4, 5];
   
   // Iteración inmutable sobre los elementos del vector
   for num in numeros.iter() {
       println!("{}", num);
   }
   
   // Iteración mutable sobre los elementos del vector
   for num in numeros.iter_mut() {
       *num *= 2; // Multiplicar cada elemento por 2
   }
   
   println!("{:?}", numeros); // Imprimir el vector modificado
   

   En este ejemplo, utilizamos iter() para iterar de forma inmutable sobre los elementos del vector y iter_mut() para hacerlo de forma mutable. Al iterar de forma mutable, podemos modificar los elementos del vector dentro del bucle.

2. Eliminación de Elementos:
   Rust proporciona varios métodos para eliminar elementos de un vector, como pop() para eliminar el último elemento, remove() para eliminar un elemento en una posición específica y clear() para vaciar completamente el vector. Por ejemplo:

   rustCopy code
   let mut frutas = vec!["manzana", "banana", "naranja"];
   
   // Eliminar el último elemento
   let ultima_fruta = frutas.pop();
   println!("Última fruta eliminada: {:?}", ultima_fruta);
   
   // Eliminar el segundo elemento
   let segunda_fruta = frutas.remove(1);
   println!("Segunda fruta eliminada: {}", segunda_fruta);
   
   // Vaciar el vector
   frutas.clear();
   println!("Vector de frutas vacío: {:?}", frutas);
   

   Aquí, usamos pop() para eliminar la última fruta, remove() para eliminar la segunda fruta y clear() para vaciar completamente el vector de frutas.

3. Obtener la Longitud y Capacidad:
   Puedes obtener la longitud de un vector utilizando el método len() y su capacidad utilizando el método capacity(). La longitud representa la cantidad de elementos actualmente almacenados en el vector, mientras que la capacidad indica cuántos elementos puede contener el vector antes de que sea necesario asignar más memoria. Por ejemplo:

   rustCopy code
   let mut numeros = Vec::with_capacity(10); // Crear un vector con una capacidad inicial de 10
   
   // Agregar algunos elementos al vector
   for i in 0..8 {
       numeros.push(i);
   }
   
   println!("Longitud del vector: {}", numeros.len()); // Imprimir la longitud
   println!("Capacidad del vector: {}", numeros.capacity()); // Imprimir la capacidad
   

   En este caso, hemos creado un vector con una capacidad inicial de 10 elementos, pero solo hemos agregado 8. La capacidad del vector puede ser mayor que su longitud, lo que significa que aún tiene espacio para crecer sin asignar más memoria.

4. Slicing (Rebanado) de Vectores:
   Rust permite crear rebanadas de vectores utilizando la sintaxis de rebanado ([start..end]). Esto te permite trabajar con una porción específica del vector sin copiar los elementos. Por ejemplo:

   rustCopy code
   let numeros = vec![1, 2, 3, 4, 5];
   
   // Crear una rebanada con los elementos desde el segundo hasta el cuarto (índices 1 a 3)
   let sub_numeros = &numeros[1..4];
   println!("Sub-vector: {:?}", sub_numeros);
   

   Aquí, hemos creado una rebanada que contiene los elementos desde el segundo hasta el cuarto del vector numeros.

En conclusión, los vectores en Rust son una estructura de datos poderosa y flexible que te permite almacenar y manipular colecciones de elementos de forma dinámica y eficiente. Con métodos para agregar, eliminar, acceder y modificar elementos, así como para iterar sobre ellos y crear rebanadas, los vectores son una parte fundamental del kit de herramientas de Rust para trabajar con datos.