Memoria Dinámica

void *malloc(size_t size);

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
#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);

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
#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;
}

1
void *realloc(void *ptr, size_t new_size);

1
2
3
4
5
// ¡PELIGRO! Si realloc falla, se pierde el puntero original
ptr = realloc(ptr, nuevo_tamano);
if (ptr == NULL) {
    // Fuga de memoria: el bloque original se perdió
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdlib.h>

int *numeros = malloc(5 * sizeof(*numeros));
if (numeros == NULL) {
    fprintf(stderr, "Error: No se pudo asignar memoria inicial.\n");
    return 1;
}
// ...

size_t nuevo_tamano = 10;
int *temp = realloc(numeros, nuevo_tamano * sizeof(*temp));

if (temp == NULL) {
    // realloc falló, pero 'numeros' sigue siendo válido
    fprintf(stderr, "Error: No se pudo redimensionar la memoria.\n");
    free(numeros); // Liberar el bloque original
    numeros = NULL;
    return 1;
}

// Éxito: ahora 'numeros' puede apuntar al nuevo bloque
numeros = temp;

1
void free(void *ptr);

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

1
2
3
4
5
6
7
8
9
10
11
#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
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void funcion_sin_fuga()
{
    int *datos = malloc(100 * sizeof(*datos));

    if (datos == NULL)
    {
        return;
    }

    // Operaciones...

    free(datos);
    datos = NULL;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdlib.h>
#include <stdio.h>

int main()
{
    int *ptr = malloc(sizeof(*ptr));
    if (ptr == NULL)
    {
        return 1;
    }
    *ptr = 42;

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

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

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
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;
}

1
2
3
4
5
6
7
8
9
10
11
#include <stdlib.h>

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

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

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int main()
{
    int *ptr = malloc(sizeof(*ptr));
    if (ptr == NULL)
    {
        return 1;
    }

    free(ptr);
    ptr = NULL;

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

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 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
}

(vulnerabilidades-comunes)=
#### Vulnerabilidades Comunes

Los errores de memoria no son solo bugs: son vulnerabilidades de seguridad.
Comprender los ataques comunes te ayuda a escribir código más defensivo.

**Buffer Overflow:**

Un buffer overflow ocurre cuando escribís más datos de los que un buffer puede
contener, sobrescribiendo memoria adyacente.

:::{code-block}c
:linenos:
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
}

:::
<!-- {code-block}c -->

En el stack, un atacante puede sobrescribir la dirección de retorno para
ejecutar código arbitrario:

:::{figure} 5/buffer_overflow.svg
:name: fig-buffer-overflow
:width: 100%

Visualización de buffer overflow en el stack: antes del overflow el buffer tiene
su espacio asignado y la dirección de retorno está protegida; después del
overflow, datos excesivos (representados como 'A') sobrescriben el buffer, los
datos intermedios, y finalmente corrompen la dirección de retorno, permitiendo
potencialmente la ejecución de código malicioso.

:::
<!-- {figure} 1/buffer_overflow.svg -->

**Use-After-Free (UAF):**

Usar memoria después de liberarla puede permitir que un atacante controle datos
críticos:

:::{code-block}c
:linenos:
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();
}

:::
<!-- {code-block}c -->

**Double Free:**

Liberar memoria dos veces puede corromper las estructuras internas del
allocator, permitiendo ataques sofisticados:

:::{code-block}c
:linenos:
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!

:::
<!-- {code-block}c -->

(estrategias-defensivas)=
#### Estrategias Defensivas

**1. Principio de mínimo privilegio:** No uses más memoria de la que necesitás,
y no la mantengas asignada más tiempo del necesario.

**2. Verificación exhaustiva:**

:::{code-block}c
:linenos:
// 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 */ }

:::
<!-- {code-block}c -->

**3. Inicialización defensiva:**

:::{code-block}c
:linenos:
// 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

:::
<!-- {code-block}c -->

**4. Encapsulación:** Ocultá la gestión de memoria detrás de funciones:

:::{code-block}c
:linenos:
// 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

:::
<!-- {code-block}c -->

**5. Usar funciones seguras:**

:::{code-block}c
:linenos:
// 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

:::
<!-- {code-block}c -->

:::{important} La Seguridad No Es Opcional

En el desarrollo profesional, los errores de memoria no son solo bugs molestos:
son **vulnerabilidades de seguridad** que pueden ser explotadas. Cada uno de los
errores discutidos (buffer overflow, UAF, double free) ha sido la base de
ataques reales en sistemas de producción.

Escribir código memory-safe no es solo seguir buenas prácticas: es una
responsabilidad ética. Tu código podría procesar datos sensibles, ejecutarse en
infraestructura crítica, o estar expuesto a atacantes motivados. La seguridad
debe ser parte del diseño desde el principio, no un añadido posterior.

:::
<!-- {important} La Seguridad No Es Opcional -->

(ejercicios-de-autoevaluacion-seguridad-de-memoria)=
#### Ejercicios de Autoevaluación (Seguridad de Memoria)








(ejemplo-integrador-arreglo-dinamico-de-tamano-fijo)=
### 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.

:::{code-block}c
:linenos:
#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 Doble puntero al arreglo a destruir.
* @post Toda la memoria del arreglo es liberada y el puntero se anula.
*/
void destruir_arreglo(arreglo_t **arreglo)
{
 if (arreglo != NULL && *arreglo != NULL)
 {
     if ((*arreglo)->datos != NULL)
     {
         free((*arreglo)->datos);
         (*arreglo)->datos = NULL;
     }
     free(*arreglo);
     *arreglo = NULL;
 }
}

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;
}

:::
<!-- {code-block}c -->

:::{note} Análisis del Ejemplo

Este ejemplo integra múltiples buenas prácticas:

- Inicialización de punteros a `NULL` ({ref}`0x0003h`)
- Verificación de todas las asignaciones de memoria ({ref}`0x3001h`)
- Uso de `calloc` para inicialización automática a cero
- Uso de `sizeof(*puntero)` ({ref}`0x300Bh`)
- Simetría con `crear_arreglo()` y `destruir_arreglo()` ({ref}`0x3002h`)
- Documentación completa de funciones ({ref}`0x000Ah`)
- Uso de `const` para parámetros no modificados ({ref}`0x3007h`)
- Uso de `size_t` para tamaños e índices ({ref}`0x3010h`)
- Verificación de límites antes de acceder a elementos ({ref}`0x300Ch`) 

:::
<!-- {note} Análisis del Ejemplo -->


(conceptos-avanzados-y-rendimiento-de-bajo-nivel)=
### Conceptos Avanzados y Rendimiento de Bajo Nivel


En esta sección se presentan detalles técnicos complementarios sobre la
ejecución y la jerarquía de hardware, orientados a comprender el rendimiento
real de los programas.

(funcionamiento-de-la-pila-en-ensamblador-x86-64)=
#### Funcionamiento de la Pila en Ensamblador (x86-64)

A nivel de arquitectura de hardware, la pila se gestiona a través de registros
del procesador. En la arquitectura x86-64:
- El registro `rsp` (*Stack Pointer*) apunta al tope actual de la pila.
- El registro `rbp` (*Base Pointer* o *Frame Pointer*) apunta al inicio del
marco de pila de la función en ejecución.

A continuación se muestra cómo se ve un prólogo y epílogo típico de una función
en código ensamblador simplificado:

```{code-block} asm
:linenos:
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

1
int *ptr = NULL;

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

1
free(ptr);

1
2
free(ptr);
ptr = NULL;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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);
    }
}

1
2
3
4
5
6
7
8
/**
 * 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);

1
2
3
4
5
6
7
8
void imprimir_arreglo(const int *arreglo, size_t tamano)
{
    for (size_t i = 0; i < tamano; i++)
    {
        printf("%d ", arreglo[i]);
    }
    printf("\n");
}

1
2
3
4
5
// Preferido
int *ptr = malloc(n * sizeof(*ptr));

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

1
2
3
4
5
6
7
size_t tamano = 10;
int *arreglo = malloc(tamano * sizeof(*arreglo));

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

1
2
3
4
5
6
7
void establecer_elemento(int *arreglo, size_t tamano, size_t indice, int valor)
{
    if (indice < tamano)
    {
        arreglo[indice] = valor;
    }
}