Aritmética de punteros y matrices dinámicas

Prerrequisitos: punteros, arreglos, sizeof y memoria dinámica básica.

Objetivos: 1. Calcular el desplazamiento válido de un puntero dentro de un arreglo. 2. Representar una matriz dinámica con su estrategia de liberación.

Comprobación de salida: justificá por qué sumar uno a int * no equivale a sumar un byte.

Aritmética de punteros y matrices dinámicas¶

Introducción¶

Este apunte explora conceptos avanzados de memoria dinámica en C, construyendo sobre las bases presentadas en Modelo de memoria y pila y Punteros. Aquí profundizamos en el manejo de Estructuras y Tipos Compuestos que contienen punteros, problemas comunes de gestión de memoria, y técnicas para trabajar con matrices dinámicas.

Problemas Comunes de Memoria Dinámica¶

Repaso opcional completo

Repaso opcional

La explicación normativa de fugas, free y realloc pertenece a 5_memoria_dinamica.md. Esta sección solo sirve como repaso breve; no agrega un prerrequisito nuevo a la aritmética de punteros.

Esta sección detalla errores frecuentes en la gestión de memoria dinámica y sus soluciones. Estos problemas se amplían en Errores Comunes y Peligros.

Fragmentación del Heap¶

La fragmentación externa ocurre cuando la memoria libre se divide en bloques pequeños y no contiguos, aunque la suma total de memoria libre sea suficiente para una solicitud.

Escenario Ilustrativo¶

Problema: Aunque hay 150 KB libres (100 + 50), no podés asignar un bloque contiguo de 120 KB.

Soluciones¶

Estrategia	Descripción	Cuándo Usar
Asignación en bloque	Pedir memoria en bloques grandes, subdividir internamente	Arrays redimensionables, pools de objetos
Memory pools	Pre-asignar conjunto de objetos del mismo tamaño	Asignaciones/liberaciones frecuentes del mismo tipo
Compactación	Reorganizar bloques para unir espacios libres	Raramente posible en C (requiere actualizar punteros)

Punteros Colgantes (Dangling Pointers)¶

Un puntero colgante (dangling pointer) es un puntero que apunta a memoria que ya ha sido liberada con free. Este es uno de los errores más peligrosos en C (ver Dangling Pointer (Puntero Colgante) para más detalles).

Causa¶

Cuando llamás free(puntero), la memoria se libera pero la variable puntero no cambia. Sigue conteniendo la dirección antigua, que ahora es inválida.

1
2
3
4
5
int *datos = malloc(sizeof(int) * 10);
// ... usar datos ...
free(datos);
// En este punto, 'datos' sigue apuntando a la dirección antigua
// pero esa memoria puede estar siendo usada por otra parte del programa

Riesgo: Comportamiento Indefinido¶

Usar un puntero colgante (leer o escribir) invoca undefined behavior. El programa puede:

• Aparentar funcionar correctamente (el peor caso, porque oculta el error)

• Crashear inmediatamente

• Corromper otros datos silenciosamente

• Comportarse de forma impredecible

1
2
free(datos);
datos[0] = 42; // UNDEFINED BEHAVIOR

Solución: Poner en NULL Después de free¶

1
2
free(puntero);
puntero = NULL; // Ahora es seguro verificar con if (puntero != NULL)

Liberar Memoria No Dinámica¶

Intentar liberar memoria que no fue asignada dinámicamente es un error grave que resulta en undefined behavior.

Regla Fundamental¶

Errores Comunes¶

1. Liberar variables del stack:

1
2
3
4
5
int main()
{
    char automatica[] = "hola mundo"; // En el stack
    free(automatica);                 // ERROR: undefined behavior
}

Como se explica en La Pila (Stack), las variables automáticas se gestionan automáticamente en el stack. No necesitan (ni deben) ser liberadas manualmente.

2. Liberar literales de cadena:

1
2
char *mensaje = "Hola"; // Literal en .rodata (read-only data)
free(mensaje);          // ERROR: undefined behavior

Los literales de cadena residen en el segmento .rodata (ver Segmentación de la Memoria) y son de solo lectura.

3. Liberar variables globales:

1
2
3
4
5
int global_arr[100]; // Segmento .bss o .data
void funcion()
{
    free(global_arr); // ERROR: undefined behavior
}

Ejercicios de Autoevaluación (Problemas de Memoria)¶

Indicá cuáles de estas llamadas a free son válidas:

int v[3];
int *a = malloc(3 * sizeof *a);
int *b = a + 1;
free(v);       /* A */
free(b);       /* B */
free(a);       /* C */

Solución

Ni A ni B son válidas: v tiene duración automática y b no es la dirección devuelta por el allocator. C es la única liberación correcta. Si se pierde a antes de liberar el bloque hay una fuga; por eso no se debe sobrescribir el puntero propietario con una dirección interior.

---

Funciones Adicionales de Gestión de Memoria¶

Más allá de malloc y free, C proporciona funciones adicionales para manipular memoria dinámica. Estas se detallan completamente en Memoria dinámica: propiedad y ciclo de vida.

calloc: Asignación con Inicialización¶

1
void *calloc(size_t cantidad, size_t tamaño);

Asigna memoria para un arreglo de cantidad elementos, cada uno de tamaño bytes. Crucialmente, inicializa toda la memoria a cero.

Comparación con malloc:

1
2
3
4
5
6
// Usando malloc
int *arr1 = malloc(10 * sizeof(int));
// arr1[i] contiene basura
// Usando calloc
int *arr2 = calloc(10, sizeof(int));
// arr2[i] == 0 para todo i

realloc: Redimensionar Bloques¶

1
void *realloc(void *bloque, size_t nuevo_tamaño);

Cambia el tamaño de un bloque de memoria existente. Esta función es fundamental para implementar arrays redimensionables.

Comportamiento de realloc¶

Uso Correcto de realloc¶

Patrón correcto:

1
2
3
4
5
6
7
8
int *temp = realloc(arr, nuevo_tamaño * sizeof(int));
if (temp == NULL)
{
    // realloc falló, arr sigue válido
    // Manejar error (liberar arr si es necesario)
    return ERROR;
}
arr = temp; // Éxito: actualizar puntero

¿Por Qué realloc Puede Mover el Bloque?¶

Si no hay espacio contiguo para expandir el bloque en su ubicación actual, realloc:

1. Asigna un nuevo bloque más grande en otra ubicación

2. Copia los datos del bloque original al nuevo

3. Libera el bloque original

4. Retorna la dirección del nuevo bloque

memset: Relleno de Memoria¶

1
void *memset(void *destino, int valor, size_t count);

Rellena los primeros count bytes de destino con valor (convertido a unsigned char).

Usos comunes:

1
2
3
4
5
6
7
// Inicializar array a cero
int arr[100];
memset(arr, 0, sizeof(arr));
// Limpiar buffer sensible
char password[64];
// ... usar password ...
memset(password, 0, sizeof(password)); // Borrar rastros

memcpy: Copia de Memoria¶

1
void *memcpy(void *destino, const void *origen, size_t count);

Copia count bytes desde origen a destino. Las regiones no deben solaparse.

Ejemplo:

1
2
3
4
int src[5] = {1, 2, 3, 4, 5};
int dst[5];
memcpy(dst, src, sizeof(src));
// dst == {1, 2, 3, 4, 5}

Arreglos de Largo Variable (VLA)¶

Los VLA (Variable Length Arrays) son arreglos cuyo tamaño se determina en tiempo de ejecución, no en compilación.

1
2
3
4
void funcion(int cantidad)
{
    int arreglo[cantidad]; // <-- VLA: tamaño determinado en runtime
}

¿Por Qué No Son Parte del Camino Principal?¶

1. Asignación en el Stack¶

Los VLAs se crean en el stack, no en el heap (ver Comparación Stack vs Heap). El stack tiene tamaño limitado (típicamente 1-8 MB).

1
2
3
4
5
void procesar(int n)
{
    int datos[n]; // VLA en el stack
    // Si n es grande (por ejemplo, 1,000,000), esto causa stack overflow
}

2. No Hay Mecanismo de Error¶

A diferencia de malloc, que retorna NULL si falla, un VLA cuya dimensión excede la capacidad del stack en tiempo de ejecución simplemente provoca un desbordamiento del stack (stack overflow) y crashea el programa de manera irrecuperable:

1
2
3
4
5
6
7
8
9
10
11
12
13
int *heap_arr = malloc(n * sizeof(int));
if (heap_arr == NULL)
{
    // Podemos manejar el error
    fprintf(stderr, "Memoria insuficiente\n");
    return ERROR;
}
// vs
void procesar_con_vla(int n)
{
    int stack_arr[n]; // VLA: Si n es muy grande, el programa abortará sin que
    podamos interceptar el fallo.
}

3. Problemas de Portabilidad¶

El límite del stack varía entre plataformas y configuraciones. Código que funciona en una máquina puede crashear en otra.

Alternativa Correcta: Memoria Dinámica¶

1
2
3
4
5
6
7
8
9
10
11
void funcion(int cantidad)
{
    int *arreglo = malloc(cantidad * sizeof(int));
    if (arreglo == NULL)
    {
        // Manejar error
        return;
    }
    // Usar arreglo...
    free(arreglo);
}

Ejercicios de Autoevaluación (Funciones de Gestión y VLAs)¶

Compará estas dos funciones y explicá cuándo preferirías cada una:

void suma_vla(size_t n, const int a[n], int *r);
int *suma_heap(size_t n, const int *a);

Doble Indirección (Puntero a Puntero)¶

Una variable puntero es un tipo de dato que almacena una dirección de memoria. Sin embargo, al ser una variable en sí misma, también reside en una dirección de memoria física específica del sistema. La doble indirección consiste en utilizar un puntero que almacena la dirección de otra variable puntero, declarándose mediante el operador de doble asterisco (**).

1
2
3
int valor = 42;
int *p = &valor; // Puntero simple (indirección simple)
int **pp = &p;   // Doble puntero (doble indirección)

En este esquema:

• valor almacena el entero 42.

• p almacena la dirección de memoria de valor.

• pp almacena la dirección de memoria de la variable p.

Desreferenciar pp una vez (*pp) evalúa al puntero p (obteniendo la dirección de valor). Desreferenciar pp dos veces (**pp) accede directamente al contenido de valor (42).

Paso de Punteros por Referencia¶

En el lenguaje C, todos los argumentos de una función se transmiten estrictamente por valor (copia). Esto significa que la función trabaja con copias locales de los parámetros recibidos.

Si necesitás que una función modifique un tipo de dato básico (como un int), debés pasar un puntero a esa variable (int *) para simular un paso por referencia. De forma análoga, si una función necesita modificar una variable puntero (por ejemplo, para asignarle memoria dinámica o reubicarla), se debe pasar la dirección del puntero, lo que requiere un doble puntero (int **).

El Error Común: Pasar un Puntero Simple¶

Considerá la siguiente función que intenta asignar memoria para un entero:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include <stdlib.h>
// Intento incorrecto de asignar memoria
void inicializar_incorrecto(int *ptr)
{
    ptr = malloc(sizeof(int)); // Modifica la copia local
    if (ptr != NULL)
    {
        *ptr = 10;
    }
}
int main(void)
{
    int *mi_puntero = NULL;
    inicializar_incorrecto(mi_puntero);
    // ERROR: mi_puntero sigue siendo NULL en main
    // Además, se generó un memory leak de la memoria asignada en la función.
    return 0;
}

Al invocar inicializar_incorrecto(mi_puntero), el valor de mi_puntero (que es NULL) se copia en el parámetro local ptr. Cuando la función ejecuta malloc, almacena la dirección de la memoria reservada en la variable local ptr. Al retornar la función, ptr se destruye en el stack y mi_puntero en main permanece inalterado, provocando una fuga de memoria física.

La Solución: Doble Indirección¶

Para modificar el puntero original de la función invocadora, se debe enviar su dirección de memoria (&mi_puntero). La función receptora utilizará un parámetro de doble indirección para acceder y modificar el puntero original mediante desreferencia:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <stdio.h>
#include <stdlib.h>
// Forma correcta utilizando doble indirección
void inicializar_correcto(int **ptr)
{
    if (ptr == NULL || *ptr != NULL)
    {
        return; // Evita desreferenciar un puntero nulo o reasignar memoria
    }
    *ptr = malloc(sizeof **ptr); // Modifica el puntero del llamador
    if (*ptr != NULL)
    {
        **ptr = 42; // Modifica el valor entero apuntado
    }
}
int main(void)
{
    int *mi_puntero = NULL;
    // Pasamos la dirección del puntero
    inicializar_correcto(&mi_puntero);
    if (mi_puntero != NULL)
    {
        printf("Valor asignado: %d\n", *mi_puntero);
        free(mi_puntero);
        mi_puntero = NULL;
    }
    return 0;
}

Patrón Práctico: Creación y Destrucción Modular¶

Este enfoque es el estándar en C para construir interfaces limpias de Tipos Abstractos de Datos (TAD), garantizando que las funciones que modifican la estructura interna o el estado de los punteros del cliente lo hagan de forma segura y controlada.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct
{
    char *nombre;
    int id;
} recurso_t;
typedef enum
{
    RECURSO_EXITO = 0,
    RECURSO_ERR_PARAMETROS,
    RECURSO_ERR_MEMORIA,
    RECURSO_ERR_PRECONDICION
} recurso_status_t;
// Constructor que inicializa el puntero del llamador
recurso_status_t recurso_crear(recurso_t **recurso_out, const char *nombre,
                               int id)
{
    if (recurso_out == NULL || nombre == NULL)
    {
        return RECURSO_ERR_PARAMETROS;
    }
    if (*recurso_out != NULL)
    {
        return RECURSO_ERR_PRECONDICION; // Ya tiene memoria asignada
    }
    recurso_t *nuevo = malloc(sizeof(recurso_t));
    if (nuevo == NULL)
    {
        return RECURSO_ERR_MEMORIA;
    }
    nuevo->nombre = malloc(strlen(nombre) + 1);
    if (nuevo->nombre == NULL)
    {
        free(nuevo);
        return RECURSO_ERR_MEMORIA;
    }
    strcpy(nuevo->nombre, nombre);
    nuevo->id = id;
    *recurso_out = nuevo; // Retornamos el recurso creado por referencia
    return RECURSO_EXITO;
}
// Destructor defensivo que libera memoria y pone el puntero en NULL
void recurso_destruir(recurso_t **recurso_out)
{
    if (recurso_out == NULL || *recurso_out == NULL)
    {
        return;
    }
    free((*recurso_out)->nombre);
    free(*recurso_out);
    *recurso_out = NULL; // Evita punteros colgantes en el llamador
}

Matrices Dinámicas¶

Las variantes tridimensionales, VLA y las técnicas de representación especializadas quedan fuera del camino principal de este apunte.

Una matriz (arreglo bidimensional) puede implementarse de varias formas en memoria dinámica. Cada enfoque tiene trade-offs en complejidad, eficiencia de memoria y acceso.

Como se explica en El Montón (Heap), la memoria dinámica nos permite crear estructuras de tamaño arbitrario. Las matrices dinámicas extienden este concepto a dos dimensiones.

Enfoque 1: Matriz “Dentada” (Array de Punteros)¶

Este enfoque crea un arreglo de punteros, donde cada puntero apunta a una fila (otro arreglo). Se llama “dentada” (jagged array) porque cada fila puede tener largo diferente (aunque típicamente usamos filas del mismo tamaño).

Asignación¶

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int **matriz;
int filas = 3, columnas = 4;
// Paso 1: Array de punteros a filas
matriz = malloc(filas * sizeof(int *));
if (matriz == NULL)
{
    return NULL;
}
// Paso 2: Cada fila
for (int i = 0; i < filas; i++)
{
    matriz[i] = malloc(columnas * sizeof(int));
    if (matriz[i] == NULL)
    {
        // Error: liberar lo ya asignado
        for (int j = 0; j < i; j++)
        {
            free(matriz[j]);
        }
        free(matriz);
        return NULL;
    }
}

Acceso¶

El acceso es natural con la sintaxis estándar de C:

1
2
matriz[i][j] = 42;
int valor = matriz[i][j];

Liberación¶

Siguiendo el principio “de adentro hacia afuera” (Destrucción de Estructuras Dinámicas):

1
2
3
4
5
6
7
// 1. Liberar cada fila
for (int i = 0; i < filas; i++)
{
    free(matriz[i]);
}
// 2. Liberar el array de punteros
free(matriz);

Ventajas y Desventajas¶

Ventajas:

• Sintaxis natural matriz[i][j]

• Filas pueden tener tamaños diferentes

• Fácil de entender conceptualmente

Desventajas:

• Fragmentación: Cada fila es un bloque separado en el heap

• Overhead de memoria: Punteros adicionales para cada fila

• Cache-unfriendly: Filas no están contiguas en memoria (ver Jerarquía de Memoria y Caché)

Enfoque 2: Bloque Único (Simulación Manual)¶

Este enfoque asigna toda la matriz como un único bloque contiguo en memoria. Es más eficiente pero requiere calcular índices manualmente.

Asignación¶

1
2
3
4
5
6
7
int *matriz;
int filas = 3, columnas = 4;
matriz = malloc(filas * columnas * sizeof(int));
if (matriz == NULL)
{
    return NULL;
}

Acceso Manual¶

No podés usar matriz[i][j] directamente porque matriz es int *, no int **. Debés calcular el índice lineal:

1
2
3
4
// Acceso: fila i, columna j
int valor = matriz[i * columnas + j];
// Asignación
matriz[i * columnas + j] = 42;

Explicación del cálculo:

• Cada fila tiene columnas elementos

• Para llegar a la fila i, saltamos i * columnas elementos

• Luego avanzamos j columnas dentro de esa fila

Liberación¶

Solo una llamada a free:

1
free(matriz);

Función de Acceso Helper¶

Para mejorar la legibilidad, podés crear una función:

1
2
3
4
5
6
7
8
9
10
11
12
static inline int matriz_get(int *matriz, int fila, int col, int num_cols)
{
    return matriz[fila * num_cols + col];
}
static inline void matriz_set(int *matriz, int fila, int col, int num_cols,
                              int valor)
{
    matriz[fila * num_cols + col] = valor;
}
// Uso:
matriz_set(matriz, i, j, columnas, 42);
int val = matriz_get(matriz, i, j, columnas);

Ventajas y Desventajas¶

Ventajas:

• Memoria contigua: Excelente localidad de cache (ver Jerarquía de Memoria y Caché)

• Solo una asignación: Más eficiente, menos fragmentación

• Menos overhead: No hay punteros intermedios

Desventajas:

• Sintaxis de acceso menos intuitiva

• Todas las filas deben tener el mismo tamaño

• Fácil cometer errores en el cálculo de índices

Enfoque 3: Bloque Único con Puntero a Array¶

Este enfoque combina lo mejor de ambos mundos: memoria contigua del Enfoque 2 con la sintaxis natural del Enfoque 1, mediante un puntero a un array. Es fundamental aclarar que, para evitar la definición de tipos modificados dinámicamente en tiempo de ejecución (que constituyen una forma de VLA prohibida), las dimensiones de las columnas deben ser constantes conocidas en tiempo de compilación.

Asignación con Puntero a Array¶

1
2
3
4
5
6
7
8
#define COLUMNAS 4
int filas = 3;
// Puntero a un array de 'COLUMNAS' enteros (tamaño constante)
int (*matriz)[COLUMNAS] = malloc(sizeof(int) * COLUMNAS * filas);
if (matriz == NULL)
{
    return NULL;
}

Acceso Natural¶

Ahora podés usar la sintaxis estándar:

1
2
matriz[i][j] = 42;
int valor = matriz[i][j];

Aritmética de Punteros en el Direccionamiento Bidimensional¶

Para comprender cómo el compilador desreferencia la sintaxis matriz[i][j] en el Enfoque 3, debemos analizarla desde la aritmética de punteros.

Si declaramos int (*matriz)[COLUMNAS], el tipo de matriz es “puntero a un array de COLUMNAS enteros”. Por lo tanto, el tamaño del elemento al que apunta es $\text{sizeof}(int) \times \text{COLUMNAS}$ bytes.

El acceso matriz[i][j] es equivalente a *(*(matriz + i) + j). El compilador realiza el cálculo de la dirección física de la siguiente manera:

1. Desplazamiento de Fila (matriz + i): Al sumar i al puntero matriz, el compilador avanza i elementos del tipo apuntado. La dirección resultante es:

   $$\text{Dir}(matriz[i]) = \text{Dir}(matriz) + i \times \text{COLUMNAS} \times \text{sizeof}(int)$$

   (1)

2. Desplazamiento de Columna (*(matriz + i) + j): La expresión *(matriz + i) evalúa al array de la fila i. Por la regla de decaimiento (array decay), este decae a un puntero al primer entero de dicha fila (tipo int *). Al sumar j, avanzamos j enteros:

   $$\text{Dir}(matriz[i][j]) = \text{Dir}(matriz[i]) + j \times \text{sizeof}(int)$$

   (2)

3. Dirección Final Combinada: Sustituyendo la primera ecuación en la segunda, la dirección de memoria exacta del elemento es:

   $$\text{Dir}(matriz[i][j]) = \text{Dir}(matriz) + (i \times \text{COLUMNAS} + j) \times \text{sizeof}(int)$$

   (3)

Este cálculo de desplazamiento en bytes coincide exactamente con la simulación manual del Enfoque 2, con la ventaja de que el compilador realiza la multiplicación y escala los índices de forma transparente y eficiente.

Liberación¶

Solo un free:

1
free(matriz);

Comparación de Declaraciones¶

1
2
3
4
5
6
// Enfoque 1: Array de punteros
int **matriz1; // Puntero a puntero a int
// Enfoque 2: Puntero simple
int *matriz2; // Puntero a int
// Enfoque 3: Puntero a array
int (*matriz3)[COLUMNAS]; // Puntero a array de COLUMNAS ints

El Enfoque 3 y los Tipos Modificados¶

Para mantener una dimensión de columnas fija y evitar tipos modificados se utiliza:

1
2
#define COLUMNAS 4
int (*matriz)[COLUMNAS] = malloc(sizeof(int) * COLUMNAS * filas);

Ventajas y Desventajas¶

Ventajas:

• Sintaxis natural matriz[i][j]

• Memoria contigua (buena localidad de cache)

• Solo una asignación/liberación

Desventajas:

• Sintaxis de declaración compleja

• En C89, requiere tamaño de columnas constante

• Menos portable que los otros enfoques

Comparación de Enfoques¶

Ejercicios de Autoevaluación (Doble Indirección y Matrices)¶

Implementá crear_matriz para reservar un bloque contiguo de filas * columnas enteros y dejar *salida en NULL si la operación falla. ¿Qué overflow debés evitar?

#include <stdint.h>
#include <stdlib.h>

int crear_matriz(size_t filas, size_t columnas, int **salida)
{
    if (salida == NULL || filas == 0 || columnas == 0 ||
        filas > SIZE_MAX / columnas ||
        filas * columnas > SIZE_MAX / sizeof **salida)
        return 0;
    int *p = malloc(filas * columnas * sizeof *p);
    if (p == NULL) return 0;
    *salida = p;
    return 1;
}

Conexión con el Siguiente Tema¶

Dominando la gestión avanzada de memoria dinámica, tenés las herramientas para implementar estructuras de datos complejas: listas enlazadas, árboles, grafos, hash tables. Pero construir estas estructuras correctamente requiere algo más que conocimiento técnico de punteros.

El apunte TAD, Pilas y Colas introduce el concepto de Tipos Abstractos de Datos (TADs):

• Encapsulación: Ocultar detalles de implementación

• Interfaces limpias: Separar “qué hace” de “cómo lo hace”

• Invariantes: Propiedades que siempre deben cumplirse

• Patrones de diseño: crear/destruir, getters/setters, iteradores

Un TAD bien diseñado permite cambiar completamente la implementación interna (por ejemplo, de matriz dentada a bloque único) sin afectar al código cliente. Esta separación de concerns es fundamental para escribir software mantenible y escalable.

Los punteros y la memoria dinámica son las herramientas de bajo nivel; los TADs son los principios arquitecturales que guían su uso profesional.

Pregunta puente: Una lista enlazada y un array dinámico implementan la misma interfaz abstracta (secuencia de elementos). ¿Cómo decidir cuál usar? ¿Cómo diseñar la interfaz para que sea independiente de la implementación? El análisis de TADs responde estas preguntas.

Ejercicios de Autoevaluación¶

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdlib.h>
#include <string.h>
typedef struct
{
    char *nombre;
    int id;
} recurso_t;
recurso_t *recurso_crear(const char *nombre, int id)
{
    if (nombre == NULL)
        return NULL;
    // Paso 1: Asignar estructura contenedora
    recurso_t *nuevo = malloc(sizeof(recurso_t));
    if (nuevo == NULL)
        return NULL;
    // Paso 2: Asignar miembro interno (+1 para '\0')
    nuevo->nombre = malloc(strlen(nombre) + 1);
    if (nuevo->nombre == NULL)
    {
        free(nuevo); // Liberar contenedor previo para evitar leak
        return NULL;
    }
    // Paso 3: Copiar datos
    strcpy(nuevo->nombre, nombre);
    nuevo->id = id;
    return nuevo;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdlib.h>
void estudiante_destruir(estudiante_t *est)
{
    if (est == NULL)
    {
        return; // Cláusula de guarda
    }
    // 1. Liberar los miembros dinámicos internos primero
    free(est->nombre);
    free(est->apellido);
    // 2. Liberar la estructura contenedora al final
    free(est);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdlib.h>
int main()
{
    int *datos = malloc(5 * sizeof(int));
    if (datos == NULL)
        return 1;
    // ... uso de la memoria ...
    free(datos);  // Se libera el bloque, pero 'datos' sigue guardando la
                  // dirección
    datos = NULL; // Se mitiga el dangling pointer asignando NULL
    // Ahora es seguro realizar comprobaciones como:
    // if (datos != NULL) { ... }
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdlib.h>
void free_seguro(int **ptr)
{
    if (ptr == NULL || *ptr == NULL)
    {
        return; // Evita doble liberación o desreferencia nula
    }
    free(*ptr);  // Libera el bloque de memoria
    *ptr = NULL; // Pone el puntero original del invocador en NULL
}
// Ejemplo de uso:
// int *p = malloc(sizeof(int));
// free_seguro(&p);
// En este punto p es NULL de forma automática.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
#include <stdlib.h>
int redimensionar_arreglo(int **arr, size_t *capacidad)
{
    size_t nueva_capacidad = (*capacidad) * 2;
    // Se asigna el retorno en un puntero temporal
    int *temp = realloc(*arr, nueva_capacidad * sizeof(int));
    if (temp == NULL)
    {
        // En caso de fallo, *arr sigue apuntando al bloque original válido
        fprintf(stderr, "Error: Memoria insuficiente para redimensionar.\n");
        return -1;
    }
    *arr = temp; // Éxito: se actualiza el puntero del invocador
    *capacidad = nueva_capacidad;
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <stdlib.h>
typedef enum
{
    STATUS_OK = 0,
    STATUS_ERR_PARAM,
    STATUS_ERR_MEMORIA
} status_t;
status_t inicializar_puntero(int **out_ptr)
{
    if (out_ptr == NULL)
    {
        return STATUS_ERR_PARAM;
    }
    // Se asigna memoria desreferenciando una vez
    *out_ptr = malloc(sizeof(int));
    if (*out_ptr == NULL)
    {
        return STATUS_ERR_MEMORIA;
    }
    // Doble desreferencia para escribir el valor entero en el heap
    **out_ptr = 100;
    return STATUS_OK;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <stdlib.h>
// Asignación de la matriz dentada
double **matriz_crear(size_t filas, size_t columnas)
{
    double **mat = malloc(filas * sizeof(double *));
    if (mat == NULL)
        return NULL;
    for (size_t i = 0; i < filas; i++)
    {
        mat[i] = malloc(columnas * sizeof(double));
        if (mat[i] == NULL)
        {
            // Liberar lo asignado previamente en caso de fallo (LIFO)
            for (size_t j = 0; j < i; j++)
            {
                free(mat[j]);
            }
            free(mat);
            return NULL;
        }
    }
    return mat;
}
// Liberación de la matriz dentada
void matriz_liberar(double **mat, size_t filas)
{
    if (mat == NULL)
        return;
    for (size_t i = 0; i < filas; i++)
    {
        free(mat[i]); // Liberar cada fila primero
    }
    free(mat); // Liberar el array de punteros contenedor
}

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
int obtener_celda(const int *matriz, int columnas, int f, int c)
{
    // Cálculo del índice plano correspondiente a la celda bidimensional
    // Se desplazan f filas completas de ancho 'columnas', y se avanza c
    // elementos
    int indice_lineal = f * columnas + c;
    return matriz[indice_lineal];
}
// Ejemplo de uso:
// int *matriz = malloc(3 * 4 * sizeof(int));
// int valor = obtener_celda(matriz, 4, 2, 1); // Accede a matriz[2][1]

Glosario¶

Síntesis y Resumen¶

Conceptos Clave¶

Este apunte explora patrones avanzados de memoria dinámica en C, construyendo sobre los fundamentos de Modelo de memoria y pila y Punteros.

Referencias y Lecturas de Aritmética de Punteros¶

Textos Fundamentales sobre Memoria Dinámica¶

• Kernighan & Ritchie (2014). Capítulo 8: The UNIX System Interface. Gestión de memoria y estructuras complejas.

• King (2008). Capítulo 17: Advanced Uses of Pointers. Matrices multidimensionales y estructuras auto-referenciadas.

• Gustedt (2019). Level 2, Takeaway 2.6.5: Dynamic allocation. Patrones modernos de gestión de memoria.

Gestión de Memoria y Debugging¶

• Seacord (2013). Capítulo 4: Dynamic Memory Management. Errores comunes y cómo evitarlos.

• Valgrind Memcheck Manual - https://valgrind.org/docs/manual/mc-manual.html

  • Herramienta esencial para detectar leaks y dangling pointers.

Matrices y Estructuras Multidimensionales¶

• Linden (1994). Capítulo 4: The Shocking Truth: C Arrays and Pointers Are NOT the Same!

• Multi-dimensional Arrays in C - https://www.cs.cmu.edu/~ab/15-123S11/lectures/Lecture 09 - Multidimensional Arrays.pdf

Optimización y Performance¶

• Bryant & O'Hallaron (2015). Capítulo 6: Memory Hierarchy. Localidad de cache y performance de acceso.

• Warren (2012). Capítulo 9: Memory. Técnicas de optimización de memoria.

Patrones de Diseño con Memoria Dinámica¶

• Hanson (1996). Interfaces y implementaciones con gestión de memoria robusta.

• Plauger (1992). Implementaciones de la biblioteca estándar que usan memoria dinámica.

Herramientas de Análisis¶

• AddressSanitizer - https://github.com/google/sanitizers/wiki/AddressSanitizer

  • Detector de errores de memoria integrado en GCC/Clang.

• Dr. Memory - https://drmemory.org/

  • Alternativa a Valgrind para Windows.