Punteros y direcciones de memoria en C

La memoria puede representarse como una secuencia de bytes numerados. Cada número es una dirección. Un objeto como un int ocupa bytes consecutivos y su dirección identifica su primer byte. El nombre que utilizas en el código fuente permite al compilador encontrar ese objeto; el lenguaje no exige que se almacene una etiqueta con el nombre junto a su valor.

Medir el almacenamiento con sizeof

sizeof indica los bytes y produce un valor size_t. Utiliza %zu para imprimirlo:

int scores[4] = {12, 18, 15, 21};
printf("%zu %zu\n", sizeof scores, sizeof scores[0]);

Con valores int de 4 bytes, esto imprime 16 4. El primer resultado mide los cuatro elementos; el segundo mide uno. sizeof(char) siempre es 1. Una disposición habitual en equipos de escritorio de 64 bits utiliza valores int de 4 bytes, valores double de 8 bytes y punteros a objetos de 8 bytes. Otros sistemas pueden diferir. Incluso entre sistemas de 64 bits, long suele ocupar 8 bytes en Linux y macOS, pero 4 en Windows.

El tamaño del almacenamiento y la longitud del texto responden a preguntas distintas. Para char word[20] = "hi";, sizeof word es 20, mientras que strlen(word) es 2. El array sigue conteniendo 20 elementos aunque su cadena utilice solo dos letras y un terminador. Salvo en los arrays de longitud variable, estos tamaños de objeto se fijan en tiempo de compilación.

Seguir las direcciones de un array

Las direcciones hexadecimales utilizan los dígitos de 0 a 9 y luego de a a f. El prefijo 0x indica la base 16. Para un array ilustrativo que comienza en 0x1000, cuatro elementos de 4 bytes comienzan en:

0x100C es 4108 en decimal, doce bytes después de 0x1000. Los elementos de un array no tienen espacios entre ellos. No se garantiza el orden ni la separación de las variables declaradas por separado; las direcciones reales impresas también pueden cambiar entre ejecuciones. Un compilador puede mantener un valor en un registro del procesador cuando no se necesita almacenamiento con dirección.

Alineación y orden de los bytes

La alineación restringe dónde pueden comenzar los objetos de un tipo. Una disposición habitual sitúa los valores int de 4 bytes en múltiplos de 4 y los valores double de 8 bytes en múltiplos de 8. El compilador proporciona una alineación adecuada para los objetos declarados.

El orden de los bytes es el orden de los bytes dentro de un valor de varios bytes. Para un unsigned int de 4 bytes que contiene 0x12345678, el almacenamiento con el byte menos significativo primero tiene los bytes 78 56 34 12 de las direcciones menores a las mayores; el almacenamiento con el byte más significativo primero tiene 12 34 56 78. Un unsigned char * puede examinar la representación de un objeto byte a byte. El orden de los bytes no cambia el orden de los índices del array.

Mantener el objeto activo

Una variable local ordinaria tiene duración automática del almacenamiento: su tiempo de vida dura mientras se ejecuta su bloque. Las implementaciones típicas mantienen esos objetos en el marco de pila de una llamada y reutilizan ese almacenamiento después. Las variables globales, las variables static y los literales de cadena duran todo el programa. Guardar una dirección no prolonga el tiempo de vida de su objeto.

Un puntero almacena una dirección y tiene un tipo que describe el objeto al que puede acceder. Declarar un int * te proporciona almacenamiento para un puntero; no crea un int que ese puntero pueda utilizar. Da al puntero un valor conocido cuando lo declares.

Obtener la dirección de un objeto

int count = 42;
int *p = &count;

El operador de obtención de dirección unario & obtiene la dirección de count. Si count comienza en la dirección ilustrativa 0x1000, p contiene 0x1000, mientras que count contiene 42. El puntero también es un objeto: &p es la dirección del almacenamiento independiente que contiene ese puntero.

Puedes obtener la dirección de un elemento de un array, como &scores[2]. Una constante numérica o el resultado de un cálculo no es un objeto almacenado cuya dirección puedas obtener de esta forma: &42 y &(count + 1) no son válidos. La expresión binaria a & b utiliza el mismo símbolo para la operación AND a nivel de bits; el número de operandos indica de qué operación se trata.

Interpretar cada declarador

Los caracteres en blanco no cambian ninguno de estos tipos. int* p e int *p son equivalentes. Declarar un puntero por línea hace más difícil pasar por alto su asterisco. En equipos de escritorio habituales de 64 bits, un puntero a objeto ocupa 8 bytes, pero su propio tamaño no indica el tamaño del objeto al que apunta.

El tipo apuntado importa. Para double price = 9.5;, utiliza double *r = &price;. Inicializar un int * con &price produce un mensaje de diagnóstico por punteros incompatibles. Una conversión explícita que oculte el mensaje no hace válido el acceso a ese double como int: el tipo determina cómo se accede a los bytes almacenados.

Redirigir un puntero

int a = 5, b = 8;
int *p = &a;
p = &b;

La última asignación reemplaza la dirección en p. No mueve ninguno de los enteros ni copia el valor de uno en el otro. Ahora p apunta a b; a sigue siendo 5 y b sigue siendo 8. Varias variables de tipo puntero también pueden almacenar la misma dirección.

Utilizar un estado vacío conocido

Un puntero local sin inicializar tiene un valor indeterminado, y a veces se llama puntero indeterminado. No lo examines ni lo desreferencies. Inicialízalo con la dirección de un objeto válido o con NULL, disponible en cabeceras como <stddef.h> y <stdio.h>:

int *pending = NULL;
if (pending == NULL) {
    pending = &count;
}

Un puntero nulo no designa ningún objeto. !pending es otra prueba de nulidad. Estas pruebas solo tienen sentido para punteros inicializados; no validan una dirección arbitraria ni un puntero cuyo objeto ha dejado de existir.

Imprimir un puntero a objeto

printf("%p\n", (void *)p);

%p espera un void *, así que proporciona la conversión explícita cuando utilices un puntero a objeto con un tipo concreto. La implementación elige su representación impresa, que suele ser hexadecimal. %d y %x esperan argumentos enteros de tipos determinados y no pueden utilizarse como sustitutos de %p.

El operador de desreferenciación unario * sigue un puntero hasta su objeto. Si p apunta a x, *p designa el propio x. Leer *p lee ese objeto; asignar un valor a *p lo modifica.

Seguir una escritura mediante una dirección

int x = 10;
int *p = &x;
*p = *p + 5;
int y = *p * 2;
printf("%d %d %d\n", x, *p, y);

Primero p almacena la dirección de x. En el lado derecho de la asignación, *p lee 10. Al sumar 5 se obtiene 15, y el *p del lado izquierdo almacena 15 en x. La siguiente línea multiplica el valor actualizado por 2, por lo que y pasa a ser 30. La salida es 15 15 30.

El contexto distingue los asteriscos: int *p declara un puntero, el *p unario accede a un objeto y *p * 2 también contiene una multiplicación binaria. Para un objeto válido x, *&x designa x; para un puntero a un objeto válido, &*p devuelve el valor del puntero.

Distinguir las direcciones del contenido

Comienza cada traza con dos filas de información: qué dirección contiene cada puntero y qué valor contiene cada entero. Supón que p apunta a a, que contiene 3, y q apunta a b, que contiene 8.

Un diagrama de memoria utiliza una caja para cada objeto. Etiqueta una caja con su nombre y dirección, coloca dentro su valor actual y dibuja una flecha desde un puntero hasta su destino. Una asignación de dirección mueve una flecha; una asignación al objeto apuntado cambia el contenido de la caja de destino.

Después de p = q, los punteros son alias de b. Si luego ejecutas *p = 20;, leer *q o b da 20. Copiar una dirección crea otra vía hacia el mismo objeto, no otro entero.

Comprobar que una desreferenciación es válida

Un puntero utilizado para acceder debe designar un objeto existente de un tipo adecuado, y escribir también requiere un objeto modificable. Los punteros nulos no designan ningún objeto. Los punteros sin inicializar no tienen un destino conocido que se pueda utilizar. Un puntero queda colgante cuando termina el tiempo de vida de su destino.

Acceder mediante un puntero no válido es comportamiento indefinido: C no impone requisitos sobre el resultado. El programa puede detenerse con un fallo de segmentación, corromper datos o parecer que se ejecuta normalmente. Una ejecución aparentemente correcta no demuestra que el acceso fuera válido.

Para un puntero que puede ser nulo legítimamente, compruébalo antes de acceder:

if (p != NULL) {
    *p = 0;
}

Asignar NULL a un puntero que ya no necesitas puede evitar que esa variable se utilice por accidente más adelante. No restablece otros alias. Lleva por separado el control del tiempo de vida del objeto.

Poner paréntesis alrededor del valor deseado

El ++ posfijo tiene mayor precedencia que el * unario. Por tanto, *p++ significa *(p++): utiliza el valor anterior del puntero para acceder a un valor y avanza el puntero. (*p)++ incrementa el valor apuntado y deja el puntero en su lugar. *p + 1 lee el valor y suma 1 sin almacenar el resultado. Son tres acciones distintas.

C pasa todos los argumentos por valor. Un parámetro es una variable local inicializada a partir del argumento. Pasar una dirección no cambia esa regla: la función recibe una copia de la dirección y esa copia puede acceder al objeto de la función llamadora.

Comparar dos funciones de restablecimiento

void reset_copy(int n) {
    n = 0;
}

void reset(int *n) {
    *n = 0;
}

Para int score = 12;, reset_copy(score) cambia solo su n local. score sigue siendo 12. La llamada reset(&score) copia la dirección de score en el parámetro de tipo puntero n; asignar después un valor a *n cambia score a 0. Esta técnica suele llamarse paso por referencia, aunque el paso real de argumentos del lenguaje sigue siendo por valor.

La dirección en la llamada y la desreferenciación en el cuerpo cumplen funciones distintas. &score indica a la función dónde está el objeto. *n = 0 le indica qué almacenar allí. Llamar a reset(score) proporciona un entero donde se requiere un puntero y provoca un mensaje de diagnóstico del compilador.

Analizar un intercambio

void swap(int *a, int *b) {
    int t = *a;
    *a = *b;
    *b = t;
}

/* Inside a calling function: */
int x = 3, y = 8;
swap(&x, &y);

1. a apunta a x y b apunta a y.
2. t guarda el valor original de x, que es 3.
3. *a = *b escribe 8 en x.
4. *b = t escribe el 3 guardado en y.

Ambas variables de la función llamadora cambian. Una versión que recibe int a, int b normales solo intercambia copias. Una versión con punteros que hace int *t = a; a = b; b = t; tampoco intercambia los enteros: solo redirige los parámetros locales de tipo puntero.

Entregar más de un resultado

Una sentencia de retorno proporciona un valor, pero los parámetros de tipo puntero pueden llevar resultados adicionales:

void divide(int total, int size, int *q, int *r) {
    *q = total / size;
    *r = total % size;
}

/* size must be positive for these example inputs. */
int q, r;
divide(17, 5, &q, &r);

La división entera da q igual a 3 y r igual a 2. La función llamadora proporciona dos objetos modificables distintos. Otra interfaz útil devuelve un estado de éxito y escribe un resultado solo si tiene éxito; las funciones llamadoras comprueban ese estado antes de utilizar el resultado.

Reconocer el mismo patrón en llamadas a la biblioteca

scanf("%d", &age) necesita la dirección de age porque almacena allí el entero leído. Pasar age proporciona un valor en lugar del int * requerido, lo que produce comportamiento indefinido. Comprueba que scanf devuelva 1 antes de utilizar el valor recién leído.

Para texto, char name[20]; scanf("%19s", name); pasa un puntero al primer carácter del array. El ancho permite como máximo 19 caracteres de entrada y deja espacio para '\0'. La expresión del array ya proporciona el puntero a carácter requerido.

Un parámetro de tipo array también recibe una dirección, no un bloque copiado de elementos. En void zero(int *a, size_t n), las asignaciones a a[i] afectan al array de la función llamadora. Pasar la dirección solo copia un puntero, lo que también permite que funciones de solo lectura examinen arrays grandes sin copiar cada elemento.

Una interfaz con punteros debe dejar claras dos cosas: si la función puede escribir mediante el puntero y durante cuánto tiempo sigue siendo válido el almacenamiento apuntado. const responde a la primera pregunta. El tiempo de vida del objeto responde a la segunda.

Identificar la restricción de const

Un puntero a datos constantes limita esta vía de acceso. Si x se definió como un int x = 5; ordinario, x = 6; sigue estando permitido aunque un const int * apunte a él. Si el propio objeto se definió con const, intentar modificarlo mediante cualquier puntero es comportamiento indefinido.

Un puntero constante conserva una dirección. Debe inicializarse y la dirección no puede sustituirse después. El objeto en esa dirección aún puede cambiar cuando su tipo lo permite. Lee hacia fuera desde el nombre: int *const p hace que p sea constante; const int *p protege el int al que se accede mediante p.

Utiliza un parámetro de solo lectura como const char *s cuando una función solo examina una cadena. Puede pasarse un char * ordinario a ese parámetro sin conversión explícita. La función puede avanzar su s local, pero se rechaza la asignación mediante *s. Volver a convertir a un tipo modificable requiere más que eliminar una advertencia del compilador: el objeto subyacente debe ser realmente modificable.

Devolver una posición en almacenamiento de la función llamadora

int *find(int *a, size_t n, int target) {
    for (size_t i = 0; i < n; i++) {
        if (a[i] == target) return &a[i];
    }
    return NULL;
}

Para int v[] = {4, 9, 2, 9};, find(v, 4, 9) devuelve &v[1]. La función termina, pero v pertenece a la función llamadora y sigue existiendo allí. Después de comprobar el resultado frente a NULL, la función llamadora puede calcular found - v para obtener el índice 1 o asignar *found = 0 para actualizar el elemento. Una búsqueda de 7 devuelve NULL, que no debe desreferenciarse. strchr y strstr usan la misma convención de devolver un puntero nulo cuando no se encuentra el resultado.

Rechazar direcciones de variables locales cuyo tiempo de vida ha terminado

int *bad(void) {
    int result = 42;
    return &result;
}

result tiene duración automática del almacenamiento. Su tiempo de vida termina cuando la llamada retorna, lo que deja a la función llamadora con un puntero colgante. El compilador puede advertir de ello y cualquier acceso posterior mediante ese puntero tiene comportamiento indefinido. Que los bytes antiguos sean visibles en una ejecución no mantiene vivo el objeto.

El mismo problema puede ocurrir en la llave de cierre de un bloque interior. Un puntero exterior no puede prolongar el tiempo de vida de una variable interior cuya dirección guardó.

Elegir almacenamiento que dure lo suficiente

Devuelve un valor int cuando la función llamadora solo necesite un resultado entero. Para varios resultados, deja que la función llamadora proporcione el almacenamiento que se va a rellenar. Un puntero devuelto también puede referirse al array de la función llamadora, a un literal de cadena expuesto mediante const char * o a un objeto static.

Una variable local estática se inicializa una vez y dura todo el programa, pero todas las llamadas la comparten. Si una llamada posterior almacena allí un nuevo valor, todos los punteros devueltos anteriormente ven ese cambio. El almacenamiento estático resuelve el problema del tiempo de vida sin proporcionar a cada llamada su propio objeto de resultado independiente.

Sumar un entero a un puntero lo desplaza por elementos del tipo apuntado. Si p apunta al elemento i de un array, p + n apunta al elemento i + n, siempre que la posición resultante esté dentro del array o inmediatamente después de su último elemento.

Ajustar la dirección una sola vez

En la dirección ilustrativa 0x1000, sumar 3 da estos resultados:

El compilador realiza el ajuste según el tamaño. Escribir p + 3 * sizeof *p lo aplica dos veces y generalmente llega al elemento equivocado. Utiliza unsigned char * cuando el paso deseado sea realmente un byte de la representación de un objeto.

Para int a[6] = {10, 20, 30, 40, 50, 60}; e int *p = &a[1];, *(p + 2) lee a[3], que es 40. La asignación p += 3; desplaza el propio puntero a a[4], que contiene 50. Desde ahí, *(p - 1) lee 40. p++, p--, p += n y p -= n se desplazan por elementos.

Restar posiciones para contar elementos

&a[5] - &a[1] es 4, e invertir los operandos da -4. El resultado ya cuenta elementos; no lo dividas por sizeof(int). Su tipo con signo es ptrdiff_t, declarado en <stddef.h>, y %td lo imprime.

Resta solo punteros al mismo array, incluida la posición inmediatamente posterior a su último elemento, y con un resultado representable en ptrdiff_t. Esta operación describe posiciones dentro de ese array. Restar direcciones de variables no relacionadas es comportamiento indefinido, aunque los números impresos estén casualmente próximos.

Utilizar la posición posterior al final como límite

Para seis elementos, a + 6 es un puntero a la posición inmediatamente posterior al último elemento válido. Puede servir como límite y participar en una resta válida dentro del mismo array, pero no puede desreferenciarse. a + 7 y a - 1 ya tienen comportamiento indefinido al formarse; evitar una desreferenciación posterior no los corrige.

for (int *p = a; p < a + 6; p++) {
    printf("%d\n", *p);
}

El cuerpo se ejecuta para los índices de 0 a 5. Después del último incremento, p es igual a a + 6 y la siguiente prueba detiene el bucle. Utilizar <= permitiría que el cuerpo accediera a esa posición que no es un elemento.

Para las reglas de la aritmética, un objeto individual actúa como un array de un elemento. Puedes formar &x + 1; no puedes utilizarlo para leer una supuesta variable siguiente.

Comparar solo posiciones pertinentes

Los operadores de orden como < comparan posiciones dentro de un array. No ordenes punteros a objetos no relacionados. La igualdad y la desigualdad pueden comparar tipos de puntero compatibles y comprobar si un puntero es nulo.

No puedes sumar dos punteros, multiplicar punteros ni realizar aritmética de C estándar con un void * o un puntero a función. Para encontrar el punto medio de un intervalo [p, q) dentro de un mismo array, utiliza p + (q - p) / 2: resta las posiciones para obtener una cantidad, divide esa cantidad y luego avanza desde p.

Un array es un bloque de elementos. Un puntero es un objeto independiente que contiene una dirección. Su estrecha relación procede de una conversión automática que ocurre en la mayoría de las expresiones, no de que los dos objetos sean del mismo tipo.

Convertir una expresión de array

int a[5] = {3, 1, 4, 1, 5};
int *p = a;

Aquí a se convierte en un puntero a a[0]. Esta conversión de array a puntero hace que el inicializador sea equivalente a &a[0]. Tanto *p como a[0] leen 3.

C define el acceso mediante índices a través de la aritmética: a[i] significa *(a + i). Por tanto, p[3] también funciona y lee 1. &a[i] y a + i identifican el mismo elemento. Incluso 3[a] tiene el mismo significado definido que a[3], aunque la forma habitual es mucho más clara.

Saber cuándo el array completo sigue siendo un array

La conversión no ocurre para los operandos de sizeof o del & unario. Tampoco ocurre para typeof y typeof_unqual de C23, ni cuando un literal de cadena inicializa un array de caracteres.

No puedes asignar una nueva dirección a un array ni incrementar su nombre: a = p; y a++; no son válidos. Puedes redirigir p, por ejemplo, con p = a + 2;. Copia el contenido del array con un bucle sobre los elementos o con una llamada adecuada a memcpy.

Seguir el tipo ajustado del parámetro

int sum(const int *values, size_t n) {
    int total = 0;
    for (size_t i = 0; i < n; i++) total += values[i];
    return total;
}

La función llamadora proporciona tanto una dirección como una cantidad. Para el array anterior, sum(a + 2, 3) visita los índices originales 2, 3 y 4, y suma 4, 1 y 5 para devolver 10. Dentro de la función, el índice 0 es relativo al puntero inicial proporcionado.

En una lista de parámetros de función, int a[], int a[10] e int *a declaran un parámetro de tipo puntero. La forma simple [10] no proporciona un límite comprobado ni transmite una longitud. Dentro de una función así, sizeof a mide un puntero. La expresión sizeof a / sizeof a[0] daría 2 en un sistema con punteros de 8 bytes y valores int de 4 bytes, independientemente de la longitud real del array de la función llamadora.

Distinguir un puntero a elemento de un puntero a array

a se convierte en int *, mientras que &a tiene el tipo int (*)[5], un puntero al array completo de cinco elementos. Ambos identifican el comienzo del mismo almacenamiento, pero la aritmética sigue sus distintos tipos. a + 1 avanza un int, o 4 bytes en esta disposición. &a + 1 avanza un array completo, o 20 bytes, hasta su posición inmediatamente posterior al final.

Una dirección inicial impresa no puede revelar esa diferencia de tipos. Lee la declaración y mantén el tipo apuntado junto al puntero al seguir una expresión.

Un bucle con puntero necesita una posición actual y una regla de parada. Un array con un número conocido de elementos utiliza un puntero al final; una cadena utiliza su '\0' de terminación. Elige la forma que permita ver con mayor facilidad los elementos visitados.

Recorrer un intervalo de longitud conocida

int a[] = {3, 1, 4, 1, 5};
int total = 0;
for (const int *p = a; p < a + 5; p++) {
    total += *p;
}

Los totales acumulados son 3, 4, 8, 9 y 14. Un bucle con índice que suma a[i] para índices menores que 5 da el mismo resultado. Los compiladores optimizadores modernos suelen generar código similar para estas formas; la sintaxis de punteros por sí sola no garantiza ninguna ventaja de velocidad.

Leer antes o después de avanzar

Con p en el 3 de {3, 1, 4}, int v = *p++; asigna 3 a v y deja p en el 1. El incremento posfijo proporciona el valor anterior del puntero a * y actualiza el puntero. *++p primero avanza al siguiente elemento y luego lo lee. (*p)++ modifica el elemento actual y no desplaza el puntero.

Detenerse en el terminador de una cadena

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

Para "pointer", p se detiene en el terminador, siete posiciones desde el inicio. El resultado excluye ese terminador. Un recuento de caracteres utiliza el mismo recorrido: examinar "mississippi" e incrementar un contador cada vez que *p == 's' cuenta cuatro coincidencias entre once letras.

Un puntero al interior de una cadena da acceso a su sufijo. Con const char *msg = "hello world";, puts(msg + 6) imprime "world". Los caracteres anteriores permanecen donde estaban.

Copiar también el terminador

char destination[4];
const char *src = "cat";
char *dst = destination;
while ((*dst++ = *src++) != '\0') {
}

Cada iteración asigna un carácter, comprueba el valor asignado y avanza ambos punteros. La última iteración copia '\0', por lo que el destino es una cadena completa. Ambos punteros quedan entonces justo después de sus terminadores. El almacenamiento necesita la longitud del texto más un byte; omitir ese byte adicional provoca un desbordamiento de búfer. Este patrón de copia también requiere que las regiones de origen y destino no se solapen.

Invertir desde ambos extremos

Para una cadena modificable, obtén primero su longitud. Si la longitud es cero, detente antes de formar un puntero al último carácter. De lo contrario, establece left = s y right = s + length - 1. Mientras left < right, intercambia los caracteres, incrementa left y decrementa right. Para "stressed", cuatro intercambios producen "desserts"; el terminador permanece en el extremo original.

La comprobación de cadena vacía importa porque restar 1 de su puntero inicial formaría un puntero anterior al array.

Elegir almacenamiento de caracteres modificable

char word[] = "hello"; crea un array modificable de seis bytes, incluido el terminador. const char *word = "hello"; apunta a un literal de cadena con duración estática del almacenamiento. Modificar un literal de cadena es comportamiento indefinido, incluso si una declaración utiliza char * sin const. Utiliza const char * para que las escrituras accidentales sean un error de compilación.

Un bucle sobre un array debe detenerse antes de la posición inmediatamente posterior a su final, y un recorrido de cadena debe encontrar realmente un terminador dentro del almacenamiento accesible. Un puntero no lleva consigo ni una longitud ni una garantía de que los bytes formen una cadena.

Un puntero es un objeto almacenado, por lo que tiene una dirección que otro puntero puede contener. Un puntero a puntero añade un paso más entre la expresión y los datos finales.

Seguir las flechas de una en una

int x = 7;
int *p = &x;
int **pp = &p;

Utiliza direcciones ilustrativas: x en 0x2000 contiene 7; p en 0x3000 contiene 0x2000; pp en 0x4000 contiene 0x3000. Al evaluar *pp se llega a p, cuyo valor tiene tipo int *. Al evaluar **pp se sigue ese puntero hasta x, un int.

&p tiene un nivel de puntero más que p; cada desreferenciación elimina un nivel. Inicializar int **pp con &x produce una incompatibilidad porque &x tiene tipo int *.

Elegir el nivel de asignación

Con otro entero existente y, **pp = 9; modifica x. La asignación *pp = &y; modifica el puntero p, por lo que los usos posteriores de **pp llegan a y. Deja x con su valor actual. Si q es otro int *, pp = &q; modifica solo el puntero exterior, haciendo que su primera flecha llegue a q en lugar de p.

No cuentes los asteriscos sin comprobar también el objeto de cada nivel. Antes de evaluar **pp, tanto la ruta hasta el objeto de tipo puntero como la ruta desde ese objeto hasta el entero deben ser válidas.

Desplazar un puntero a cadena de la función llamadora

void skip_spaces(const char **s) {
    while (**s == ' ') {
        (*s)++;
    }
}

/* In the caller: */
const char *text = "   hi";
skip_spaces(&text);
puts(text);

La función llamadora pasa la dirección de su variable de tipo puntero. Por tanto, *s designa text; **s lee el carácter actual. Cada (*s)++ avanza text un carácter. Después de tres iteraciones apunta a 'h' y puts imprime "hi". La función requiere un puntero válido a un puntero que apunte a una cadena terminada en nulo.

Una versión que recibe const char *s e incrementa s modifica solo una copia local. Los paréntesis en (*s)++ también son imprescindibles: *s++ incrementa el puntero local exterior en lugar del puntero a carácter de la función llamadora. En const char **s, los caracteres son de solo lectura mediante esta vía de acceso, pero el puntero de la función llamadora puede desplazarse.

Leer un puntero de salida de la biblioteca

strtol de <stdlib.h> utiliza un parámetro de salida de tipo char **:

char *end;
long number = strtol("42abc", &end, 10);

Devuelve 42 y almacena en end un puntero al primer carácter no utilizado, que ahora apunta a "abc". Si el puntero al final es igual al puntero inicial, no se convirtió ningún dígito. Un analizador numérico que realice todas las comprobaciones también gestiona los errores de rango; aquí la función del puntero es indicar la posición de parada.

Un array puede almacenar punteros como elementos. Un array bidimensional, en cambio, almacena filas completas como elementos. Ambos admiten dos índices, pero su almacenamiento y los tipos de puntero a los que se convierten son distintos.

Almacenar direcciones de cadenas independientes

const char *days[] = {"Mon", "Tue", "Wed"};

days contiene tres punteros a caracteres. Cada uno apunta a un literal de cadena independiente. days[1] es el puntero a "Tue", y days[1][0] lee 'T'. Con punteros a objetos de 8 bytes, sizeof days es 24, independientemente de las longitudes de las cadenas. Las cadenas ocupan almacenamiento en otro lugar.

Las longitudes pueden diferir, lo que produce una colección irregular. Reordenar la lista puede intercambiar elementos de tipo puntero sin copiar el texto. Asignar days[0] = "Thursday"; está permitido: el elemento de tipo puntero puede cambiar aunque los caracteres a los que se accede mediante él sean de solo lectura.

En la mayoría de las expresiones, days se convierte en un puntero a su primer elemento. Como un elemento es un const char *, el tipo convertido es const char **:

for (const char **d = days; d < days + 3; d++) {
    puts(*d);
}

El bucle avanza un elemento de tipo puntero por iteración. *d obtiene el puntero a carácter que necesita puts.

Leer cadenas de la línea de comandos

int main(int argc, char *argv[]) recibe el mismo tipo de parámetro que char **argv. argc no es negativo y cuenta las cadenas disponibles. Cuando es positivo, argv[0] representa el nombre del programa o una cadena vacía si ese nombre no está disponible. Los argumentos del usuario ocupan los índices desde 1 hasta argc - 1, y argv[argc] es un puntero nulo.

En una invocación típica ./greet Ada 42, argc es 3, argv[1] apunta a "Ada" y argv[2] apunta a "42". El último argumento es texto hasta que lo lee una conversión como strtol. argv[1][0] es 'A'. Comprueba argc > 2 antes de utilizar argv[2].

Un bucle que imprime los argumentos del usuario puede utilizar for (int i = 1; i < argc; i++) puts(argv[i]);. Para recorrer desde argv + 1 hasta un puntero nulo, comprueba primero argc > 0; si argc es cero, no hay un intervalo de argumentos del usuario que pueda comenzarse de ese modo. Las cadenas de argumentos son modificables, a diferencia de los literales de cadena.

Seguir filas completas

int grid[3][4] contiene doce enteros en orden por filas: toda la fila 0, luego la fila 1 y después la fila 2. Con valores int de 4 bytes, cada fila ocupa 16 bytes. grid[2][1] está 36 bytes después de grid[0][0]: dos filas completas aportan 32 bytes y la columna aporta 4.

grid + 1 avanza una fila. Una función que lo recibe puede utilizar int g[][4] o int (*g)[4], con un número de filas separado. No puede utilizar int **: la tabla no tiene punteros a filas almacenados que puedan desreferenciarse. Una conversión explícita no puede crear esos punteros inexistentes.

Del mismo modo, char names[3][6] dispone de dieciocho posiciones para caracteres en filas de tamaño fijo. const char *names[3] dispone de tres posiciones para punteros que pueden referirse a cadenas de distintas longitudes.

Un puntero a función almacena una referencia a una función a la que se puede llamar más adelante. Su tipo incluye el tipo de retorno y los tipos de los parámetros. Esos tipos deben coincidir con los de la función utilizada mediante el puntero.

Poner paréntesis alrededor del nombre del puntero

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }
int mul(int a, int b) { return a * b; }

int (*op)(int, int) = add;

Lee desde op: es un puntero, aquello a lo que apunta es una función que recibe dos valores int, y esa función devuelve un int. Sin los paréntesis, int *op(int, int); declara una función que devuelve un puntero a entero. Los paréntesis cambian el significado de la declaración.

El nombre de una función se convierte en un puntero a función en este inicializador. op = &add; es equivalente a op = add;. Tanto op(6, 3) como (*op)(6, 3) llaman a add y devuelven 9. Asignar op = sub; hace que la misma llamada devuelva 3. En la expresión de llamada no ha cambiado nada salvo la función almacenada en el puntero.

Mantener la firma compatible

Un puntero de tipo int (*)(int, int) no puede llamar de forma segura a una función que recibe y devuelve double. Por ejemplo, asignarle sqrt produce un mensaje de diagnóstico por tipos incompatibles. Convertir explícitamente el puntero a función para eliminar un mensaje de diagnóstico no hace válida una llamada incompatible; el comportamiento es indefinido.

C estándar trata por separado los punteros a objetos y los punteros a funciones. void * es el tipo de puntero genérico a objeto, no un contenedor portable para un puntero a función. Los punteros a funciones admiten pruebas de igualdad y desigualdad, pero no aritmética de punteros.

Un puntero nulo a función significa que no hay ninguna función a la que llamar. Cuando una interfaz permite ese estado, compruébalo:

if (op != NULL) {
    int result = op(6, 3);
    printf("%d\n", result);
}

Llamar mediante un puntero nulo a función es comportamiento indefinido.

Dar nombre al tipo una vez

typedef int (*binop)(int, int);
binop ops[] = {add, sub, mul};

El typedef da nombre a un tipo de puntero. binop selected = mul; declara un puntero; binop pick(char symbol); declara una función que devuelve uno. Sin el typedef, esa declaración de retorno sería int (*pick(char symbol))(int, int);.

Un array de punteros a funciones es una tabla de despacho. ops[2](6, 3) selecciona mul y devuelve 18. Para un índice de selección con signo i, comprueba i >= 0 && i < 3 antes de evaluar ops[i]. Acceder fuera de los límites de la tabla no es válido aunque se pueda llamar a todas las funciones almacenadas.

Interpretar declaraciones más amplias hacia fuera

Comienza por el nombre y resuelve los paréntesis y las partes posfijas antes de avanzar más hacia fuera. En int (*table[3])(int, int), table[3] forma un array de tres elementos, * hace que cada elemento sea un puntero y (int, int) hace que su destino sea una función que devuelve int.

En char *(*f)(const char *), f es un puntero a una función que recibe un const char *; esa función devuelve un char *. Mantén separados los requisitos de tiempo de vida del puntero devuelto y los requisitos de compatibilidad de llamada del puntero a función.

Una función de devolución de llamada es una función proporcionada a otra función, que la llama como parte de su trabajo. Esto separa la operación general de recorrido u ordenación de la acción o el orden concreto que elijas.

Pasar una operación sin llamarla

void twice(int *x) { *x *= 2; }

void for_each(int *a, size_t n, void (*fn)(int *)) {
    for (size_t i = 0; i < n; i++) fn(&a[i]);
}

Para int v[] = {1, 2, 3};, for_each(v, 3, twice); produce {2, 4, 6}. El nombre de la función proporciona un puntero. Escribir twice() intentaría llamarla de inmediato, sin el argumento requerido, en lugar de proporcionar una operación para llamadas posteriores.

Recuperar un tipo desde un puntero genérico a objeto

Un void * puede contener un puntero a objeto y convertirse de nuevo al tipo original. No puede desreferenciarse ni utilizarse en aritmética de punteros de C estándar porque no proporciona un tipo de elemento. Conserva los calificadores: los datos de solo lectura pasan por const void * y después por un puntero adecuado a datos constantes.

qsort de <stdlib.h> recibe una dirección base, un número de elementos, un tamaño de elemento en bytes y una función de comparación. La función de devolución de llamada tiene tipo int (*)(const void *, const void *). Cada argumento apunta a un elemento del array y el signo devuelto indica dónde corresponde el primer elemento:

Ordenar enteros sin desbordamiento

int cmp_int(const void *a, const void *b) {
    int x = *(const int *)a;
    int y = *(const int *)b;
    return (x > y) - (x < y);
}

/* In the caller: */
int v[] = {42, -7, 19, 0, 3};
qsort(v, 5, sizeof v[0], cmp_int);

El array pasa a ser {-7, 0, 3, 19, 42}. Las comparaciones producen 0 o 1, por lo que la expresión de retorno solo produce -1, 0 o 1. Invertir la expresión de orden a (y > x) - (y < x) ordena en sentido descendente.

No utilices return x - y; para enteros con signo arbitrarios. Para un int de 32 bits, restar -2 000 000 000 de 2 000 000 000 supera INT_MAX. El desbordamiento con signo tiene comportamiento indefinido, por lo que no se garantiza un resultado reducido modularmente ni un signo de comparación fiable.

Ordenar punteros a cadenas

int cmp_str(const void *a, const void *b) {
    return strcmp(*(const char *const *)a,
                  *(const char *const *)b);
}

const char *names[] = {"Lin", "Ada", "Grace"};
qsort(names, 3, sizeof names[0], cmp_str);

Incluye <string.h> para strcmp. Aquí un elemento del array es a su vez un puntero. La función de devolución de llamada recibe una dirección de ese elemento de tipo puntero, por lo que desreferenciar una vez obtiene la dirección de la cadena. El const interior añadido impide modificar el elemento mediante esta vía de acceso. Después de ordenar, el orden es "Ada", "Grace", "Lin".

strcmp(a, b) leería los bytes de las posiciones de puntero como texto. Utiliza también sizeof names[0], el tamaño de un elemento de tipo puntero, no sizeof(char) ni la longitud de un nombre.

Las funciones de comparación deben dejar los elementos sin cambios y responder de forma coherente, incluido el orden transitivo. qsort no garantiza conservar el orden de los elementos que se consideran iguales al compararlos. bsearch acepta el mismo tipo de función de comparación para buscar en un array ya ordenado según ese criterio.