Entendiendo Arrays y Punteros en C con Ejemplos Claros y Prácticos

Si estás empezando con el lenguaje C o ya llevas un tiempo programando y todavía te confunden los conceptos de punteros y arrays, no estás solo. Estos dos elementos fundamentales de C suelen generar dudas, especialmente porque su comportamiento puede parecer similar, pero tienen diferencias clave. En este artículo vamos a desmenuzar estos conceptos en detalle, con explicaciones claras y ejemplos simples que te ayudarán a dominarlos de una vez por todas.

A través de este contenido, verás cómo los punteros permiten una gestión más flexible y eficiente de la memoria, aprenderás a utilizar arrays tanto de variables como de punteros, y conocerás cómo todo esto se une al tratar con funciones, cadenas de caracteres y estructuras más complejas. Todo explicado de forma natural, práctica y sin rodeos.

¿Qué es un puntero en C?

Un puntero en C es una variable que almacena la dirección de memoria de otra variable. En lugar de guardar un valor directamente, guarda la ubicación donde se encuentra ese valor en la memoria.

La sintaxis básica para declarar un puntero es:

int variable;
int *puntero = &variable;

Donde & es el operador que obtiene la dirección de memoria, y * se usa para acceder (o desreferenciar) al contenido de la dirección apuntada.

Por ejemplo:

int valor = 10;
int *p = &valor;
printf("%d", *p); // Imprime 10

Esto imprimirá el contenido de la dirección almacenada en p, que es el valor de la variable valor.

Aritmética de punteros

Una de las características más potentes de los punteros es que podemos realizar operaciones aritméticas sobre ellos. Esto se debe a que un puntero apunta a una dirección de memoria, y al incrementar o decrementar ese puntero, cambia la posición a la que apunta, teniendo en cuenta el tamaño del tipo de dato al que apunta.

int array = {5, 10, 15};
int *ptr = array;

printf("%d", *(ptr + 1)); // Imprime 10

Este comportamiento hace que recorrer un array con un puntero sea muy sencillo y eficiente.

Las operaciones básicas que puedes realizar son:

• Asignación: int *ptr = array;
• Desreferencia: *ptr devuelve el valor contenido en la dirección
• Incremento: ptr++ avanza al siguiente elemento
• Resta: permite saber la distancia entre dos punteros

Arrays en C

Un array en C es una colección de elementos del mismo tipo ubicados en posiciones consecutivas de memoria. Al declarar un array como:

int numeros = {1, 2, 3, 4, 5};

Internamente, los elementos están alineados uno tras otro en la memoria. El nombre del array, como numeros, representa una constante que apunta a la dirección del primer elemento. Es decir:

numeros == &numeros

Por esta razón, es posible usar punteros para acceder a los elementos de un array. Esto habilita técnicas como recorrer el array con un puntero:

int *ptr;
for(ptr = numeros; ptr < numeros + 5; ptr++) {
    printf("%d ", *ptr);
}

Que es exactamente lo mismo que hacerlo con índices.

Relación entre punteros y arrays

La relación entre arrays y punteros es tan estrecha que pueden confundirse fácilmente. Aunque técnicamente un array no es un puntero, su comportamiento se asemeja mucho al de uno al ser usado como parámetro de funciones, por ejemplo.

void imprimir(int *arr, int n) {
    for(int i = 0; i < n; i++) {
        printf("%d ", arr);
    }
}

Esta función puede ser llamada tanto con un array como con un puntero, porque al pasar un array a una función, lo que realmente se pasa es la dirección de su primer elemento.

Cadenas de caracteres en C

En C, una cadena de caracteres es simplemente un array de tipo char que termina con el carácter especial ‘\0’ (carácter nulo). Esto indica el final de la cadena.

Por ejemplo:

char saludo[] = "Hola";

Es equivalente a:

char saludo[] = {'H', 'o', 'l', 'a', '\0'};

Este carácter nulo permite funciones como strlen() saber cuándo detenerse.

Una forma común de declarar una cadena es usando un puntero:

char *mensaje = "Mensaje de prueba";

Hay que tener cuidado con esta forma, ya que la cadena apuntada puede estar en un segmento de memoria de solo lectura, lo cual impide modificar su contenido.

Punteros a funciones

Algo más avanzado, pero muy útil, es el uso de punteros a funciones. En C es posible almacenar la dirección de una función dentro de un puntero y luego llamarla a través de él. Esto es especialmente útil en estructuras como callbacks o algoritmos genéricos.

int suma(int a, int b) {
    return a + b;
}

int (*operacion)(int, int);
operacion = suma;
printf("%d", operacion(5, 3)); // Imprime 8

Esto ofrece una gran flexibilidad y se utiliza mucho en estructuras como menús interactivos o estructuras orientadas a eventos.

Arrays de punteros

Un array de punteros no es más que una colección de punteros, es decir, cada elemento del array es un puntero a una dirección de memoria.

int a = 1, b = 2, c = 3;
int *arr_punteros;
arr_punteros = &a;
arr_punteros = &b;
arr_punteros = &c;

Así, puedes acceder a los valores como:

printf("%d", *arr_punteros); // Imprime 1

Esto se usa mucho para trabajar con cadenas de texto, como en arrays de cadenas:

char *mensajes[] = {"Hola", "Mundo", "Adiós"};

Y recorriéndolo con un bucle:

for(int i = 0; i < 3; i++) {
    printf("%s\n", mensajes);
}

Uso de punteros en funciones

En C, las funciones reciben sus argumentos por valor, lo que significa que se trabaja con una copia. Si queremos modificar el valor original de una variable desde una función, debemos pasar un puntero a esa variable.

void cambiar(int *x) {
    *x = 100;
}

Llamándola así:

int valor = 50;
cambiar(&valor);
printf("%d", valor); // Imprime 100

Parámetros de línea de comandos

En C, los programas pueden recibir argumentos al momento de ejecutarse. Esto se logra con los parámetros argc y argv[] en la función main(). Además, puedes consultar cómo usar punteros en funciones para gestionar argumentos y mejorar tu código.

int main(int argc, char *argv[]) {
    for(int i = 0; i < argc; i++) {
        printf("Argumento %d: %s\n", i, argv);
    }
}

argc indica cuántos argumentos se han pasado, y argv es un array de punteros a char que contiene los argumentos como cadenas.