Tutorial de Programación en C de Linux Parte 19: Punteros y Arreglos

Hasta ahora en esta serie de tutoriales de programación en C, hemos discutido brevemente los conceptos básicos de los punteros. Sin embargo, hay varios conceptos relacionados con los punteros que necesitan ser discutidos. Así que en este tutorial, discutiremos el concepto de punteros y arreglos.

Antes de comenzar con punteros y arreglos, refresquemos rápidamente el concepto básico de punteros. Los punteros son un tipo especial de variables que pueden contener direcciones. Por ejemplo, un puntero ‘ptr’ a un carácter puede declararse de la siguiente manera;

char *ptr;

Y puedes usar el signo ampersand para almacenar una dirección en él. Aquí hay un ejemplo:

char c = 'a';  
ptr = &c;

Así que ahora, el puntero ‘ptr’ contiene la dirección de la variable ‘c’. Alternativamente, también puedes decir que ‘ptr’ ahora apunta a la variable ‘c’.

Para acceder o manipular el valor de la variable a la que apunta el puntero, puedes usar el operador *. Por ejemplo, para cambiar el valor de la variable c de ‘a’ a ‘b’, puedes usar el puntero ‘ptr’ de la siguiente manera:

*ptr = 'b';

El siguiente programa debería darte una mejor idea sobre estos conceptos básicos de punteros que hemos discutido hasta ahora:

#include   
  
int main()  
{  
 char c = 'a';  
 char *ptr = &c;  
   
 *ptr = 'b';  
   
 printf ("variable c = %c", c);  
  
 return 0;  
}

Aquí está la salida de este programa:

variable c = b

Así que puedes ver que usando un puntero, el valor de una variable fue cambiado.

Punteros y Arreglos

A medida que pases más y más tiempo escribiendo y leyendo código en C, observarás que los punteros y los arreglos a menudo se utilizan juntos. Por ejemplo, puedes acceder a elementos individuales de un arreglo usando un puntero. Considera el siguiente fragmento de código:

...  
...  
...  
char arr[] = {'a','b','c','d','e'}  
char *ptr;  
ptr = &arr[0]  
...  
...  
...

Aquí, el puntero ‘ptr’ apunta al primer elemento del arreglo ‘arr’, que si hablas en términos de índices, se encuentra en la posición cero del arreglo. Ahora, puedes usar el operador * con ‘ptr’ para acceder/manipular el valor al que el puntero está apuntando.

Siguiendo adelante, una vez que tienes un puntero apuntando al primer elemento de un arreglo, es fácil acceder a otros elementos del arreglo también. Por ejemplo, si - en el contexto del fragmento de código anterior - usas la siguiente expresión en cualquier lugar:

*(ptr+1)

entonces te permite acceder al segundo elemento del arreglo, algo que normalmente haces de la siguiente manera:

arr[1] 

Así que efectivamente, agregar 1 a ‘ptr’ te lleva a la dirección del siguiente elemento en el arreglo, y usando * puedes acceder al valor almacenado en esa dirección. De manera similar, agregar 2 te lleva al tercer elemento … y así sucesivamente.

Aquí hay un programa que debería darte una idea más clara sobre lo que discutimos ahora:

#include   
  
int main()  
{  
 char arr[] = {'a','b','c','d','e'};  
 char *ptr = &arr[0];  
   
 for(int i=0;i

Y aquí está la salida:

arr[0] es a   
arr[1] es b   
arr[2] es c   
arr[3] es d   
arr[4] es e

Así que puedes ver, la expresión ‘*(ptr+i)’ - con i variando de 0 al último índice en el arreglo - nos permitió acceder a todos los elementos del arreglo.

NOTA 1: El nombre del arreglo, cuando se usa en el código, te da la dirección base del arreglo. Esto significa que el nombre del arreglo y la dirección de su primer elemento son lo mismo. Así que en el contexto de un arreglo ‘arr’, ‘&arr[0]’ y ‘arr’ son lo mismo. Esto se extiende a otros elementos también, lo que significa que &arr[2] también puede escribirse como (arr+2) y así sucesivamente.

NOTA 2: Ampliando lo que discutimos en la nota anterior, cada representación de elemento de arreglo puede descomponerse en representación de puntero. Por ejemplo: arr[2] es equivalente a ‘*(arr + 2)’.

NOTA 3: Si bien puedes asignar una dirección de arreglo a un puntero, viceversa no es válido. Además, a diferencia de los punteros, no puedes usar los operadores ++ o – con el nombre del arreglo. En términos generales, no puedes cambiar las direcciones en las que los elementos del arreglo están ubicados originalmente.

Conclusión

Este tutorial se centró en el concepto de punteros y arreglos, cómo están relacionados y cómo se pueden acceder a los elementos del arreglo a través de punteros. Hacia el final, también discutimos algunos puntos importantes cuando se trata de código que utiliza punteros a arreglos.

Intenta probar estos conceptos localmente en tu máquina para tener una mejor idea de cómo funcionan estas cosas, y en caso de cualquier duda o consulta, deja un comentario abajo.