En el lenguaje C, el manejo de punteros es fundamental para la gestión eficiente de la memoria. Es crucial distinguir entre la dirección de una variable (el valor físico de la ubicación en memoria) y una varible puntero (un contenedor que almacena dicho valor).

Fundamentos de Punteros

Para trabajar con direcciones de memoria, utilizamos dos operadores principales:

• &: Obtiene la dirección de memoria de un objeto existente.
• *: Posee un doble propósito. En una declaración, define un tipo de dato puntero; en una expresión, actúa como operador de desreferenciación para acceder al valor almacenado en la dirección apuntada.

int valor = 50;
int *ptr = &valor; // El puntero 'ptr' ahora apunta a 'valor'

Punteros como Argumentos de Función

El uso de punteros en funciones permite modificar variables locales del llamador, técnica conocida como paso por referencia o parámetros de salida.

Intercambio de datos mediante punteros

Existen dos enfoques principales al manipular punteros en funciones: modificar hacia dónde apunta el puntero o modificar el valor contenido en la dirección original.

#include <stdio.h>

// Intercambio de valores reales en memoria (Eficaz)
void permutarValores(int *x, int *y) {
    int auxiliar = *x;
    *x = *y;
    *y = auxiliar;
}

int main() {
    int valA = 100, valB = 200;
    printf("Antes: A=%d, B=%d\n", valA, valB);
    permutarValores(&valA, &valB);
    printf("Después: A=%d, B=%d\n", valA, valB);
    return 0;
}

Interacción entre Punteros y Arreglos

En C, el nombre de un arreglo se comporta como un puntero constante a su primer elemento. Por lo tanto, arreglo es equivalente a &arreglo[0].

int datos[] = {10, 20, 30};
int *p_datos = datos; // Apunta al primer elemento (10)

Operaciones Aritméticas con Punteros

La aritmética de punteros permite desplazarse por los elementos de un arreglo de forma lineal. El incremento de un puntero (p++) no suma un byte, sino el tamaño en bytes del tipo de dato al que apunta.

Iteración de Arreglos mediante Direccionamiento

Existen múltiples formas de recorrer un arreglo utilizando la lógica de punteros:

#include <stdio.h>

void mostrarArreglo(int *inicio, int tamano) {
    // Uso de aritmética de punteros para el control del bucle
    for (int *actual = inicio; actual < (inicio + tamano); actual++) {
        printf("Valor: %d en la dirección %p\n", *actual, (void*)actual);
    }
}

int main() {
    int lista[] = {5, 10, 15, 20};
    mostrarArreglo(lista, 4);
    return 0;
}

Punteros a Arreglos (Array Pointers)

Un puntero a arreglo es una variable que apunta a la estructura completa del arreglo, no solo a un elemento individual. Se declara utilizando paréntesis para proirizar la asociación.

int miArreglo[5] = {1, 2, 3, 4, 5};
int (*ptrArreglo)[5] = &miArreglo; // Apunta al bloque completo de 5 enteros

Aplicación en Arreglos Bidimensionales

Los punteros a arreglos son especialmente útiles para manejar matrices, donde el puntero puede representar una fila completa.

#include <stdio.h>

int main() {
    int matriz[2][3] = {{1, 2, 3}, {4, 5, 6}};
    
    // ptrFila apunta a un arreglo de 3 enteros (una fila)
    int (*ptrFila)[3] = matriz;

    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            // Acceso mediante notación de puntero doblemente desreferenciado
            printf("%d ", *(*(ptrFila + i) + j));
        }
        printf("\n");
    }
    return 0;
}

Diferencias Críticas de Sintaxis

Es vital no confundir las siguientes expresiones:

• *p++: El operador ++ tiene prioridad. Se obtiene el valor de p y luego p se incrementa.
• (*p)++: Se obtiene el valor apuntado por p y se incrementa ese valor.
• *(++p): Primero se incrementa la dirección de p, luego se accede al contenido.