Punteros en Rust, ¿Qué son y para qué sirven?

En Rust existe el concepto de punteros, pero se maneja de manera distinta a lenguajes como C o Go, porque Rust pone mucho énfasis en la seguridad de memoria y en evitar errores comunes como dangling pointers o data races.

Recordando el post anterior tenemos que una variable se compone de: 

1.  Un tipo de dato. 
2.  Un nombre. 
3.  Un valor. 
4.  Una dirección de memoria.

Las dos primeras características las define el programador, el valor depende del flujo del programa. La memoria la designa el sistema.

Y es aquí donde entran los punteros, que son variables que almacenan la dirección de memoria de otra variable. En Rust, el concepto puede ser un poco diferente a lenguajes como C y Go como lo vamos a ver.

Tipos de punteros en Rust

En Rust, veremos los punteros como en referencias, Box, Rc/Arc, raw pointers y su uso está regulado por el sistema de propiedad para garantizar seguridad y eficiencia.

¿Para qué sirven en Rust?

• Referencias: para pasar valores sin copiarlos y controlar mutabilidad. 
• Box: para manejar datos en el heap y estructuras recursivas. 
• Rc/Arc: para compartir datos entre múltiples dueños. 
• Raw pointers: interoperabilidad con C o casos muy específicos de bajo nivel.

1. Referencias (& y &mut).

• Son el equivalente más cercano a los punteros en Go. 
• &T : referencia inmutable a un valor. 
•  &mut T : referencia mutable, permite modificar el valor.

referencia.rs

fn incrementar(x: &mut i32) {
    *x += 1;
}

fn main() {
    let mut valor = 10;
    incrementar(&mut valor);
    println!("Valor: {}", valor); // 11
}

2. Box (Box <T>)

• Es un puntero inteligente que guarda datos en el heap en lugar del stack. 
• Útil para estructuras grandes o recursivas.

caja.rs

fn main() {
    let b = Box::new(42);
    println!("Valor en Box: {}", b);
}

3. Rc y Arc.

Rc<T> : Reference Counted, permite compartir datos entre varias partes del programa en un solo hilo. Arc<T> : Atomic Reference Counted, igual que Rc pero seguro para múltiples hilos.

rc.rs

use std::rc::Rc;

fn main() {
    let x = Rc::new(5);
    let y = Rc::clone(&x);
    println!("x = {}, y = {}", x, y);
}

4. Raw pointers (*const T y *mut T)

• Son punteros "crudos" como en C, pero en Rust se consideran inseguros. 
• Solo se usan dentro de bloques unsafe { ... }.

pointers.rs

fn main() {
    let x = 10;
    let p: *const i32 = &x;
    unsafe {
        println!("Valor apuntado: {}", *p);
    }
}

En Go, los punteros son simples y seguros, pero no hay control estricto sobre aliasing o mutabilidad.

En Rust, el sistema de ownership y borrowing asegura que:

• No haya dos referencias mutables al mismo tiempo. 
• No se acceda a memoria liberada. 
•  Se eviten data races en concurrencia, cuando dos o más hilos acceden simultáneamente a la misma ubicación de memoria, al menos uno de ellos realiza una escritura y los accesos no están sincronizados.

Comparando los punteros en Go y Rust tenemos esta tabla:

Aspecto	Punteros en Go	Punteros en Rust
Sintaxis básica	& obtiene dirección, * accede al valor. Ejemplo: p := &x, *p	& referencia inmutable, &mut mutable. Ejemplo: let r = &x;, *r
Mutabilidad	Se controla con el tipo de variable, pero no hay restricción estricta sobre aliasing.	El sistema de ownership y borrowing impide múltiples referencias mutables simultáneas.
Seguridad	Seguros, pero sin control estricto de concurrencia.	Altamente seguros: evita dangling pointers y data races en tiempo de compilación.
Punteros crudos	No existen punteros crudos como en C.	Existen (*const T, *mut T), pero solo en bloques unsafe.
Punteros inteligentes	No hay punteros inteligentes nativos, se usan referencias simples.	Box, Rc, Arc permiten gestión avanzada de memoria y compartición.
Uso típico	Modificar valores en funciones, evitar copias grandes.	Controlar mutabilidad, trabajar con heap (Box), compartir datos (Rc/Arc).
Filosofía	Simplicidad y eficiencia sin demasiadas restricciones.	Seguridad estricta y control de memoria en tiempo de compilación.

En Go, los punteros son simples y seguros, útiles para modificar valores y evitar copias.

En Rust, los punteros existen bajo varias formas (referencias, Box, Rc, Arc, raw pointers), pero están regulados por el sistema de propiedad para garantizar seguridad y evitar errores de memoria.

Continuaremos con este tema en próximas entregas.

Enlaces:

https://alquimistadecodigo.blogspot.com/2026/04/punteros-en-go-por-que-tendria-que.html
https://book.rustlang-es.org/ch04-01-what-is-ownership
https://book.rustlang-es.org/ch04-02-references-and-borrowing