Punteros en Zig: acceso directo a la memoria

Los punteros son una parte fundamental de los lenguajes de programación de sistemas como Zig. A diferencia de lenguajes de alto nivel que ocultan la gestión de memoria, Zig nos permite trabajar directamente con direcciones de memoria, lo que proporciona un control preciso sobre nuestros datos. Este artículo explicará qué son los punteros en Zig, los distintos tipos que existen, cómo utilizarlos correctamente y las precauciones necesarias para evitar errores comunes.

Si tienes experiencia con punteros en lenguajes como C, notarás que Zig tiene un enfoque similar pero con mejoras significativas en cuanto a seguridad y expresividad. Zig ofrece diferentes tipos de punteros para distintos casos de uso, lo que ayuda a prevenir errores y hacer el código más claro.

¿Qué es un puntero?

Un puntero es una variable que almacena la dirección de memoria de otra variable. En lugar de contener directamente un valor como un entero o una cadena, un puntero "apunta" a la ubicación donde se encuentra almacenado ese valor. Esto permite:

Pasar grandes estructuras de datos por referencia en lugar de copiarlas
Modificar datos desde diferentes partes del programa
Crear estructuras de datos dinámicas como listas enlazadas y árboles
Gestionar eficientemente la memoria

Tipos de punteros en Zig

Zig distingue principalmente entre dos tipos de punteros:

Punteros a un solo elemento: *T
Punteros a múltiples elementos: [*]T

Además, existen otras variantes como:

Slices: []T
Punteros a arrays: *[N]T
Punteros opcionales: ?*T
Punteros a C: [*c]T

Vamos a explorar cada uno de estos tipos con ejemplos prácticos.

Punteros a un solo elemento (`*T`)

Este es el tipo de puntero más básico en Zig. Apunta exactamente a un único valor de tipo T.

const std = @import("std");
const expect = std.testing.expect;

test "punteros básicos" {
    // Declaramos una variable mutable
    var numero: i32 = 42;
    
    // Obtenemos un puntero a la variable usando &
    const puntero: *i32 = &numero;
    
    // Accedemos al valor usando .*
    try expect(puntero.* == 42);
    
    // Modificamos el valor a través del puntero
    puntero.* = 100;
    
    // La variable original refleja el cambio
    try expect(numero == 100);
}

En este ejemplo:

Creamos una variable numero con valor 42.
Creamos un puntero puntero que apunta a numero usando el operador &.
Accedemos al valor apuntado con puntero.*.
Modificamos el valor a través del puntero.
Verificamos que la variable original ha cambiado.

Punteros constantes vs punteros a valores constantes

Zig distingue entre:

*const T: un puntero (que no puede cambiar a dónde apunta) a un valor que no puede ser modificado
*T: un puntero a un valor que puede ser modificado

test "punteros constantes" {
    var valor_modificable: i32 = 123;
    const valor_constante: i32 = 456;
    
    // Puntero a valor modificable
    const ptr_a_modificable: *i32 = &valor_modificable;
    ptr_a_modificable.* += 1; // Permitido
    try expect(valor_modificable == 124);
    
    // Puntero a valor constante
    const ptr_a_constante: *const i32 = &valor_constante;
    // ptr_a_constante.* += 1; // ¡Error! No se puede modificar un valor constante
    _ = ptr_a_constante; // Permite ejecutar el ejemplo sin la linea anterior
    
    // Un puntero a constante también puede apuntar a un valor modificable
    const ptr_constante_a_modificable: *const i32 = &valor_modificable;
    // ptr_constante_a_modificable.* += 1; // ¡Error! El puntero es a un valor constante
    
    // Pero aún podemos modificar el valor original directamente
    valor_modificable += 1;
    try expect(valor_modificable == 125);
    try expect(ptr_constante_a_modificable.* == 125); // El puntero refleja el cambio
}

Punteros a múltiples elementos (`[*]T`)

Mientras que *T apunta a un solo elemento, [*]T es un puntero a múltiples elementos consecutivos del mismo tipo. Este tipo de puntero:

No conoce cuántos elementos hay (a diferencia de un slice)
Permite aritmética de punteros
No realiza comprobación de límites

test "punteros a múltiples elementos" {
    var numeros = [_]i32{ 10, 20, 30, 40, 50 };
    
    // Puntero a múltiples elementos
    const multi_ptr: [*]i32 = &numeros;
    
    // Acceso mediante indexación
    try expect(multi_ptr[0] == 10);
    try expect(multi_ptr[1] == 20);
    try expect(multi_ptr[4] == 50);
    
    // Aritmética de punteros
    const desplazado = multi_ptr + 2;
    try expect(desplazado[0] == 30); // Equivalente a multi_ptr[2]
    
    // Modificación mediante el puntero
    multi_ptr[3] = 45;
    try expect(numeros[3] == 45);
    
    // ¡Cuidado! No hay comprobación de límites en tiempo de ejecución
    // multi_ptr[5] = 60; // Podría acceder a memoria fuera del array
}

Slices (`[]T`)

Los slices son como punteros a múltiples elementos, pero también incluyen información sobre la longitud. Un slice es esencialmente un "puntero gordo" (fat pointer) que contiene:

Un puntero al primer elemento
La cantidad de elementos

Los slices proporcionan seguridad adicional al realizar comprobación de límites en tiempo de ejecución.

test "slices" {
    var buffer = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
    
    // Crear un slice de todo el buffer
    const slice_completo: []u8 = &buffer;
    try expect(slice_completo.len == 8);
    
    // Crear un slice de parte del buffer
    const slice_parcial = buffer[2..5];
    try expect(slice_parcial.len == 3);
    try expect(slice_parcial[0] == 3); // El primer elemento es buffer[2]
    
    // Modificar a través del slice
    slice_parcial[1] = 42;
    try expect(buffer[3] == 42); // Se modifica el buffer original
    
    // Comprobación de límites
    // slice_parcial[3] = 10; // Error en tiempo de ejecución: índice fuera de límites
    
    // Acceso al puntero interno del slice
    const puntero_interno: [*]u8 = slice_parcial.ptr;
    try expect(puntero_interno[0] == 3);
}

Punteros a arrays (`*[N]T`)

Un puntero a un array conoce exactamente cuántos elementos hay en el array. Es como un slice, pero con la longitud conocida en tiempo de compilación.

test "punteros a arrays" {
    var numeros = [5]i32{ 1, 2, 3, 4, 5 };
    
    // Puntero a un array completo
    const array_ptr: *[5]i32 = &numeros;
    
    // Conoce su longitud en tiempo de compilación
    comptime {
        std.debug.assert(array_ptr.len == 5);
    }
    
    // Acceso y modificación
    try expect(array_ptr[2] == 3);
    array_ptr[2] = 30;
    try expect(numeros[2] == 30);
    
    // Se puede convertir a slice
    const slice: []i32 = array_ptr;
    try expect(slice.len == 5);
}

Punteros opcionales (`?*T`)

Los punteros opcionales pueden ser null. Son útiles cuando un puntero podría no apuntar a nada válido.

test "punteros opcionales" {
    var numero: i32 = 123;
    
    // Puntero opcional que apunta a algo
    var ptr_opcional: ?*i32 = &numero;
    
    // Comprobar si es null
    try expect(ptr_opcional != null);
    
    // Desempaquetar el puntero
    if (ptr_opcional) |ptr| {
        try expect(ptr.* == 123);
        ptr.* = 456;
    }
    
    try expect(numero == 456);
    
    // Asignar null
    ptr_opcional = null;
    try expect(ptr_opcional == null);
    
    // Otra forma de desempaquetar (más peligrosa)
    ptr_opcional = &numero;
    const valor = ptr_opcional.?.*; // .? desempaqueta, puede fallar si es null
    try expect(valor == 456);
}

Punteros a C (`[*c]T`)

Estos punteros especiales se utilizan principalmente para la interoperabilidad con código C. Tienen características mixtas de los punteros simples y los punteros a múltiples elementos.

test "punteros de C" {
    var numeros = [_]i32{ 10, 20, 30 };
    
    // Puntero de C
    const c_ptr: [*c]i32 = &numeros;
    
    // Acceso similar a los punteros a múltiples elementos
    try expect(c_ptr[0] == 10);
    try expect(c_ptr[2] == 30);
    
    // Permite aritmética de punteros
    const c_ptr_desplazado = c_ptr + 1;
    try expect(c_ptr_desplazado[0] == 20);
    
    // A diferencia de los punteros normales de Zig, los punteros de C
    // pueden ser null sin necesidad de hacerlos opcionales
    // var c_ptr_null: [*c]i32 = null; // Esto es válido en Zig
}

Uso seguro de punteros

Los punteros son potentes pero pueden causar errores graves si se usan incorrectamente. Aquí hay algunas recomendaciones:

Usa slices cuando sea posible: Los slices realizan comprobación de límites y son más seguros.
Evita la aritmética de punteros innecesaria: La aritmética de punteros es propensa a errores.
Prefiere punteros opcionales para valores que podrían ser null.
Ten cuidado con los punteros colgantes: Un puntero que apunta a memoria que ya ha sido liberada.

test "puntero colgante - ejemplo a evitar" {
    // Este ejemplo muestra un error común a evitar
    var ptr: *i32 = undefined;
    
    {
        var numero: i32 = 123;
        ptr = &numero; // ptr ahora apunta a numero
        // numero sale de ámbito aquí
    }
    
    // ¡PELIGRO! ptr ahora es un puntero colgante
    // Acceder a ptr.* aquí causaría un comportamiento indefinido
}

Usar alineación cuando sea necesario: Zig permite especificar requisitos de alineación para punteros.

test "alineación de punteros" {
    var valor: i32 align(8) = 1234; // Valor alineado a 8 bytes
    
    // Puntero que refleja la alineación
    const ptr_alineado: *align(8) i32 = &valor;
    
    // Conversión explícita de alineación
    const ptr_normal: *i32 = @alignCast(ptr_alineado);
    
    try expect(ptr_normal.* == 1234);
}

Uso de punteros con estructuras y uniones

Los punteros son particularmente útiles cuando se trabaja con estructuras y uniones:

const Punto = struct {
    x: i32,
    y: i32,
    
    pub fn distancia(self: *const Punto) f32 {
        return @sqrt(@as(f32, @floatFromInt(self.x * self.x + self.y * self.y)));
    }
    
    pub fn mover(self: *Punto, dx: i32, dy: i32) void {
        self.x += dx;
        self.y += dy;
    }
};

test "punteros a estructuras" {
    var punto = Punto{ .x = 3, .y = 4 };
    
    // Método que recibe un puntero constante (no modifica la estructura)
    try expect(punto.distancia() == 5.0);
    
    // Método que recibe un puntero (modifica la estructura)
    punto.mover(2, -1);
    
    try expect(punto.x == 5);
    try expect(punto.y == 3);
    
    // Acceso a campos a través de un puntero
    const ptr = &punto;
    try expect(ptr.x == 5); // Forma abreviada de ptr.*.x
}

Observa cómo para acceder a los campos de una estructura a través de un puntero, Zig permite usar ptr.campo en lugar de ptr.*.campo, lo que hace que el código sea más legible.

Conclusión

Los punteros en Zig son una herramienta poderosa que ofrece control directo sobre la memoria. A diferencia de algunos lenguajes de alto nivel, Zig te permite elegir el tipo exacto de puntero que necesitas para cada situación:

Punteros a un solo elemento (*T) para referencias simples.
Punteros a múltiples elementos ([*]T) cuando necesitas aritmética de punteros.
Slices ([]T) para trabajar de forma segura con rangos de elementos.
Punteros a arrays (*[N]T) cuando la longitud es conocida en tiempo de compilación.
Punteros opcionales (?*T) para casos donde el puntero podría ser null.
Punteros a C ([*c]T) para interoperabilidad con código C.

Esta variedad de tipos de punteros permite escribir código seguro y expresivo, adaptado a las necesidades específicas de cada situación. Si bien los punteros pueden ser complejos, comprenderlos bien te permitirá aprovechar al máximo las capacidades de Zig como lenguaje de programación de sistemas.

Recuerda que aunque los punteros te dan control, también conllevan responsabilidad. Usa siempre el tipo de puntero más seguro para cada situación y aprovecha las características de seguridad que Zig proporciona para evitar errores comunes.

Punteros en Zig: acceso directo a la memoria

¿Qué es un puntero?

Tipos de punteros en Zig

Punteros a un solo elemento (*T)

Punteros constantes vs punteros a valores constantes

Punteros a múltiples elementos ([*]T)

Slices ([]T)

Punteros a arrays (*[N]T)

Punteros opcionales (?*T)

Punteros a C ([*c]T)