Relación entre
punteros y arreglos
Los punteros y
los arreglos están estrechamente relacionados, de hecho, el nombre de un
arreglo corresponde a un puntero que apunta al primer elemento del arreglo.
Esto quiere decir, que las siguientes expresiones son equivalentes:
arreglo[0]
*arreglo
Ejemplo:
#include<iostream>
using std::cout;
using std::endl;
int main(){
int arreglo[] = {2,4,6,8,10};
cout << "Primer indice: "
<< arreglo[0]
<< endl;
cout << "Primer indice:
" << *arreglo
<< endl;
return 0;
}
Como se puede
apreciar, se obtiene el mismo resultado. La diferencia entre ambas expresiones,
es que el nombre de un arreglo, es un apuntador constante, lo cual significa
que al realizar por ejemplo la operación arreglo++, resultaría un error de
compilación ya que se estaría tratando de modificar un elemento constante.
Como en todo
arreglo, también nos podemos desplazar entre los índices. Para hacerlo con
apuntadores, para lograrlo se realizará
de la siguiente forma:
*(arreglo + 2)
Esto es
equivalente a la expresión arreglo[2].
Veamos un ejemplo, utilizando el código anterior.
#include<iostream>
using
std::cout;
using
std::endl;
int
main(){
int arreglo[] = {2,4,6,8,10};
cout
<< "Indice nro.: " << arreglo[2] << endl;
cout
<< "Indice nro.: " << *(arreglo + 2) << endl;
return 0;
}
Usar el
paréntesis es importante, de lo contrario se realizaría una suma al primer
índice, que en este caso vale 2. Como el primer índice es igual a dos, el
resultado que mostrará es un 4 (debido a la suma de 2+2)
#include<iostream>
using
std::cout;
using
std::endl;
int
main(){
int arreglo[] = {2,4,6,8,10};
cout
<< "Indice nro.: " << arreglo[2] << endl;
cout
<< "Indice nro.: " << *arreglo + 2 << endl;
return 0;
}
Para apuntar a
un índice de un arreglo, también es posible hacerlo creando un apuntador al
cual le asignamos la dirección de memoria del arreglo y su índice, tal como en
el siguiente ejemplo:
#include<iostream>
using
std::cout;
using
std::endl;
int
main(){
int arreglo[] = {2,4,6,8,10};
int *puntero = &arreglo[2];
cout
<< *puntero
<< endl;
return 0;
}
Los punteros también aceptan algunas operaciones
aritméticas, pero son algo diferentes a las convencionales. Por ejemplo, si
tengo una dirección de memoria con un valor de 1000, al sumarle 1, el resultado
no sería 1001, sino que el resultado sería el tamaño del byte correspondiente
al tipo de dato del puntero. Como en este caso se trata de punteros, el
resultado sería 1004, si le sumo 2, el resultado sería 1008 y así
sucesivamente. De esta manera, se puede apuntar a distintos índices. Por
ejemplo:
#include<iostream>
using
std::cout;
using
std::endl;
int
main(){
int arreglo[] = {2,4,6,8,10};
int
*puntero = &arreglo[0];
puntero++;
cout
<< *puntero << endl;
return 0;
}
Los arreglos también pueden tener punteros. Esto se
usa comúnmente para crear arreglos de cadenas de caracteres, como la mostrada a
continuación:
const char *cadena[] = {"Uno",
"Dos", "Tres"};
Para poder crear este tipo de arreglo, es necesario
utilizar punteros (o usar la clase string). A continuación un ejemplo:
#include<iostream>
using
std::cout;
using
std::endl;
int
main(){
const char *cadena[3] =
{"Uno", "Dos","Tres"};
cout <<
"El segundo elemento es: " << cadena[1];
return 0;
}
Y para mostrar el contenido del arreglo, usamos un
bucle.
#include<iostream>
using
std::cout;
using
std::endl;
int
main(){
const char *cadena[] =
{"Uno", "Dos","Tres"};
cout << "La cadena es:
";
for (int i = 0; i < 3; i++){
cout << cadena[i] << "
";
}
cout << "\n";
return 0;
}
Así cómo es posible acceder a cada uno de los índices
de un arreglo de caracteres, también es posible acceder a cada letra de un
índice, para ello es necesario usar un arreglo bidimensional.
#include<iostream>
using
std::cout;
using
std::endl;
int
main(){
const char *cadena[] =
{"Uno", "Dos","Tres"};
cout <<
"La segunda letra del primer indice es: " << cadena[0][1] <<
endl;
return 0;
}
Esto es todo por ahora. Saludos
Gustavo J. Cerda Nilo
Enero 2018
