Volver al blog

Punteros en C explicados desde cero: memoria, arrays, malloc y 6 ejercicios resueltos

Punteros en C explicados desde cero: memoria, arrays, malloc y 6 ejercicios resueltos

Un puntero en C es una variable que guarda la dirección de memoria de otra variable. En lugar de guardar un 7, guarda "dónde está el 7". Con esa dirección puedes leer y modificar el dato original desde cualquier parte del programa, recorrer arrays, reservar memoria mientras el programa se ejecuta y construir listas enlazadas o árboles.

Es el tema que más alumnos atasca en Fundamentos de Programación, en Estructuras de Datos y en cualquier asignatura de C de Ingeniería Informática, Telecomunicaciones o Industriales. No porque sea difícil en sí, sino porque casi nunca se explica dibujando la memoria. En esta guía lo hacemos así: con cajas, direcciones y flechas, código que puedes compilar y seis ejercicios resueltos con el resultado exacto que debe salirte.

Resumen rápido

Expresión Qué significa Ejemplo
int *p; Declara p como puntero a int p aún no apunta a nada válido
&x Dirección de la variable x p = &x;
*p El valor que hay en la dirección guardada en p *p = 5; cambia x
p->campo Campo de la estructura apuntada por p Equivale a (*p).campo
v[i] Elemento i del array Equivale a *(v + i)
NULL Puntero que no apunta a nada Hay que comprobarlo antes de usar *p
malloc / free Reservar y liberar memoria dinámica Cada malloc necesita su free

Si solo te quedas con una idea: & saca la dirección y * sigue la dirección. Todo lo demás se construye sobre eso.

Qué es un puntero, dibujado

Cada variable ocupa un sitio en la memoria y ese sitio tiene una dirección, igual que una casa tiene un número en la calle. Mira este código:

#include <stdio.h>

int main(void) {
    int edad = 20;
    int *p = &edad;

    printf("%d %d\n", edad, *p);   // 20 20

    *p = 21;
    printf("%d\n", edad);          // 21
    return 0;
}

En memoria pasa esto (las direcciones son inventadas, pero la idea es exactamente esta):

Variable Dirección Contenido
edad 0x1000 20 → después 21
p 0x2000 0x1000 (la dirección de edad)
  • p es una variable normal con su propia dirección (0x2000). Lo especial es lo que guarda: otra dirección.
  • *p significa "ve a la dirección que guarda p y trabaja con lo que hay allí". Por eso *p = 21 cambia edad aunque en esa línea no aparezca edad.
  • El tipo importa: int *p dice que en esa dirección hay un int. Así el compilador sabe cuántos bytes leer y cuánto avanzar al hacer p + 1.

Los tres significados del asterisco

La mitad de la confusión con los punteros viene de que * significa tres cosas distintas según dónde aparece:

  1. En una declaración, int *p; dice "p es un puntero a int". No accede a nada.
  2. En una expresión, *p es desreferenciar: acceder al valor apuntado.
  3. Entre dos números, a * b es una multiplicación de toda la vida.

Por eso int *p = &edad; es correcto (declaras p y le das la dirección de edad), y en cambio *p = &edad; después de declararlo es un error: intentas guardar una dirección en el int apuntado.

Un detalle que cae en examen: en int *a, b; solo a es un puntero; b es un int. El asterisco va con el nombre, no con el tipo. Si quieres dos punteros, int *a, *b;.

Para qué sirven los punteros

En los ejercicios de clase parece que los punteros complican cosas que se podían hacer sin ellos. En C no hay alternativa para cuatro cosas:

  1. Que una función modifique variables de quien la llama (paso por referencia).
  2. Pasar arrays a funciones, porque en C un array siempre se pasa como un puntero a su primer elemento.
  3. Reservar memoria cuyo tamaño no conoces al compilar, con malloc.
  4. Construir estructuras enlazadas: listas, pilas, colas, árboles y grafos, donde cada nodo apunta al siguiente.

Paso por referencia: el ejemplo de intercambiar dos variables

En C los argumentos se pasan por valor: la función recibe una copia. Por eso esta función no hace nada útil:

void intercambiar_mal(int a, int b) {
    int aux = a;
    a = b;
    b = aux;        // intercambia las copias, no las originales
}

Si quieres que la función cambie las variables originales, tienes que pasarle dónde están:

void intercambiar(int *a, int *b) {
    int aux = *a;
    *a = *b;
    *b = aux;
}

int main(void) {
    int x = 3, y = 7;

    intercambiar_mal(x, y);
    printf("x=%d y=%d\n", x, y);   // x=3 y=7

    intercambiar(&x, &y);
    printf("x=%d y=%d\n", x, y);   // x=7 y=3
    return 0;
}

Fíjate en las dos mitades: la función declara int * en los parámetros y usa *a, y quien la llama pasa &x. Si olvidas cualquiera de las dos, el compilador te avisa con un warning de tipos incompatibles. No ignores ese warning: casi siempre es exactamente este fallo.

Es lo mismo que hace scanf("%d", &n): necesita la dirección de n para poder escribir dentro.

Punteros y arrays

El nombre de un array, usado en una expresión, se convierte en un puntero a su primer elemento. De ahí sale la regla que lo explica todo:

v[i] es exactamente lo mismo que *(v + i).

int v[5] = {10, 20, 30, 40, 50};
int *q = v;                       // igual que q = &v[0]

printf("%d %d %d %d\n", v[2], *(v + 2), q[2], *(q + 2));   // 30 30 30 30

q++;
printf("%d\n", *q);               // 20

Aritmética de punteros

q + 1 no suma un byte: avanza un elemento. Si q es un int * y un int ocupa 4 bytes, q + 1 está 4 bytes más adelante. Por eso el tipo del puntero es importante.

Operaciones válidas con punteros que apuntan al mismo array:

  • Sumar o restar un entero: p + 3, p--.
  • Restar dos punteros: fin - ini da cuántos elementos hay entre ellos.
  • Compararlos: ini < fin.

Sumar dos punteros no tiene sentido y no compila.

La trampa de sizeof en una función

Un array no es exactamente un puntero, y esto se ve con sizeof:

void tam(int v[]) {
    printf("en funcion: %zu\n", sizeof(v));   // 8 en un sistema de 64 bits
}

int main(void) {
    int v[5] = {10, 20, 30, 40, 50};
    printf("main: %zu\n", sizeof(v));         // 20 (5 enteros de 4 bytes)
    tam(v);
    return 0;
}

Dentro de la función, int v[] es en realidad int *v, así que sizeof devuelve el tamaño de un puntero, no del array. Por eso todas las funciones que reciben un array en C reciben también su tamaño: void mostrar(const int *v, int n). El const indica que la función solo lee el array y no lo modifica.

Cadenas y punteros

En C una cadena es un array de char que termina en '\0'. Hay dos formas de declararla que parecen iguales y no lo son:

char a[] = "hola";    // array de 5 char en la pila: puedes modificarlo
char *b = "hola";     // puntero a un literal: NO puedes modificarlo

a[0] = 'H';           // correcto
b[0] = 'H';           // comportamiento indefinido: suele dar segmentation fault

a es un array propio con una copia del texto. b apunta a un literal que suele estar en memoria de solo lectura. La forma correcta de escribir la segunda es const char *b = "hola";, y así el compilador te avisa si intentas modificarla.

Otras dos reglas que evitan la mayoría de fallos con cadenas:

  • Una palabra de 5 letras necesita 6 posiciones por el '\0'.
  • Las cadenas no se comparan con ==: eso compara direcciones. Se usa strcmp(a, b) == 0. Tampoco se asignan con =: se copian con strcpy o, mejor, con snprintf o strncpy indicando el tamaño.

Memoria dinámica: malloc y free

Un array normal tiene un tamaño fijo al compilar. Cuando el tamaño depende de lo que introduce el usuario o de un fichero, se reserva memoria en tiempo de ejecución en el heap:

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

int main(void) {
    int n;
    printf("¿Cuántas notas? ");
    if (scanf("%d", &n) != 1 || n <= 0) return 1;

    double *notas = malloc(n * sizeof *notas);
    if (notas == NULL) {
        printf("No hay memoria suficiente\n");
        return 1;
    }

    double suma = 0;
    for (int i = 0; i < n; i++) {
        scanf("%lf", &notas[i]);
        suma += notas[i];
    }
    printf("Media: %.2f\n", suma / n);

    free(notas);
    notas = NULL;
    return 0;
}

Las cinco reglas de malloc:

  1. malloc recibe bytes, no elementos. Por eso se multiplica por sizeof. Escribir sizeof *notas en vez de sizeof(double) tiene una ventaja: si mañana cambias el tipo, la reserva sigue siendo correcta.
  2. Comprueba siempre si devuelve NULL. Muchos profesores quitan puntos si no lo haces.
  3. La memoria de malloc no está inicializada. Contiene basura. Si necesitas ceros, usa calloc(n, sizeof *notas).
  4. Cada malloc tiene exactamente un free. Ni cero (fuga de memoria) ni dos (double free).
  5. Después de free, el puntero sigue guardando la dirección antigua. Asignarle NULL evita usarlo por error.

Para cambiar el tamaño de un bloque se usa realloc, y siempre a través de un puntero auxiliar: si falla y devuelve NULL, no pierdes el bloque original.

int *tmp = realloc(v, nuevo_n * sizeof *v);
if (tmp == NULL) {
    // v sigue siendo válido: decide qué hacer
} else {
    v = tmp;
}

Punteros a estructuras: el operador ->

Con estructuras grandes es habitual pasar un puntero en lugar de una copia. Para acceder a un campo a través de un puntero se usa ->:

typedef struct {
    char nombre[30];
    double nota;
} Alumno;

void aprobar(Alumno *a) {
    if (a->nota < 5) a->nota = 5;     // a->nota es lo mismo que (*a).nota
}

int main(void) {
    Alumno al = {"Pau", 4.2};
    aprobar(&al);
    printf("%s %.1f\n", al.nombre, al.nota);   // Pau 5.0
    return 0;
}

Los paréntesis de (*a).nota son obligatorios porque . tiene más prioridad que *. *a.nota intentaría desreferenciar el campo nota, que no es un puntero. El operador -> existe precisamente para no tener que escribir esos paréntesis.

Puntero a puntero: cuándo hace falta **

La regla es la misma que con intercambiar: si una función tiene que modificar una variable de quien la llama, recibe su dirección. Si esa variable ya es un puntero, la función recibe la dirección de un puntero: un **.

El caso típico es una función que cambia la cabeza de una lista enlazada o que reserva memoria para el puntero de quien llama. Lo verás en el ejercicio 6.

Los 7 errores con punteros que provocan fallos de segmentación

Un segmentation fault significa que el programa ha accedido a memoria que no le pertenece. Casi siempre es uno de estos:

  1. Puntero sin inicializar. int *p; *p = 5; escribe en una dirección aleatoria. Inicializa siempre: int *p = NULL;.

  2. Desreferenciar NULL. Pasa cuando malloc falla o cuando recorres una lista sin comprobar n != NULL.

  3. Devolver la dirección de una variable local. La variable desaparece al terminar la función y el puntero queda colgando:

    int *crear(void) {
        int x = 10;
        return &x;      // MAL: x deja de existir al salir
    }
    

    Si la función tiene que devolver memoria nueva, reserva con malloc y que quien la llama haga el free.

  4. Usar memoria después de free. El dato puede seguir ahí "por casualidad" y el fallo aparece más tarde en otro sitio.

  5. Liberar dos veces el mismo bloque, o liberar algo que no viene de malloc.

  6. Salirse del array. C no comprueba límites: v[5] en un array de 5 elementos pisa otra variable sin avisar.

  7. Olvidar el '\0' al construir una cadena a mano. printf y strlen siguen leyendo hasta encontrar un cero en algún sitio.

Cómo encontrarlos en minutos y no en horas

  • Compila siempre con avisos: gcc -Wall -Wextra -g programa.c -o programa. Muchos de estos errores ya salen como warning.
  • Añade AddressSanitizer: gcc -Wall -Wextra -g -fsanitize=address programa.c -o programa. Al ejecutar te dice la línea exacta del acceso inválido, dónde se reservó la memoria y dónde se liberó.
  • En Linux, valgrind ./programa detecta lecturas inválidas y fugas de memoria, que es lo que suelen comprobar los correctores automáticos de prácticas.
  • Con gdb (o el depurador de tu IDE), ejecuta paso a paso y mira el valor de cada puntero. Tienes el método en cómo depurar código paso a paso.

Ejercicios de punteros resueltos

Intenta cada ejercicio antes de mirar la solución. En los dos primeros, dibuja las cajas de la memoria en un papel: es exactamente lo que te pedirán en un examen en papel. Todo el código está probado con gcc y AddressSanitizer.

Ejercicio 1: ¿qué imprime?

int a = 5, b = 10;
int *p1 = &a, *p2 = &b;

*p1 = *p2 + 1;
p1 = p2;
*p1 = 0;

printf("a=%d b=%d\n", a, b);

Solución: a=11 b=0.

  • *p1 = *p2 + 1 → en la dirección de a se guarda 10 + 1. Ahora a vale 11.
  • p1 = p2 → sin asterisco: no cambia ningún entero, cambia hacia dónde apunta p1. Ahora los dos apuntan a b.
  • *p1 = 0 → como p1 apunta a b, b vale 0.

La clave es distinguir entre cambiar el puntero (p1 = ...) y cambiar lo apuntado (*p1 = ...).

Ejercicio 2: ¿qué imprime? (aritmética de punteros)

int w[] = {4, 8, 15, 16, 23};
int *r = w + 1;

printf("%d %d %d\n", *r, *(r + 2), r[-1]);
printf("%d\n", *r++);
printf("%d\n", *r);
printf("%d\n", ++*r);
printf("%d\n", w[2]);

Solución:

8 16 4
8
15
16
16
  • r apunta a w[1], así que *r es 8, *(r + 2) es w[3] = 16 y r[-1] es w[0] = 4. Los índices negativos son válidos mientras no te salgas del array.
  • *r++ se lee como *(r++): devuelve el valor actual (8) y después avanza el puntero a w[2].
  • *r ahora es 15.
  • ++*r se lee como ++(*r): incrementa el valor apuntado, no el puntero. w[2] pasa a ser 16 y se imprime 16.

*r++ y ++*r son de las preguntas favoritas de examen precisamente porque se parecen mucho y hacen cosas distintas.

Ejercicio 3: mínimo y máximo con parámetros de salida

Enunciado. Escribe una función que reciba un array y su tamaño y "devuelva" a la vez el mínimo y el máximo.

void minmax(const int *v, int n, int *min, int *max) {
    *min = v[0];
    *max = v[0];
    for (int i = 1; i < n; i++) {
        if (v[i] < *min) *min = v[i];
        if (v[i] > *max) *max = v[i];
    }
}

int main(void) {
    int datos[] = {7, -2, 15, 0, 9};
    int mn, mx;
    minmax(datos, 5, &mn, &mx);
    printf("min=%d max=%d\n", mn, mx);   // min=-2 max=15
    return 0;
}

Una función en C solo puede devolver un valor con return. Cuando necesitas devolver varios, se usan parámetros de salida: punteros donde la función escribe los resultados. Fíjate en que el mínimo y el máximo se inicializan con v[0] y no con 0: con un array de negativos, empezar en 0 daría un máximo incorrecto.

Ejercicio 4: invertir un array con dos punteros

Enunciado. Invierte un array en el mismo sitio, sin usar índices ni un array auxiliar.

void invertir(int *v, int n) {
    int *ini = v;
    int *fin = v + n - 1;
    while (ini < fin) {
        int aux = *ini;
        *ini = *fin;
        *fin = aux;
        ini++;
        fin--;
    }
}

Con {7, -2, 15, 0, 9} el resultado es {9, 0, 15, -2, 7}. El último elemento está en v + n - 1, no en v + n: esa posición ya está fuera del array. La condición ini < fin compara direcciones y para cuando los punteros se cruzan, tanto si n es par como impar.

Ejercicio 5: tu propio strlen

Enunciado. Calcula la longitud de una cadena sin usar strlen ni índices.

size_t mi_strlen(const char *s) {
    const char *p = s;
    while (*p != '\0') {
        p++;
    }
    return p - s;
}

mi_strlen("punteros") devuelve 8 y mi_strlen("") devuelve 0. Se avanza un puntero hasta el '\0' y se restan las dos direcciones: la resta de punteros da el número de elementos entre ellos. Es la misma idea que usa la biblioteca estándar.

Ejercicio 6: array dinámico y lista enlazada

Enunciado A. Escribe una función que reciba un array de enteros y devuelva un array nuevo con solo los pares, indicando cuántos hay.

int *filtrar_pares(const int *v, int n, int *n_pares) {
    int cuenta = 0;
    for (int i = 0; i < n; i++) {
        if (v[i] % 2 == 0) cuenta++;
    }
    *n_pares = cuenta;
    if (cuenta == 0) return NULL;

    int *res = malloc(cuenta * sizeof *res);
    if (res == NULL) {
        *n_pares = 0;
        return NULL;
    }

    int j = 0;
    for (int i = 0; i < n; i++) {
        if (v[i] % 2 == 0) res[j++] = v[i];
    }
    return res;
}

Con {3, 8, 5, 12, 6, 7} devuelve {8, 12, 6} y n_pares vale 3. Se recorre dos veces: una para contar y saber cuánto reservar, otra para copiar. Quien llama a la función es responsable de hacer free del array devuelto, y eso debe quedar claro en un comentario.

Enunciado B. Inserta un valor al principio de una lista enlazada.

typedef struct Nodo {
    int valor;
    struct Nodo *sig;
} Nodo;

int insertar_inicio(Nodo **cabeza, int valor) {
    Nodo *nuevo = malloc(sizeof *nuevo);
    if (nuevo == NULL) return 0;
    nuevo->valor = valor;
    nuevo->sig = *cabeza;
    *cabeza = nuevo;
    return 1;
}

void liberar_lista(Nodo **cabeza) {
    Nodo *actual = *cabeza;
    while (actual != NULL) {
        Nodo *sig = actual->sig;   // guardar ANTES de liberar
        free(actual);
        actual = sig;
    }
    *cabeza = NULL;
}

int main(void) {
    Nodo *lista = NULL;
    insertar_inicio(&lista, 3);
    insertar_inicio(&lista, 2);
    insertar_inicio(&lista, 1);

    for (Nodo *n = lista; n != NULL; n = n->sig) {
        printf("%d -> ", n->valor);
    }
    printf("NULL\n");               // 1 -> 2 -> 3 -> NULL

    liberar_lista(&lista);
    return 0;
}

Aquí aparece el **. La función tiene que cambiar la variable lista del main (la cabeza pasa a ser el nodo nuevo), y lista ya es un Nodo *. Si la función recibiera Nodo *cabeza, cambiaría su copia y en el main la lista seguiría vacía. Al liberar, hay que guardar actual->sig antes del free: leerlo después sería usar memoria liberada (error 4 de la lista).

Si quieres seguir con pilas, colas y árboles, tienes la continuación en estructuras de datos en la universidad.

Cómo estudiar punteros para el examen

Dibuja la memoria siempre. Una caja por variable, su contenido dentro y una flecha desde cada puntero hasta lo que apunta. Si al acabar un ejercicio tu dibujo y la salida del programa coinciden, lo has entendido. Si no, el dibujo te dice exactamente dónde está la confusión.

Lee las declaraciones en voz alta. int *p es "p es un puntero a int". Nodo **cabeza es "cabeza es un puntero a un puntero a Nodo". Si no sabes leer la declaración, no vas a saber usarla.

Practica sin compilador. Si el examen es en papel, haz los ejercicios de "¿qué imprime?" a mano y después compruébalos compilando. Tienes más estrategias para el día D en cómo preparar un examen práctico de programación.

Compila siempre con -Wall -Wextra -fsanitize=address mientras estudias. Los avisos te enseñan más que cualquier apunte.

Cuándo pedir ayuda

Vas bien si haces los seis ejercicios sin mirar la solución y sabes explicar por qué en el último hace falta **. Merece la pena pedir ayuda cuando:

  • Entiendes la teoría pero, delante de un ejercicio, no sabes si poner *, & o nada.
  • Tu práctica da segmentation fault y llevas horas sin encontrar la línea.
  • Ya estás en listas, árboles o memoria dinámica y los punteros simples todavía te generan dudas.
  • Tienes el examen o la entrega cerca y no sabes qué priorizar.

En nuestras clases particulares de C y C++ online hacemos justo lo que explica esta guía: dibujamos la memoria de tu programa, lo seguimos con el depurador línea a línea y trabajamos con tus prácticas y tus exámenes de otros años hasta que los punteros dejan de ser una caja negra. Si estudias una carrera, lo adaptamos al temario de tu asignatura en las clases de programación para la universidad. Son clases uno a uno por videollamada a 25 € la hora, sin matrícula ni permanencia.

Preguntas frecuentes

¿Qué es un puntero en C en pocas palabras?

Una variable que guarda la dirección de memoria de otra variable. Con &x obtienes la dirección de x y con *p accedes al valor que hay en la dirección guardada en p.

¿Cuál es la diferencia entre * y & en C?

& obtiene la dirección de una variable y * hace lo contrario: a partir de una dirección, accede al valor. Son operaciones inversas: *&x es lo mismo que x. Además, en una declaración como int *p, el asterisco solo indica que p es un puntero.

¿Por qué mi programa da "segmentation fault"?

Porque accede a memoria que no le pertenece. Las causas más habituales son un puntero sin inicializar, desreferenciar NULL, salirse de un array, usar memoria después de free o devolver la dirección de una variable local. Compila con -g -fsanitize=address y el programa te dirá la línea exacta.

¿Un array es un puntero?

No exactamente. El nombre de un array se convierte en un puntero a su primer elemento casi siempre que lo usas, y por eso v[i] equivale a *(v + i). Pero un array tiene un tamaño fijo y no se le puede asignar otra dirección. La diferencia se nota con sizeof: en el array da el tamaño total y en un puntero da el tamaño de una dirección.

¿Cuándo tengo que usar malloc?

Cuando el tamaño de los datos no se conoce al compilar (depende del usuario o de un fichero), cuando los datos tienen que seguir existiendo después de que termine la función que los crea, o cuando construyes estructuras enlazadas nodo a nodo. Para un array pequeño de tamaño fijo, un array normal es más simple y más seguro.

¿Qué diferencia hay entre punteros en C y referencias en C++?

Una referencia de C++ (int &r = x;) es un alias de una variable: siempre está ligada a algo válido, no puede ser nula y no se reasigna. Un puntero puede ser NULL, cambiar de dirección y usarse con aritmética. En C++ se usan referencias para el paso por referencia y punteros (mejor inteligentes, como std::unique_ptr) para la memoria dinámica. Si estudias C++, la base de esta guía te sirve igual.

¿Los punteros se usan en otros lenguajes?

Java, Python o JavaScript no te dejan manejar direcciones, pero por debajo trabajan con referencias: cuando pasas un objeto a un método en Java, lo que se copia es una referencia. Entender los punteros en C hace que entiendas por qué modificar un objeto dentro de un método en Java cambia el original. Lo verás en programación orientada a objetos explicada.

WhatsApp