Entenent Arrays i Punters en C amb Exemples Clars i Pràctics

Si estàs començant amb el llenguatge C o ja fa un temps que programes i encara et confonen els conceptes de punters i arrays, no estàs sol. Aquests dos elements fonamentals de C solen generar dubtes, especialment perquè el seu comportament pot semblar semblant, però tenen diferències clau. En aquest article anem a esmicolar aquests conceptes en detall, amb explicacions clares i exemples simples que t'ajudaran a dominar-los d'una vegada per totes.

A través d'aquest contingut, veuràs com els punters permeten una gestió més flexible i eficient de la memòria , aprendràs a utilitzar arrays tant de variables com de punters, i coneixeràs com s'uneix tot això en tractar amb funcions, cadenes de caràcters i estructures més complexes. Tot explicat de forma natural, pràctica i sense embuts.

Què és un punter a C?

Un punter en C és una variable que emmagatzema l'adreça de memòria d'una altra variable . En lloc de desar un valor directament, desa la ubicació on es troba aquest valor a la memòria.

La sintaxi bàsica per declarar un punter és:

int variable;
int *puntero = &variable;

On & és l'operador que obté l'adreça de memòria, i * es fa servir per accedir (o desreferenciar) al contingut de l'adreça apuntada.

Per exemple:

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

Això imprimirà el contingut de l'adreça emmagatzemada a p , que és el valor de la variable valor.

Aritmètica de punters

Una de les característiques més potents dels punters és que podem fer operacions aritmètiques sobre ells. Això és perquè un punter apunta a una adreça de memòria, i en incrementar o decrementar aquest punter, canvia la posició a la qual apunta , tenint en compte la mida del tipus de dada a què apunta.

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

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

Aquest comportament fa que recórrer un array amb un punter sigui molt senzill i eficient.

Les operacions bàsiques que pots fer són:

• assignació: int *ptr = array;
• Desreferència: *ptr retorna el valor contingut a l'adreça
• increment: ptr++ avança al següent element
• Resta: permet saber la distància entre dos punters

Arraigs a C

Un array en C és una col·lecció d'elements del mateix tipus ubicats en posicions consecutives de memòria . En declarar un array com:

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

Internament, els elements estan alineats un darrere l'altre a la memòria. El nom de l'array, com a números , representa una constant que apunta a l'adreça del primer element. És a dir:

numeros == &numeros

Per aquesta raó, és possible fer servir punters per accedir als elements d'un array . Això habilita tècniques com recórrer l'array amb un punter:

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

Que és exactament el mateix que fer-ho amb índexs.

Relació entre punters i arrays

La relació entre arrays i punters és tan estreta que es poden confondre fàcilment. Encara que tècnicament un array no és un punter, el seu comportament s'assembla molt al d'un en ser usat com a paràmetre de funcions, per exemple.

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

Aquesta funció pot ser anomenada tant amb un array com amb un punter, perquè en passar un array a una funció, el que realment es passa és la direcció del seu primer element.

Cadenes de caràcters en C

A C, una cadena de caràcters és simplement un array de tipus char que acaba amb el caràcter especial '\0' (caràcter nul). Això indica el final de la cadena.

Per exemple:

char saludo[] = "Hola";

És equivalent a:

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

Aquest caràcter nul permet funcions com strlen() saber quan aturar-se.

Una forma comuna de declarar una cadena és usant un punter:

char *mensaje = "Mensaje de prueba";

Cal anar amb compte amb aquesta forma, ja que la cadena apuntada pot estar en un segment de memòria de només lectura, la qual cosa impedeix modificar-ne el contingut.

Punters a funcions

Una mica més avançat, però molt útil, és lús de punters a funcions . A C és possible emmagatzemar l'adreça d'una funció dins d'un punter i després trucar-la a través seu. Això és especialment útil en estructures com callbacks o algorismes genèrics.

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

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

Això ofereix una gran flexibilitat i s'utilitza molt en estructures com ara menús interactius o estructures orientades a esdeveniments.

Arraigs de punters

Un array de punters no és més que una col·lecció de punters , és a dir, cada element de l'array és un punter a una adreça de memòria.

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

Així, pots accedir als valors com:

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

Això es fa servir molt per treballar amb cadenes de text, com en arrays de cadenes:

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

I recorrent-ho amb un bucle:

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

Ús de punters en funcions

A C, les funcions reben els seus arguments per valor , el que significa que es treballa amb una còpia. Si volem modificar el valor original d‟una variable des d‟una funció, hem de passar un punter a aquesta variable.

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

Anomenant-la així:

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

Paràmetres de línia d'ordres

A C, els programes poden rebre arguments en el moment d'executar-se. Això s'aconsegueix amb els paràmetres argc y argv[] en la funció main(). A més, pots consultar com utilitzar punters en funcions per gestionar arguments i millorar el teu codi.

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

argc indica quants arguments s'han passat, i argv és un array de punters a char que conté els arguments com a cadenes.