Gestión de Memoria Dinámica en C

void funcion_b()
{
    int z = 30;
    // Stack: [x=10] [y=20] [z=30] <- cima
    // Al retornar, z desaparece automáticamente
}

void funcion_a()
{
    int y = 20;
    // Stack: [x=10] [y=20] <- cima
    funcion_b();
    // Stack: [x=10] [y=20] <- cima (z ya no existe)
}

int main()
{
    int x = 10;
    // Stack: [x=10] <- cima
    funcion_a();
    // Stack: [x=10] <- cima (y ya no existe)
    return 0;
}

funcion:
    push rbp              ; Guardar frame pointer anterior
    mov rbp, rsp          ; Establecer nuevo frame pointer
    sub rsp, 16           ; Reservar espacio para variables locales

    ; ... cuerpo de la función ...

    mov rsp, rbp          ; Restaurar stack pointer
    pop rbp               ; Restaurar frame pointer anterior
    ret                   ; Retornar

int *funcion_incorrecta()
{
    int valor = 42;
    return &valor;  // ERROR: retorna dirección de variable local
    // 'valor' desaparece al salir de la función
}

int *funcion_correcta()
{
    int *valor = malloc(sizeof(*valor));
    if (valor == NULL)
    {
        return NULL;
    }
    *valor = 42;
    return valor;  // CORRECTO: la memoria persiste
    // El llamador debe liberar esta memoria
}

void *memoria_generica = malloc(100);  // void *, no sabemos qué tipo
int *enteros = memoria_generica;        // Conversión implícita a int *
char *caracteres = memoria_generica;    // O a char *, según necesites

void *ptr = malloc(10 * sizeof(int));

// ERROR: No se puede desreferenciar void *
// *ptr = 42;

// CORRECTO: Convertir primero
int *int_ptr = (int *)ptr;
*int_ptr = 42;

// ERROR: No se puede hacer aritmética con void *
// ptr = ptr + 1;  // ¿Cuántos bytes avanzar?

// CORRECTO: Convertir a tipo concreto primero
int_ptr = int_ptr + 1;  // Avanza sizeof(int) bytes

int *int_ptr = malloc(sizeof(int));
char *char_ptr = (char *)int_ptr;  // Cast explícito

// Reinterpretar los bytes:
*int_ptr = 0x41424344;
printf("%c\n", char_ptr[0]);  // Imprime 'D' (little-endian)

// Array 2D: 3 filas, 4 columnas
int **matriz = malloc(3 * sizeof(int *));
for (int i = 0; i < 3; i++)
{
    matriz[i] = malloc(4 * sizeof(int));
}

// Acceso: matriz[fila][columna]
matriz[0][0] = 10;
matriz[2][3] = 99;

// Liberar: en orden inverso
for (int i = 0; i < 3; i++)
{
    free(matriz[i]);
}
free(matriz);

int (*ptr)[4];  // Puntero a array de 4 enteros

// Declaración de array 2D tradicional
int matriz[3][4] = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

// Puntero a array de 4 enteros
int (*ptr)[4] = matriz;

// Acceso equivalente:
printf("%d\n", matriz[1][2]);  // 7
printf("%d\n", ptr[1][2]);     // 7
printf("%d\n", (*(ptr + 1))[2]); // 7 - explícito

int (*ptr)[4] = matriz;

// ptr apunta a matriz[0] (toda la primera fila)
// ptr + 1 apunta a matriz[1] (toda la segunda fila)
// ptr + 2 apunta a matriz[2] (toda la tercera fila)

// Cada incremento salta 4 * sizeof(int) bytes

#include <stdio.h>
#include <stdlib.h>

// Crear matriz 2D contígua: filas × columnas
int (*crear_matriz_contigua(size_t filas, size_t columnas))[columnas]
{
    // Asignar toda la memoria de una vez
    int (*matriz)[columnas] = malloc(filas * sizeof(*matriz));

    if (matriz == NULL)
    {
        return NULL;
    }

    // Inicializar
    for (size_t i = 0; i < filas; i++)
    {
        for (size_t j = 0; j < columnas; j++)
        {
            matriz[i][j] = 0;
        }
    }

    return matriz;
}

int main()
{
    size_t filas = 3;
    size_t columnas = 4;

    // Nota: necesitamos VLA (Variable Length Array) o C11
    int (*matriz)[columnas] = crear_matriz_contigua(filas, columnas);

    if (matriz == NULL)
    {
        return 1;
    }

    // Llenar la matriz
    for (size_t i = 0; i < filas; i++)
    {
        for (size_t j = 0; j < columnas; j++)
        {
            matriz[i][j] = (int)(i * columnas + j);
        }
    }

    // Acceso natural: matriz[i][j]
    printf("matriz[1][2] = %d\n", matriz[1][2]);

    // Liberar: una sola llamada
    free(matriz);

    return 0;
}

// Asignar memoria plana
int *memoria_plana = malloc(3 * 4 * sizeof(int));

// Reinterpretar como matriz 3×4
int (*matriz)[4] = (int (*)[4])memoria_plana;

// Ahora podés usar sintaxis de array 2D:
matriz[0][0] = 1;
matriz[1][2] = 7;
matriz[2][3] = 12;

// El acceso matriz[i][j] se traduce a:
// memoria_plana[i * 4 + j]

// Estas tres formas son equivalentes:
matriz[i][j]
(*(matriz + i))[j]
memoria_plana[i * 4 + j]

#include <stdio.h>
#include <stdlib.h>

void imprimir_por_puntero_plano(int *arr, size_t filas, size_t cols)
{
    printf("Como puntero plano:\n");
    for (size_t i = 0; i < filas * cols; i++)
    {
        printf("%2d ", arr[i]);
        if ((i + 1) % cols == 0) printf("\n");
    }
}

void imprimir_por_puntero_a_array(int (*arr)[4], size_t filas)
{
    printf("Como puntero a array:\n");
    for (size_t i = 0; i < filas; i++)
    {
        for (size_t j = 0; j < 4; j++)
        {
            printf("%2d ", arr[i][j]);
        }
        printf("\n");
    }
}

int main()
{
    // Asignar memoria contígua para 3×4 enteros
    int *memoria = malloc(3 * 4 * sizeof(int));

    if (memoria == NULL)
    {
        return 1;
    }

    // Llenar con valores
    for (int i = 0; i < 12; i++)
    {
        memoria[i] = i + 1;
    }

    // Representación 1: Puntero plano
    imprimir_por_puntero_plano(memoria, 3, 4);
    printf("\n");

    // Representación 2: Casteo a puntero a array
    int (*matriz)[4] = (int (*)[4])memoria;
    imprimir_por_puntero_a_array(matriz, 3);
    printf("\n");

    // Acceso directo con ambas representaciones:
    printf("memoria[5] = %d\n", memoria[5]);      // 6
    printf("matriz[1][1] = %d\n", matriz[1][1]);  // 6 (mismo elemento)

    // Modificar a través de matriz
    matriz[2][3] = 99;
    printf("memoria[11] = %d\n", memoria[11]);  // 99 (cambio reflejado)

    free(memoria);

    return 0;
}

// Sin typedef (difícil de leer):
int (*crear_matriz(size_t n))[10]
{
    return malloc(n * sizeof(int[10]));
}

// Con typedef (más claro):
typedef int fila_t[10];  // fila_t es un array de 10 ints

fila_t *crear_matriz(size_t n)
{
    return malloc(n * sizeof(fila_t));
}

// Uso:
fila_t *matriz = crear_matriz(5);
matriz[0][0] = 42;  // Funciona igual
free(matriz);

typedef struct {
    int datos[4];
} fila_estructurada_t;

// Más legible que int (*)[4]
fila_estructurada_t *matriz = malloc(3 * sizeof(*matriz));
matriz[0].datos[0] = 10;

// OK en C99+ con VLAs:
int (*crear(size_t cols))[cols]
{
    return malloc(5 * sizeof(int[cols]));
}

// NO OK en C89:
// El compilador necesita conocer cols en compile-time

// Usar typedef con tamaño fijo:
typedef int fila_fija_t[10];
fila_fija_t *crear(size_t filas)
{
    return malloc(filas * sizeof(fila_fija_t));
}

// O usar void * y castear:
void *crear_generico(size_t filas, size_t cols)
{
    return malloc(filas * cols * sizeof(int));
}

// Más fácil de debuggear:
int *arr = malloc(filas * cols * sizeof(int));
int elemento = arr[i * cols + j];  // Cálculo explícito

void *malloc(size_t size);

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int *numeros = NULL;
    size_t cantidad = 5;

    // Asignación de memoria
    numeros = malloc(cantidad * sizeof(*numeros));

    // Verificación del resultado
    if (numeros == NULL)
    {
        fprintf(stderr, "Error: No se pudo asignar memoria.\n");
        return 1;
    }

    // Uso de la memoria
    for (size_t i = 0; i < cantidad; i++)
    {
        numeros[i] = (int)i * 10;
    }

    // Liberación de la memoria
    free(numeros);
    numeros = NULL;

    return 0;
}

void *calloc(size_t num_elements, size_t element_size);

#include <stdio.h>
#include <stdlib.h>

int main()
{
    size_t cantidad = 5;
    int *arreglo = calloc(cantidad, sizeof(*arreglo));

    if (arreglo == NULL)
    {
        fprintf(stderr, "Error: No se pudo asignar memoria.\n");
        return 1;
    }

    // Todos los elementos están inicializados en 0
    for (size_t i = 0; i < cantidad; i++)
    {
        printf("arreglo[%zu] = %d\n", i, arreglo[i]);
    }

    free(arreglo);
    arreglo = NULL;

    return 0;
}

void free(void *ptr);

free(ptr);
ptr = NULL;  // Previene el uso accidental del puntero colgante

#include <stdlib.h>

void funcion_con_fuga()
{
    int *datos = malloc(100 * sizeof(*datos));

    // Se realizan operaciones...

    // ERROR: La función termina sin liberar 'datos'
    // El bloque de memoria se pierde
}

void funcion_sin_fuga()
{
    int *datos = malloc(100 * sizeof(*datos));

    if (datos == NULL)
    {
        return;
    }

    // Operaciones...

    free(datos);
    datos = NULL;
}

#include <stdlib.h>
#include <stdio.h>

int main()
{
    int *ptr = malloc(sizeof(*ptr));
    *ptr = 42;

    free(ptr);
    // ERROR: 'ptr' aún contiene la dirección liberada

    printf("%d\n", *ptr);  // Comportamiento indefinido

    return 0;
}

int main()
{
    int *ptr = malloc(sizeof(*ptr));
    *ptr = 42;

    free(ptr);
    ptr = NULL;  // Previene el uso del puntero colgante

    // Intentar desreferenciar ptr ahora causará un error inmediato
    // en lugar de comportamiento indefinido silencioso

    return 0;
}

#include <stdlib.h>

int main()
{
    int *ptr = malloc(sizeof(*ptr));

    free(ptr);
    free(ptr);  // ERROR: Doble liberación

    return 0;
}

int main()
{
    int *ptr = malloc(sizeof(*ptr));

    free(ptr);
    ptr = NULL;

    free(ptr);  // Seguro: free(NULL) no hace nada

    return 0;
}

#include <stdlib.h>

int main()
{
    int *arreglo = malloc(5 * sizeof(*arreglo));

    if (arreglo == NULL)
    {
        return 1;
    }

    // ERROR: Acceso fuera de límites
    for (size_t i = 0; i <= 5; i++)  // Debería ser i < 5
    {
        arreglo[i] = (int)i;
    }

    free(arreglo);
    arreglo = NULL;

    return 0;
}

int main()
{
    size_t tamano = 5;
    int *arreglo = malloc(tamano * sizeof(*arreglo));

    if (arreglo == NULL)
    {
        return 1;
    }

    // Correcto: i < tamano previene el acceso fuera de límites
    for (size_t i = 0; i < tamano; i++)
    {
        arreglo[i] = (int)i;
    }

    free(arreglo);
    arreglo = NULL;

    return 0;
}

#include <stdlib.h>
#include <stdio.h>

int main()
{
    int *ptr = malloc(sizeof(*ptr));
    *ptr = 100;

    free(ptr);

    // ERROR: Uso de memoria liberada
    printf("%d\n", *ptr);

    return 0;
}

// UB #1: Desreferenciar puntero NULL
int *ptr = NULL;
*ptr = 42;  // Crash probable, pero no garantizado

// UB #2: Uso después de free
int *ptr = malloc(sizeof(int));
free(ptr);
*ptr = 42;  // Puede parecer funcionar, pero es UB

// UB #3: Doble free
free(ptr);
free(ptr);  // Puede corromper el heap

// UB #4: Acceso fuera de límites
int arr[10];
arr[15] = 42;  // Puede sobrescribir otras variables

// UB #5: Retornar dirección de variable local
int *funcion() {
    int x = 42;
    return &x;  // x desaparece al retornar
}

void vulnerable()
{
    char buffer[10];
    char *datos_importantes = "SECRETO";

    // Un atacante puede escribir más de 10 bytes:
    strcpy(buffer, datos_maliciosos_largos);
    // Ahora datos_importantes puede haber sido sobrescrito
}

struct usuario {
    char nombre[50];
    int es_admin;
};

struct usuario *usr = malloc(sizeof(*usr));
usr->es_admin = 0;  // Usuario normal
free(usr);

// ... código intermedio ...

// Otro código asigna memoria que reutiliza el mismo espacio:
char *buffer = malloc(100);
strcpy(buffer, datos_del_atacante);

// Ahora usr apunta a memoria controlada por el atacante:
if (usr->es_admin) {  // ⚠️ UAF: usa memoria liberada
    // El atacante pudo sobrescribir es_admin a 1
    dar_privilegios_admin();
}

free(ptr);
// ... código ...
free(ptr);  // Corrompe la lista de bloques libres

// Asignaciones posteriores pueden retornar direcciones sobrepuestas:
int *a = malloc(100);
int *b = malloc(100);
// Ahora 'a' y 'b' podrían apuntar a la misma memoria!

// No solo verificar malloc:
if (ptr == NULL) { /* error */ }

// También verificar límites:
if (indice >= tamano) { /* error */ }

// Y validar punteros recibidos:
if (ptr_entrada == NULL) { /* error */ }

// Inicializar punteros:
int *ptr = NULL;

// Después de free, anular:
free(ptr);
ptr = NULL;

// Inicializar estructuras completamente:
struct datos d = {0};  // Todos los campos en cero

// En lugar de exponer punteros directamente:
recurso_t *crear_recurso(void);
void usar_recurso(recurso_t *r);
void destruir_recurso(recurso_t *r);

// Los usuarios nunca ven malloc/free directamente

// En lugar de:
strcpy(dest, src);  // No verifica límites

// Usar:
strncpy(dest, src, sizeof(dest) - 1);
dest[sizeof(dest) - 1] = '\0';

// O mejor aún, alocar dinámicamente con el tamaño correcto

int *ptr = NULL;

ptr = malloc(tamano);
if (ptr == NULL)
{
    // Manejo de error
    fprintf(stderr, "Error: No se pudo asignar memoria.\n");
    return ERROR_MEMORIA;
}

free(ptr);

free(ptr);
ptr = NULL;

recurso_t *crear_recurso()
{
    recurso_t *r = malloc(sizeof(*r));
    if (r == NULL)
    {
        return NULL;
    }
    // Inicialización...
    return r;
}

void destruir_recurso(recurso_t *r)
{
    if (r != NULL)
    {
        // Liberación de recursos internos...
        free(r);
    }
}

/**
 * Crea un nuevo nodo de lista.
 * @param valor El valor a almacenar en el nodo.
 * @returns Un puntero al nuevo nodo. El llamador es responsable
 *          de liberar esta memoria con destruir_nodo().
 *          Retorna NULL si no hay memoria disponible.
 */
nodo_t *crear_nodo(int valor);

void imprimir_arreglo(const int *arreglo, size_t tamano)
{
    for (size_t i = 0; i < tamano; i++)
    {
        printf("%d ", arreglo[i]);
    }
    printf("\n");
}

// Preferido
int *ptr = malloc(n * sizeof(*ptr));

// Evitar
int *ptr = malloc(n * sizeof(int));  // Si el tipo de ptr cambia, esto falla

size_t tamano = 10;
int *arreglo = malloc(tamano * sizeof(*arreglo));

for (size_t i = 0; i < tamano; i++)
{
    arreglo[i] = 0;
}

void establecer_elemento(int *arreglo, size_t tamano, size_t indice, int valor)
{
    if (indice < tamano)
    {
        arreglo[indice] = valor;
    }
}

(memoria-ejemplo-integrador)=
## Ejemplo Integrador: Arreglo Dinámico de Tamaño Fijo

Este ejemplo demuestra cómo aplicar las buenas prácticas de gestión de memoria en un caso realista: una estructura que encapsula un arreglo dinámico de enteros de tamaño fijo.

```c
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define ERROR_MEMORIA -1
#define ERROR_INDICE -2
#define EXITO 0

typedef struct
{
    int *datos;
    size_t tamano;
} arreglo_t;

/**
 * Crea un nuevo arreglo dinámico de tamaño fijo.
 * @param tamano El tamaño del arreglo (debe ser mayor que 0).
 * @returns Un puntero al arreglo creado. El llamador es responsable
 *          de liberar esta memoria con destruir_arreglo().
 *          Retorna NULL si no hay memoria disponible o si tamano es 0.
 * @post El arreglo está inicializado con todos sus elementos en 0.
 */
arreglo_t *crear_arreglo(size_t tamano)
{
    if (tamano == 0)
    {
        return NULL;
    }

    arreglo_t *arreglo = malloc(sizeof(*arreglo));
    if (arreglo == NULL)
    {
        return NULL;
    }

    arreglo->datos = calloc(tamano, sizeof(*(arreglo->datos)));
    if (arreglo->datos == NULL)
    {
        free(arreglo);
        return NULL;
    }

    arreglo->tamano = tamano;

    return arreglo;
}

/**
 * Establece el valor de un elemento en el arreglo.
 * @param arreglo Puntero al arreglo (no debe ser NULL).
 * @param indice Índice del elemento a modificar.
 * @param valor Nuevo valor para el elemento.
 * @pre arreglo no debe ser NULL.
 * @pre indice debe ser menor que el tamaño del arreglo.
 * @returns EXITO si el valor se estableció correctamente,
 *          ERROR_INDICE si el índice es inválido.
 */
int establecer_elemento(arreglo_t *arreglo, size_t indice, int valor)
{
    if (arreglo == NULL)
    {
        return ERROR_MEMORIA;
    }

    if (indice >= arreglo->tamano)
    {
        return ERROR_INDICE;
    }

    arreglo->datos[indice] = valor;
    return EXITO;
}

/**
 * Obtiene el valor de un elemento del arreglo.
 * @param arreglo Puntero al arreglo (no debe ser NULL).
 * @param indice Índice del elemento a obtener.
 * @param valor_out Puntero donde se almacenará el valor (no debe ser NULL).
 * @pre arreglo y valor_out no deben ser NULL.
 * @pre indice debe ser menor que el tamaño del arreglo.
 * @returns true si se obtuvo el elemento, false si algún parámetro es inválido.
 */
bool obtener_elemento(const arreglo_t *arreglo, size_t indice, int *valor_out)
{
    if (arreglo == NULL || valor_out == NULL)
    {
        return false;
    }

    if (indice >= arreglo->tamano)
    {
        return false;
    }

    *valor_out = arreglo->datos[indice];
    return true;
}

/**
 * Calcula la suma de todos los elementos del arreglo.
 * @param arreglo Puntero al arreglo (no debe ser NULL).
 * @pre arreglo no debe ser NULL.
 * @returns La suma de todos los elementos, o 0 si el arreglo es NULL.
 */
int sumar_elementos(const arreglo_t *arreglo)
{
    if (arreglo == NULL)
    {
        return 0;
    }

    int suma = 0;
    for (size_t i = 0; i < arreglo->tamano; i++)
    {
        suma = suma + arreglo->datos[i];
    }

    return suma;
}

/**
 * Imprime todos los elementos del arreglo.
 * @param arreglo Puntero al arreglo (no debe ser NULL).
 * @pre arreglo no debe ser NULL.
 */
void imprimir_arreglo(const arreglo_t *arreglo)
{
    if (arreglo == NULL)
    {
        return;
    }

    printf("Arreglo [tamaño: %zu]: [", arreglo->tamano);

    for (size_t i = 0; i < arreglo->tamano; i++)
    {
        printf("%d", arreglo->datos[i]);
        if (i < arreglo->tamano - 1)
        {
            printf(", ");
        }
    }

    printf("]\n");
}

/**
 * Destruye un arreglo y libera toda la memoria asociada.
 * @param arreglo Puntero al arreglo a destruir. Puede ser NULL.
 * @post Toda la memoria del arreglo es liberada.
 */
void destruir_arreglo(arreglo_t *arreglo)
{
    if (arreglo != NULL)
    {
        if (arreglo->datos != NULL)
        {
            free(arreglo->datos);
        }
        free(arreglo);
    }
}

int main()
{
    size_t tamano = 8;
    arreglo_t *mi_arreglo = crear_arreglo(tamano);

    if (mi_arreglo == NULL)
    {
        fprintf(stderr, "Error: No se pudo crear el arreglo.\n");
        return 1;
    }

    // Establecer algunos valores
    for (size_t i = 0; i < tamano; i++)
    {
        if (establecer_elemento(mi_arreglo, i, (int)(i * i)) != EXITO)
        {
            fprintf(stderr, "Error: No se pudo establecer elemento.\n");
            destruir_arreglo(mi_arreglo);
            return 1;
        }
    }

    imprimir_arreglo(mi_arreglo);

    // Obtener y mostrar un elemento específico
    int valor = 0;
    if (obtener_elemento(mi_arreglo, 3, &valor))
    {
        printf("Elemento en índice 3: %d\n", valor);
    }

    // Calcular la suma
    int suma = sumar_elementos(mi_arreglo);
    printf("Suma de todos los elementos: %d\n", suma);

    // Liberar recursos
    destruir_arreglo(mi_arreglo);

    return 0;
}

```{exercise} Cadena Dinámica
:label: ej-memoria-cadena

Implementá una función `duplicar_cadena` que reciba una cadena de caracteres y devuelva una copia exacta de ella en memoria dinámica. La función debe tener la siguiente firma:

```c
char *duplicar_cadena(const char *original);

```{solution} ej-memoria-cadena
:class: dropdown

```c
#include <stdio.h>
#include <stdlib.h>

/**
 * Duplica una cadena en memoria dinámica.
 * @param original Cadena a duplicar (no debe ser NULL).
 * @returns Un puntero a la nueva cadena. El llamador es responsable
 *          de liberar esta memoria con free().
 *          Retorna NULL si original es NULL o no hay memoria disponible.
 */
char *duplicar_cadena(const char *original)
{
    if (original == NULL)
    {
        return NULL;
    }

    // Calcular longitud de la cadena
    size_t longitud = 0;
    while (original[longitud] != '\0')
    {
        longitud = longitud + 1;
    }

    // Reservar memoria (longitud + 1 para el '\0')
    char *copia = malloc((longitud + 1) * sizeof(*copia));
    if (copia == NULL)
    {
        return NULL;
    }

    // Copiar caracter por caracter
    for (size_t i = 0; i <= longitud; i++)
    {
        copia[i] = original[i];
    }

    return copia;
}

int main()
{
    char original[100] = {0};

    printf("Ingresa una cadena (máximo 99 caracteres): ");
    if (fgets(original, sizeof(original), stdin) == NULL)
    {
        fprintf(stderr, "Error: No se pudo leer la cadena.\n");
        return 1;
    }

    // Remover el salto de línea si existe
    size_t longitud = 0;
    while (original[longitud] != '\0' && original[longitud] != '\n')
    {
        longitud = longitud + 1;
    }
    original[longitud] = '\0';

    char *copia = duplicar_cadena(original);
    if (copia == NULL)
    {
        fprintf(stderr, "Error: No se pudo duplicar la cadena.\n");
        return 1;
    }

    printf("Original: \"%s\"\n", original);
    printf("Copia: \"%s\"\n", copia);

    free(copia);
    copia = NULL;

    return 0;
}

```{exercise} Búsqueda en Arreglo Dinámico
:label: ej-memoria-busqueda

Implementá las siguientes funciones para trabajar con un arreglo dinámico de enteros:

```c
int *crear_arreglo_inicializado(size_t tamano, int valor_inicial);
int buscar_elemento(const int *arreglo, size_t tamano, int valor);
int contar_ocurrencias(const int *arreglo, size_t tamano, int valor);

```{solution} ej-memoria-busqueda
:class: dropdown

```c
#include <stdio.h>
#include <stdlib.h>

/**
 * Crea un arreglo dinámico inicializado con un valor específico.
 * @param tamano Tamaño del arreglo (debe ser mayor que 0).
 * @param valor_inicial Valor con el que se inicializará cada elemento.
 * @returns Un puntero al arreglo creado. El llamador es responsable
 *          de liberar esta memoria con free().
 *          Retorna NULL si tamano es 0 o no hay memoria disponible.
 */
int *crear_arreglo_inicializado(size_t tamano, int valor_inicial)
{
    if (tamano == 0)
    {
        return NULL;
    }

    int *arreglo = malloc(tamano * sizeof(*arreglo));
    if (arreglo == NULL)
    {
        return NULL;
    }

    for (size_t i = 0; i < tamano; i++)
    {
        arreglo[i] = valor_inicial;
    }

    return arreglo;
}

/**
 * Busca la primera ocurrencia de un valor en el arreglo.
 * @param arreglo Puntero al arreglo (no debe ser NULL).
 * @param tamano Tamaño del arreglo.
 * @param valor Valor a buscar.
 * @returns El índice de la primera ocurrencia, o -1 si no se encuentra.
 */
int buscar_elemento(const int *arreglo, size_t tamano, int valor)
{
    if (arreglo == NULL)
    {
        return -1;
    }

    for (size_t i = 0; i < tamano; i++)
    {
        if (arreglo[i] == valor)
        {
            return (int)i;
        }
    }

    return -1;
}

/**
 * Cuenta cuántas veces aparece un valor en el arreglo.
 * @param arreglo Puntero al arreglo (no debe ser NULL).
 * @param tamano Tamaño del arreglo.
 * @param valor Valor a contar.
 * @returns El número de ocurrencias del valor.
 */
int contar_ocurrencias(const int *arreglo, size_t tamano, int valor)
{
    if (arreglo == NULL)
    {
        return 0;
    }

    int contador = 0;
    for (size_t i = 0; i < tamano; i++)
    {
        if (arreglo[i] == valor)
        {
            contador = contador + 1;
        }
    }

    return contador;
}

int main()
{
    size_t tamano = 10;
    int valor_inicial = 5;

    int *arreglo = crear_arreglo_inicializado(tamano, valor_inicial);
    if (arreglo == NULL)
    {
        fprintf(stderr, "Error: No se pudo crear el arreglo.\n");
        return 1;
    }

    printf("Arreglo inicial (todos %d): ", valor_inicial);
    for (size_t i = 0; i < tamano; i++)
    {
        printf("%d ", arreglo[i]);
    }
    printf("\n");

    // Modificar algunos elementos
    arreglo[2] = 10;
    arreglo[5] = 10;
    arreglo[7] = 15;

    printf("Arreglo modificado: ");
    for (size_t i = 0; i < tamano; i++)
    {
        printf("%d ", arreglo[i]);
    }
    printf("\n");

    // Buscar valores
    int buscar = 10;
    int indice = buscar_elemento(arreglo, tamano, buscar);
    if (indice != -1)
    {
        printf("Primera ocurrencia de %d: índice %d\n", buscar, indice);
    }
    else
    {
        printf("No se encontró %d en el arreglo\n", buscar);
    }

    // Contar ocurrencias
    int ocurrencias = contar_ocurrencias(arreglo, tamano, buscar);
    printf("El valor %d aparece %d veces\n", buscar, ocurrencias);

    ocurrencias = contar_ocurrencias(arreglo, tamano, valor_inicial);
    printf("El valor %d aparece %d veces\n", valor_inicial, ocurrencias);

    free(arreglo);
    arreglo = NULL;

    return 0;
}

```{exercise} Matriz Dinámica
:label: ej-memoria-matriz

Implementá funciones para crear y manipular una matriz dinámica de enteros de tamaño $m \times n$:

```c
int **crear_matriz(size_t filas, size_t columnas);
void liberar_matriz(int **matriz, size_t filas);
void imprimir_matriz(int **matriz, size_t filas, size_t columnas);

```{solution} ej-memoria-matriz
:class: dropdown

```c
#include <stdio.h>
#include <stdlib.h>

/**
 * Crea una matriz dinámica de enteros.
 * @param filas Número de filas.
 * @param columnas Número de columnas.
 * @returns Un puntero a la matriz creada. El llamador es responsable
 *          de liberar esta memoria con liberar_matriz().
 *          Retorna NULL si no hay memoria disponible.
 */
int **crear_matriz(size_t filas, size_t columnas)
{
    int **matriz = malloc(filas * sizeof(*matriz));
    if (matriz == NULL)
    {
        return NULL;
    }

    for (size_t i = 0; i < filas; i++)
    {
        matriz[i] = malloc(columnas * sizeof(*(matriz[i])));
        if (matriz[i] == NULL)
        {
            // Liberar las filas ya asignadas
            for (size_t j = 0; j < i; j++)
            {
                free(matriz[j]);
            }
            free(matriz);
            return NULL;
        }

        // Inicializar la fila en 0
        for (size_t j = 0; j < columnas; j++)
        {
            matriz[i][j] = 0;
        }
    }

    return matriz;
}

/**
 * Libera una matriz dinámica.
 * @param matriz Puntero a la matriz. Puede ser NULL.
 * @param filas Número de filas de la matriz.
 */
void liberar_matriz(int **matriz, size_t filas)
{
    if (matriz == NULL)
    {
        return;
    }

    // Liberar en orden inverso: primero las filas, luego el arreglo
    for (size_t i = 0; i < filas; i++)
    {
        free(matriz[i]);
    }
    free(matriz);
}

/**
 * Imprime una matriz.
 * @param matriz Puntero a la matriz (no debe ser NULL).
 * @param filas Número de filas.
 * @param columnas Número de columnas.
 * @pre matriz no debe ser NULL.
 */
void imprimir_matriz(int **matriz, size_t filas, size_t columnas)
{
    if (matriz == NULL)
    {
        return;
    }

    for (size_t i = 0; i < filas; i++)
    {
        for (size_t j = 0; j < columnas; j++)
        {
            printf("%4d ", matriz[i][j]);
        }
        printf("\n");
    }
}

int main()
{
    size_t filas = 3;
    size_t columnas = 4;

    int **matriz = crear_matriz(filas, columnas);
    if (matriz == NULL)
    {
        fprintf(stderr, "Error: No se pudo crear la matriz.\n");
        return 1;
    }

    // Llenar la matriz con valores
    for (size_t i = 0; i < filas; i++)
    {
        for (size_t j = 0; j < columnas; j++)
        {
            matriz[i][j] = (int)(i * columnas + j);
        }
    }

    printf("Matriz %zu x %zu:\n", filas, columnas);
    imprimir_matriz(matriz, filas, columnas);

    liberar_matriz(matriz, filas);

    return 0;
}

```{exercise} Estructura con Memoria Dinámica
:label: ej-memoria-estructura

Implementá un tipo de dato `persona_t` que almacene información de una persona:

```c
typedef struct
{
    char *nombre;
    char *apellido;
    int edad;
} persona_t;

persona_t *crear_persona(const char *nombre, const char *apellido, int edad);
void destruir_persona(persona_t *persona);
void imprimir_persona(const persona_t *persona);

```{solution} ej-memoria-estructura
:class: dropdown

```c
#include <stdio.h>
#include <stdlib.h>

typedef struct
{
    char *nombre;
    char *apellido;
    int edad;
} persona_t;

/**
 * Calcula la longitud de una cadena.
 * @param cadena Cadena a medir (no debe ser NULL).
 * @returns La longitud de la cadena (sin contar el '\0').
 */
size_t longitud_cadena(const char *cadena)
{
    size_t longitud = 0;
    while (cadena[longitud] != '\0')
    {
        longitud = longitud + 1;
    }
    return longitud;
}

/**
 * Duplica una cadena en memoria dinámica.
 * @param cadena Cadena a duplicar (no debe ser NULL).
 * @returns Un puntero a la copia, o NULL si hay un error.
 */
char *duplicar_cadena(const char *cadena)
{
    if (cadena == NULL)
    {
        return NULL;
    }

    size_t longitud = longitud_cadena(cadena);
    char *copia = malloc((longitud + 1) * sizeof(*copia));

    if (copia == NULL)
    {
        return NULL;
    }

    for (size_t i = 0; i <= longitud; i++)
    {
        copia[i] = cadena[i];
    }

    return copia;
}

/**
 * Crea una nueva persona.
 * @param nombre Nombre de la persona (no debe ser NULL).
 * @param apellido Apellido de la persona (no debe ser NULL).
 * @param edad Edad de la persona.
 * @returns Un puntero a la persona creada. El llamador es responsable
 *          de liberar esta memoria con destruir_persona().
 *          Retorna NULL si hay un error.
 */
persona_t *crear_persona(const char *nombre, const char *apellido, int edad)
{
    if (nombre == NULL || apellido == NULL)
    {
        return NULL;
    }

    persona_t *persona = malloc(sizeof(*persona));
    if (persona == NULL)
    {
        return NULL;
    }

    persona->nombre = duplicar_cadena(nombre);
    if (persona->nombre == NULL)
    {
        free(persona);
        return NULL;
    }

    persona->apellido = duplicar_cadena(apellido);
    if (persona->apellido == NULL)
    {
        free(persona->nombre);
        free(persona);
        return NULL;
    }

    persona->edad = edad;

    return persona;
}

/**
 * Destruye una persona y libera toda su memoria.
 * @param persona Puntero a la persona a destruir. Puede ser NULL.
 */
void destruir_persona(persona_t *persona)
{
    if (persona != NULL)
    {
        if (persona->nombre != NULL)
        {
            free(persona->nombre);
        }
        if (persona->apellido != NULL)
        {
            free(persona->apellido);
        }
        free(persona);
    }
}

/**
 * Imprime los datos de una persona.
 * @param persona Puntero a la persona (no debe ser NULL).
 */
void imprimir_persona(const persona_t *persona)
{
    if (persona == NULL)
    {
        return;
    }

    printf("Nombre: %s %s\n", persona->nombre, persona->apellido);
    printf("Edad: %d años\n", persona->edad);
}

int main()
{
    persona_t *p1 = crear_persona("Juan", "Pérez", 30);

    if (p1 == NULL)
    {
        fprintf(stderr, "Error: No se pudo crear la persona.\n");
        return 1;
    }

    imprimir_persona(p1);
    destruir_persona(p1);

    return 0;
}

```{exercise} Detección de Errores de Memoria
:label: ej-memoria-errores

El siguiente programa contiene varios errores relacionados con la gestión de memoria. Identificá todos los errores, explicá por qué son problemáticos, y corregílos.

```c
#include <stdio.h>
#include <stdlib.h>

int *crear_arreglo(int tamano)
{
    int *arr = malloc(tamano * sizeof(int));
    for (int i = 0; i <= tamano; i++)
    {
        arr[i] = i;
    }
    return arr;
}

void procesar_arreglo(int *arr, int tamano)
{
    free(arr);
    printf("Procesando arreglo...\n");
    for (int i = 0; i < tamano; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main()
{
    int *numeros = crear_arreglo(5);
    procesar_arreglo(numeros, 5);

    int valor = numeros[0];
    printf("Primer valor: %d\n", valor);

    free(numeros);

    return 0;
}

```{solution} ej-memoria-errores
:class: dropdown

**Errores identificados:**

1. **En `crear_arreglo`:** No se verifica si `malloc` retornó `NULL`.
2. **En `crear_arreglo`:** Acceso fuera de límites en el lazo (`i <= tamano` debería ser `i < tamano`).
3. **En `crear_arreglo`:** Falta usar `sizeof(*arr)` en lugar de `sizeof(int)` para mayor robustez.
4. **En `crear_arreglo`:** Se debería usar `size_t` para `tamano` en lugar de `int`.
5. **En `procesar_arreglo`:** Se libera la memoria al principio y luego se intenta acceder a ella (uso después de `free`).
6. **En `main`:** Se accede a `numeros` después de que fue liberado en `procesar_arreglo` (puntero colgante).
7. **En `main`:** Doble liberación: se llama a `free(numeros)` dos veces (una en `procesar_arreglo` y otra en `main`).
8. **En `main`:** No se establece `numeros = NULL` después de liberar.

**Código corregido:**

```c
#include <stdio.h>
#include <stdlib.h>

/**
 * Crea un arreglo dinámico inicializado con valores secuenciales.
 * @param tamano Tamaño del arreglo (debe ser mayor que 0).
 * @returns Un puntero al arreglo creado, o NULL si hay un error.
 */
int *crear_arreglo(size_t tamano)
{
    if (tamano == 0)
    {
        return NULL;
    }

    int *arr = malloc(tamano * sizeof(*arr));
    if (arr == NULL)
    {
        return NULL;
    }

    for (size_t i = 0; i < tamano; i++)
    {
        arr[i] = (int)i;
    }

    return arr;
}

/**
 * Procesa un arreglo imprimiendo sus elementos.
 * @param arr Puntero al arreglo (no debe ser NULL).
 * @param tamano Tamaño del arreglo.
 */
void procesar_arreglo(const int *arr, size_t tamano)
{
    if (arr == NULL)
    {
        return;
    }

    printf("Procesando arreglo...\n");
    for (size_t i = 0; i < tamano; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main()
{
    size_t tamano = 5;
    int *numeros = crear_arreglo(tamano);

    if (numeros == NULL)
    {
        fprintf(stderr, "Error: No se pudo crear el arreglo.\n");
        return 1;
    }

    procesar_arreglo(numeros, tamano);

    int valor = numeros[0];
    printf("Primer valor: %d\n", valor);

    free(numeros);
    numeros = NULL;

    return 0;
}

```{solution} ej-memoria-puntero-array
:class: dropdown

```c
#include <stdio.h>
#include <stdlib.h>

/**
 * Crea una matriz dinámica contígua usando puntero a array.
 * @param filas Número de filas.
 * @param columnas Número de columnas.
 * @returns Un puntero a array que apunta a la matriz, o NULL si hay error.
 * @note Requiere C99+ para VLA en tipo de retorno.
 */
int (*crear_matriz_contigua(size_t filas, size_t columnas))[columnas]
{
    // Asignar memoria contígua para todos los elementos
    int (*matriz)[columnas] = malloc(filas * sizeof(*matriz));

    if (matriz == NULL)
    {
        return NULL;
    }

    // Inicializar a cero
    for (size_t i = 0; i < filas; i++)
    {
        for (size_t j = 0; j < columnas; j++)
        {
            matriz[i][j] = 0;
        }
    }

    return matriz;
}

/**
 * Llena la matriz con el patrón: matriz[i][j] = i * columnas + j
 * @param matriz Puntero a la matriz (no debe ser NULL).
 * @param filas Número de filas.
 * @param columnas Número de columnas.
 */
void llenar_matriz(int (*matriz)[/* columnas debe coincidir */],
                   size_t filas, size_t columnas)
{
    if (matriz == NULL)
    {
        return;
    }

    for (size_t i = 0; i < filas; i++)
    {
        for (size_t j = 0; j < columnas; j++)
        {
            matriz[i][j] = (int)(i * columnas + j);
        }
    }
}

/**
 * Imprime la matriz.
 * @param matriz Puntero a la matriz (no debe ser NULL).
 * @param filas Número de filas.
 * @param columnas Número de columnas.
 */
void imprimir_matriz_contigua(int (*matriz)[], size_t filas, size_t columnas)
{
    if (matriz == NULL)
    {
        return;
    }

    for (size_t i = 0; i < filas; i++)
    {
        for (size_t j = 0; j < columnas; j++)
        {
            // Acceso usando puntero a array
            printf("%4d ", (*matriz)[i * columnas + j]);
        }
        printf("\n");
    }
}

/**
 * Transpone una matriz cuadrada in-place.
 * @param matriz Puntero a la matriz cuadrada (no debe ser NULL).
 * @param n Tamaño de la matriz (n×n).
 */
void transponer_cuadrada(int (*matriz)[/* n */], size_t n)
{
    if (matriz == NULL)
    {
        return;
    }

    // Intercambiar matriz[i][j] con matriz[j][i]
    for (size_t i = 0; i < n; i++)
    {
        for (size_t j = i + 1; j < n; j++)
        {
            int temp = matriz[i][j];
            matriz[i][j] = matriz[j][i];
            matriz[j][i] = temp;
        }
    }
}

int main()
{
    size_t n = 4;  // Matriz 4×4

    // Crear matriz contígua
    int (*matriz)[n] = crear_matriz_contigua(n, n);

    if (matriz == NULL)
    {
        fprintf(stderr, "Error: No se pudo crear la matriz.\n");
        return 1;
    }

    // Llenar con patrón
    llenar_matriz((int (*)[])(matriz), n, n);

    printf("Matriz original %zu×%zu:\n", n, n);
    imprimir_matriz_contigua((int (*)[])(matriz), n, n);

    // Transponer
    transponer_cuadrada((int (*)[])(matriz), n);

    printf("\nMatriz transpuesta:\n");
    imprimir_matriz_contigua((int (*)[])(matriz), n, n);

    // Verificar la transposición
    printf("\nVerificación:\n");
    printf("Elemento [0][1] (era 1, ahora debe ser 4): %d\n", matriz[0][1]);
    printf("Elemento [1][0] (era 4, ahora debe ser 1): %d\n", matriz[1][0]);
    printf("Elemento [2][3] (era 11, ahora debe ser 14): %d\n", matriz[2][3]);

    // Liberar: una sola llamada
    free(matriz);
    matriz = NULL;

    return 0;
}

// Opción 1: Tamaño fijo con typedef
#define MAX_COLS 10
typedef int fila_t[MAX_COLS];

fila_t *crear_matriz_fija(size_t filas)
{
    return malloc(filas * sizeof(fila_t));
}

// Opción 2: void * y casteo manual
void *crear_matriz_generica(size_t filas, size_t cols)
{
    return malloc(filas * cols * sizeof(int));
}

// Uso:
int (*matriz)[4] = (int (*)[4])crear_matriz_generica(5, 4);

(memoria-conceptos-avanzados)=
## Conceptos Avanzados

(memoria-jerarquia-cache)=
### Jerarquía de Memoria y Caché

Para comprender completamente por qué el stack es más rápido que el heap,
necesitás entender la **jerarquía de memoria** del hardware moderno. La memoria
no es un espacio uniforme: hay múltiples niveles con diferentes velocidades y
tamaños.

**La jerarquía típica (de más rápido a más lento):**

```{figure} ./11/cache_hierarchy.svg
:name: fig-cache-hierarchy
:width: 70%

Jerarquía de memoria desde los registros CPU (más rápidos) hasta los discos duros (más lentos), mostrando la relación inversa entre velocidad y capacidad.

Acceso a memoria:
CPU → L1? (hit) → Usar dato (rápido)
    ↓ (miss)
    L2? (hit) → Copiar a L1 → Usar dato
    ↓ (miss)
    L3? (hit) → Copiar a L2 y L1 → Usar dato
    ↓ (miss)
    RAM → Copiar a cachés → Usar dato (lento)

// Versión stack (rápida):
void procesar_stack()
{
    int datos[1000];  // Asignación instantánea

    // Todos los elementos probablemente en caché:
    for (int i = 0; i < 1000; i++)
    {
        datos[i] = i * 2;  // Acceso secuencial, alta localidad
    }
}

// Versión heap (más lenta):
void procesar_heap()
{
    int *datos = malloc(1000 * sizeof(int));  // Llamada a función

    if (datos == NULL) return;

    // Posiblemente más cache misses:
    for (int i = 0; i < 1000; i++)
    {
        datos[i] = i * 2;  // Menos predecible para el hardware
    }

    free(datos);  // Otra llamada a función
}

struct ejemplo {
    char a;      // 1 byte
    // 3 bytes de padding insertados automáticamente
    int b;       // 4 bytes (debe estar en múltiplo de 4)
    char c;      // 1 byte
    // 3 bytes de padding al final para el arreglo
};

// sizeof(struct ejemplo) = 12, no 6

// Desperdicia espacio (16 bytes):
struct ineficiente {
    char a;      // 1 byte
    int b;       // 4 bytes (+ 3 padding antes)
    char c;      // 1 byte (+ 3 padding después)
};

// Más eficiente (8 bytes):
struct eficiente {
    int b;       // 4 bytes
    char a;      // 1 byte
    char c;      // 1 byte
    // 2 bytes padding al final (menos que antes)
};

#include <stdio.h>
#include <stddef.h>

struct prueba {
    char a;
    int b;
    char c;
};

int main()
{
    printf("Tamaño de struct: %zu\n", sizeof(struct prueba));
    printf("Offset de 'a': %zu\n", offsetof(struct prueba, a));
    printf("Offset de 'b': %zu\n", offsetof(struct prueba, b));
    printf("Offset de 'c': %zu\n", offsetof(struct prueba, c));

    return 0;
}

int *p = malloc(sizeof(int));
// p está garantizado como alineado para 'int'

struct grande {
    double d;  // Necesita alineación de 8 bytes
    long l;
};
struct grande *s = malloc(sizeof(*s));
// s está garantizado como alineado para todos los campos

# Compilar con símbolos de depuración
gcc -g -o programa programa.c

# Ejecutar con Valgrind
valgrind --leak-check=full --show-leak-kinds=all ./programa

==12345== Invalid write of size 4
==12345==    at 0x108A: main (programa.c:15)
==12345==  Address 0x522d068 is 0 bytes after a block of size 40 alloc'd

// Ineficiente: muchas asignaciones pequeñas
for (int i = 0; i < 1000; i++)
{
    char *str = malloc(10);  // 1000 llamadas a malloc
    // ... usar str ...
    free(str);               // 1000 llamadas a free
}

// Mejor: una asignación grande
char *buffer = malloc(10000);
for (int i = 0; i < 1000; i++)
{
    char *str = buffer + (i * 10);  // Solo aritmética de punteros
    // ... usar str ...
}
free(buffer);  // Una sola llamada a free

// Malo: Acceso aleatorio (muchos cache misses)
for (int i = 0; i < n; i++)
{
    int idx = random_index();
    data[idx] = process(data[idx]);  // Impredecible para el caché
}

// Bueno: Acceso secuencial (cache hits)
for (int i = 0; i < n; i++)
{
    data[i] = process(data[i]);  // Predecible, alta localidad
}

// Si tu estructura cabe en caché L1 (32 KB):
struct pequena datos[1000];  // 4 KB total, cabe en L1
// Acceso muy rápido, todo en caché

// Si excede la caché L3 (8 MB):
struct grande datos[1000000];  // 100 MB, no cabe
// Muchos accesos a RAM, más lento

// Un nivel de indirección:
int *ptr = malloc(sizeof(int));
*ptr = 42;  // Lee ptr, luego lee *ptr (2 accesos potenciales a RAM)

// Dos niveles de indirección:
int **ptr2 = malloc(sizeof(int *));
*ptr2 = malloc(sizeof(int));
**ptr2 = 42;  // Lee ptr2, luego *ptr2, luego **ptr2 (3 accesos)

// Directo (sin indirección):
int valor = 42;  // Puede estar en registro, cero accesos a memoria

// Opción A: Arreglo continuo (stack o heap)
int arreglo[1000000];
for (int i = 0; i < 1000000; i++)
{
    arreglo[i] = i * 2;
}
// Costo: ~1 millón de escrituras secuenciales
// Cache: Muy efectivo (prefetching automático)
// Tiempo: ~1-2 ms en un CPU moderno

// Opción B: Lista enlazada (heap)
struct nodo *lista = crear_lista(1000000);
struct nodo *actual = lista;
int i = 0;
while (actual != NULL)
{
    actual->valor = i * 2;
    actual = actual->siguiente;  // Sigue puntero (indirección)
    i++;
}
// Costo: ~1 millón de escrituras + 1 millón de lecturas de punteros
// Cache: Malo (los nodos están dispersos)
// Tiempo: ~5-20 ms (3-10x más lento)