Tema 8 — Colecciones e iteradores
8.1 Vec<T>: el array dinámico
Equivalente a std::vector de C++ o a una lista dinámica de C hecha a mano con malloc/realloc, pero gestionado por el sistema de ownership: no hay que liberar memoria manualmente ni preocuparse por reallocations colgantes.
fn main() {
let mut numeros: Vec<i32> = Vec::new();
numeros.push(1);
numeros.push(2);
numeros.push(3);
let numeros2 = vec![1, 2, 3]; // macro de conveniencia, equivalente
println!("{:?}", numeros);
println!("Primero: {:?}", numeros.first()); // Option<&i32>, no "unsafe" como en C
println!("Elemento 1: {}", numeros[1]); // panic controlado si está fuera de rango
for n in &numeros { // iterar por referencia: no consume el vector
println!("{n}");
}
}
Acceder con numeros[10] fuera de rango hace panic! (controlado, con mensaje). Si se prefiere gestionar el caso explícitamente sin arriesgar un panic, se usa .get(10), que devuelve Option<&i32>.
8.2 HashMap<K, V>
Equivalente a un diccionario de Python o un std::unordered_map de C++. En C no existe en el lenguaje: hay que implementarlo o traer una librería externa.
use std::collections::HashMap;
fn main() {
let mut edades: HashMap<String, u8> = HashMap::new();
edades.insert(String::from("Ana"), 30);
edades.insert(String::from("Luis"), 25);
match edades.get("Ana") {
Some(edad) => println!("Ana tiene {edad} años"),
None => println!("No encontrada"),
}
// entry API: patrón muy idiomático para "insertar si no existe, o modificar"
let contador = edades.entry(String::from("Ana")).or_insert(0);
*contador += 1;
for (nombre, edad) in &edades {
println!("{nombre}: {edad}");
}
}
8.3 Otras colecciones de la librería estándar
| Tipo | Uso |
|---|---|
VecDeque<T> |
Cola doblemente terminada, eficiente en ambos extremos |
HashSet<T> |
Conjunto sin orden, basado en hashing |
BTreeMap<K, V> / BTreeSet<T> |
Como HashMap/HashSet pero ordenados por clave |
[T; N] |
Array de tamaño fijo conocido en compilación |
&[T] (slice) |
Vista prestada sobre una secuencia contigua, sin ownership |
Slices: una de las ideas más potentes de Rust
Un slice (&[T] o &str para texto) es una referencia a una parte contigua de una colección, sin copiar los datos y sin tomar ownership — pero con los límites verificados en tiempo de ejecución (a diferencia de pasar un puntero + longitud en C, donde nada impide pasar una longitud incorrecta).
fn main() {
let numeros = vec![10, 20, 30, 40, 50];
let parte: &[i32] = &numeros[1..3]; // [20, 30], sin copiar
println!("{parte:?}");
fn suma(slice: &[i32]) -> i32 {
slice.iter().sum()
}
println!("{}", suma(&numeros)); // un Vec se puede pasar como &[T] directamente
println!("{}", suma(parte));
}
Esto permite escribir funciones que aceptan tanto arrays como vectores (o partes de ellos) sin genéricos, sin copiar y sin riesgo de desbordar límites.
8.4 Iteradores: la forma idiomática de procesar datos
En C, procesar una colección significa escribir bucles for manuales con índices. En Rust, el trait Iterator permite encadenar transformaciones de forma declarativa, y gracias a las zero-cost abstractions (Tema 1.4) el código compilado es tan eficiente como el bucle manual equivalente.
fn main() {
let numeros = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let pares_al_cuadrado: Vec<i32> = numeros
.iter()
.filter(|&&n| n % 2 == 0) // quedarse solo con los pares
.map(|&n| n * n) // elevar al cuadrado
.collect(); // materializar en un nuevo Vec
println!("{pares_al_cuadrado:?}"); // [4, 16, 36, 64, 100]
let suma: i32 = numeros.iter().sum();
let maximo = numeros.iter().max();
let hay_mayor_de_5 = numeros.iter().any(|&n| n > 5);
let todos_positivos = numeros.iter().all(|&n| n > 0);
println!("suma={suma}, max={maximo:?}, hay_mayor_de_5={hay_mayor_de_5}, todos_positivos={todos_positivos}");
// enumerate: índice + valor, sin gestionar un contador manualmente
for (i, n) in numeros.iter().enumerate() {
if i < 3 {
println!("índice {i}: {n}");
}
}
}
Iteradores son “lazy” (perezosos)
let it = numeros.iter().map(|n| {
println!("procesando {n}");
n * 2
});
// nada se ha ejecutado todavía: los adaptadores solo describen la cadena de transformación
let resultado: Vec<i32> = it.collect(); // aquí sí se ejecuta todo, de una sola pasada
Esto permite encadenar muchas operaciones sin crear colecciones intermedias en memoria: filter().map().take(5) sobre un iterador de un millón de elementos solo procesa lo necesario, no los 1.000.000 completos si take(5) ya se satisface antes.
for vs iteradores: ¿cuál usar?
Ambos compilan a código equivalente. La convención en la comunidad es:
forcuando hay efectos secundarios simples (imprimir, mutar estado externo) y la lógica es lineal.- Cadenas de iteradores (
.filter().map().collect()) cuando se transforma una colección en otra — es más declarativo y suele ser más fácil de leer una vez acostumbrado.
8.5 Comparación con C
| C | Rust | |
|---|---|---|
| Array dinámico | malloc/realloc manual, tamaño gestionado a mano |
Vec<T>, gestión automática y segura |
| Diccionario | No existe, hay que implementarlo o usar librería externa | HashMap<K, V> en la librería estándar |
| Acceso fuera de rango | Comportamiento indefinido (UB) | panic! controlado, o Option con .get() |
| Procesar una colección | Bucle for manual con índices |
Iteradores encadenables, “zero-cost” |
| Pasar “un trozo” de un array | Puntero + longitud por separado (fácil de desincronizar) | Slice &[T], longitud va integrada y verificada |
8.6 Ejercicio
- Dado
let palabras = vec!["manzana", "pera", "kiwi", "uva", "sandía"];, usa iteradores para obtener unVec<&str>solo con las palabras de más de 4 letras, en mayúsculas (usa.to_uppercase(), ojo: devuelveString, no&str). - Usa un
HashMap<char, u32>para contar cuántas veces aparece cada letra en la cadena"abracadabra", usando.chars()y el patrónentry().or_insert(0). - (Extra) Calcula el mismo resultado del punto 2 pero exclusivamente con una cadena de iteradores (
fold), sin buclesforexplícitos.
Siguiente → Tema 9: Concurrencia