Arreglos y punteros, incluyendo la

declaración y utilización de arreglos y el

uso de punteros para acceder a los
elementos de un arreglo. Ejemplos.

Prof. Lic. C. Martín Cruz Salazar

Email: ccruz@uni.edu.pe
 ARREGLO
Un arreglo es una estructura de datos que almacena una colección de
datos como enteros, reales, cadenas, etc.
Estos datos a menudo se denominan elementos del arreglo.
Poder almacenar elementos en un arreglo ayuda a reducir la cantidad
de tiempo necesario para declarar e inicializar variables.
Por ejemplo, si quisiera almacenar las edades de todos los miembros
de la familia en su hogar, normalmente tendría que declarar e
inicializar las variables con las edades de cada miembro de la familia.

int Allan = 71;

int Bob = 42;
int Carol = 37;
int David = 5;
int Ellen = 18;
cout << Allan << endl;
 ARREGLO
Para evitar la tarea repetitiva de declarar e inicializar múltiples
variables, puede declarar un arreglo y asignar directamente valores
o elementos a ese arreglo como se muestra a continuación.

int ages[] = {71, 42, 37, 5, 18};

En C++ los índices de un arreglo siempre tienen como límite inferior

0 como índice superior el tamaño del arreglo menos 1.
Cuando se escribe un arreglo se coloca el tipo de dato de los elementos
del arreglo seguido por el nombre del arreglo y corchetes. Va el signo
de asignación y dentro de llaves los elementos separados por comas.
El primer elemento empieza en el índice 0 y el último elemento es el
Tamaño menos 1.
 SINTAXIS DEL ARREGLO SIN ELEMENTOS
int ages[5];

Es necesario colocar el tipo de dato, el nombre de la variable y entre

corchetes colocar el tamaño del arreglo.
 ACCESANDO UN ARREGLO
Para acceder a los elementos del arreglo e imprimirlos, debe
conocer su posición. La posición en la que se almacena un elemento
se denomina índice. Por ejemplo, nombres[0] se refiere al primer
elemento del arreglo llamado nombres. Los índices del arreglo
siempre comienzan en 0 y se incrementan en 1 con cada elemento
que viene a continuación.
Debido a esto, los números [4] se refieren al quinto elemento del
arreglo, no al cuarto.

string names[] = {"Alan", "Bob", "Carol", "David", "Ellen"};

cout << names[0] << endl;
 QUE IMPRIME ESTE CODIGO?
string names[] = {"Alan", "Bob", "Carol", "David", "Ellen"};
cout << names << endl;

Notará que imprime una dirección de memoria.

 MODIFICANDO UN ARREGLO

Para modificar un elemento dentro de un arreglo, simplemente

busque el índice en el que se almacena ese elemento y asígnele un
nuevo valor.

int grades[] = {85, 95, 48, 100, 92};

cout << grades[2] << endl;
grades[2] = 88; //88 reemplazará a 48 en el índice 2
cout << grades[2] << endl;
 ITERANDO UN ARREGLO

string friends[] = {"Alan", "Bob", "Carol", "David", "Ellen",

"Fred", "Grace", "Henry", "Ian", "Jen"};
for (int i = 0; i < 10; i++) {
cout << friends[i] << endl;
}
Tamaño del arreglo
Para facilitar el proceso de iteración, podemos usar el operador
sizeof() para determinar cuántos elementos hay en nuestro arreglo.
Para usar sizeof(), simplemente llámelo usando la palabra clave sizeof
seguida del nombre del arreglo entre paréntesis ().
 TAMAÑO DE UN ARREGLO

string friends[] = {"Alan", "Bob", "Carol", "David", "Ellen",

"Fred", "Grace", "Henry", "Ian", "Jen"};
cout << sizeof(friends) << endl;

¿Por qué el tamaño de (friends) genera 320?

Desafortunadamente, el operador sizeof() no determina el número de
elementos dentro de un arreglo. En su lugar, sizeof() calcula el
tamaño del arreglo en bytes. En C++, una cadena ocupa 32 bytes y
dado que hay 10 elementos de cadena en el arreglo, el tamaño del
arreglo en bytes es 320.
Para calcular el número de elementos dentro de un arreglo,
necesitaremos usar sizeof() dos veces.
 TAMAÑO EXACTO DE UN ARREGLO

string friends[] = {"Alan", "Bob", "Carol", "David", "Ellen",

"Fred", "Grace", "Henry", "Ian", "Jen"};
cout << sizeof(friends) / sizeof(friends[0]) << endl;

sizeof(friends) calcula el tamaño de la matriz en bytes y

sizeof(friends[0]) calcula el tamaño del primer elemento en bytes. Al
dividir el tamaño de la matriz por el tamaño del elemento, pudimos
determinar la cantidad de elementos que existen dentro de la matriz.
Tenga en cuenta que no importa si calculamos el tamaño del primer
elemento o el segundo, ya que todos los elementos tienen el mismo
tamaño (32 bytes cada uno).
 ITERANDO A TRAVES DE LOS ELEMENTOS DE UN
ARREGLO

string friends[] = {"Alan", "Bob", "Carol", "David", "Ellen",

"Fred", "Grace", "Henry", "Ian", "Jen"};

for (int i = 0; i < sizeof(friends) / sizeof(friends[0]); i++) {

cout << friends[i] << endl;
}
 BUCLE FOR MEJORADO

Bucle for que se puede usar con arreglos llamado bucle for mejorado.
Se puede usar para iterar a través de elementos del arreglo sin tener
que hacer referencia a ningún índice del arreglo. Para usar un bucle
for mejorado, necesita lo siguiente:
* La palabra clave for seguida de paréntesis ().
* Una variable de iteración escrita seguida de dos puntos: seguida del
nombre del arreglo.
* Tenga en cuenta que la variable de iteración debe ser del mismo
tipo que el arreglo.
* Cualquier comando que se repita entre llaves {}.
* Tenga en cuenta que cuando usa un bucle for mejorado, puede
imprimir la variable de iteración sin usar corchetes [].
 BUCLE FOR MEJORADO

string friends[] = {"Alan", "Bob", "Carol", "David", "Ellen",

"Fred", "Grace", "Henry", "Ian", "Jen"};

for (string i : friends) {

cout << i << endl;
}
 ALGO IMPORTANTE PARA EL USO DEL FOR MEJORADO

Una de las principales diferencias entre un bucle for regular y un bucle

for mejorado es que un bucle for mejorado no se refiere a ningún índice
o posición de los elementos en el arreglo. Por lo tanto, si necesita
acceder o modificar elementos del arreglo, no puede usar un bucle for
mejorado. Además, no puede usar un bucle for mejorado para iterar a
través de una parte del arreglo. Piense en un bucle for mejorado como
un bucle de todo o nada que simplemente imprime todos los elementos
del arreglo o nada en absoluto.
Tenga en cuenta que el tipo de variable iterativa debe coincidir con el
tipo del arreglo.
Por ejemplo, no puede usar for (int i: friends) ya que friends es un
arreglo de cadenas e i es una variable entera. Use for (string i: friends) en
su lugar.
 ARREGLOS BIDIMENSIONALES

Los arreglos vistos anteriormente se conocen como arreglos

unidimensionales (una sola dimensión) y se caracterizan por tener un
solo subíndice. Estos arreglos se conocen también como listas. Los
arreglos multidimensionales son aquellos que tienen más de una
dimensión y, en consecuencia, más de un índice. Los arreglos más
usuales son los de dos dimensiones o bidimensionales, conocidos
también por el nombre de tablas o matrices, sin embargo, es posible
crear arreglos de tantas dimensiones como requieran sus aplicaciones,
esto es, tres, cuatro o más dimensiones.
 ARREGLO BIDIMENSIONAL
Un arreglo de dos dimensiones equivale a una tabla con múltiples filas y
múltiples columnas, ver figura:

Obsérvese que, en el arreglo bidimensional de la Figura, las filas se etiquetan de 0 a m

y las columnas de 0 a n, el número de elementos que tendrá el arreglo será el resultado
del producto (m+1)x(n+l).
 ARREGLO BIDIMENSIONAL

Declaración de un arreglo bidimensional:

tipo nombre_arreglo[filas][columnas]
Acceso
nombre_arreglo[indice1][indice2]
Extracción
nombre_variable=nombre_arreglo[indice1][indice2]

Inicialización
int matriz[3][4]={{4,10,0,3},{-1,12,4,3},{0,-4,-15,9}};
 ARREGLO BIDIMENSIONAL

Ejemplos de inserciones
Tabla[2][31]= 4.5;
Resistencias[2][4]=50;
AsientosLibres[5][12] = 5;

Y de extracción de valores:
ventas = Tabla[2][1];
dia = Semana[3][6];
 ARREGLO BIDIMENSIONAL: Ejemplo
Lee valores desde el teclado para llenar la tabla «valores_reales» y luego
imprime la tabla.
#include <iostream>
using namespace std;
int main()
{
float valores_reales[2][4];
int fila, col;
for(fila=0; fila<2; fila++)
{
printf("Ingrese fila %d :",fila+1);
for(col=0; col<4; col++)
cin >> valores_reales[fila][col];
}
//Visualizar la tabla
for(fila=0; fila<2; fila++)
{
for(col=0; col<4; col++){
printf("\t%.1f",valores_reales[fila][col]);
}
cout << endl;
}
}
 ARREGLO BIDIMENSIONAL: Ejemplo
Escriba un programa que pida las dimensiones de una matriz y genere sus
elementos con los primeros números. Imprima en forma de una matriz
#include <iostream>
using namespace std;
int main() {
int filas, columnas;
// Solicitar las dimensiones de la matriz al usuario
cout << "Ingrese el numero de filas de la matriz: ";
cin >> filas;
cout << "Ingrese el numero de columnas de la matriz: ";
cin >> columnas;
int matriz[filas][columnas];
// Generar la matriz con los primeros números
int contador = 1;
for (int i = 0; i < filas; i++) {
for (int j = 0; j < columnas; j++) {
matriz[i][j] = contador;
contador++;
}
}
// Imprime la matriz
cout << "La matriz generada es:" << endl;
for (int i = 0; i < filas; i++) {
for (int j = 0; j < columnas; j++) {
cout << matriz[i][j] << " ";
}
cout << endl;
}
return 0;
}
 PUNTERO

Un Puntero es una variable que contiene la dirección de otra variable.

Todas las variables vistas hasta este momento contienen valores de
datos, por el contrario, las variables punteros contienen valores que son
direcciones de memoria donde se almacenan datos. En resumen, un
puntero es una variable que contiene una dirección de memoria.
 DECLARANDO UN PUNTERO

La declaración de una variable puntero debe indicar al compilador el

tipo de dato al que apunta el puntero para ello se hace preceder a
su nombre con un asterisco mediante el siguiente formato :
<tipo de dato apuntado> *<identificador de puntero>

Ejemplos de variables punteros

▪ int* ptr1; //Puntero a un tipo de dato entero int
▪ long* ptr2; //Puntero a un tipo de dato entero largo long int
▪ char* ptr3; //Puntero a un tipo de dato char
▪ float* f; //Puntero a un tipo de dato float
 OPERADOR DE REFERENCIA

Referencia de puntero

A un puntero solo se le puede asignar una dirección de memoria. No se

les puede asignar valores que sean int, double, string, etc. Una dirección
de memoria se denota con el símbolo &, llamado operador de
referencia, y va delante de la variable con la que está asociada la
dirección.
 OPERADOR DEREFENCIA

int a = 5; //regular int variable set to 5

int* p = &a; //al puntero p se le asigna una dirección de memoria
cout << *p << endl; //dereference p para imprimir el contenido de la
//dirección de memoria.
 PUNTERO A OTRO PUNTERO

Es posible tener un puntero apuntando a otro puntero. Para asignar la

dirección de memoria de un puntero a un nuevo puntero, ese nuevo
puntero debe indicarse con dos símbolos de asterisco **.

int a = 5;
int* p = &a;
int** p2 = &p;
cout << *p << endl;
cout << **p2 << endl;
DESREFERENCIANDO
 ACCESO A UN ARREGLO USANDO PUNTEROS
int main()
{
int mi_arreglo[5];
mi_arreglo[0] = 10;//Asigno el valor 10 al primer elemento del arreglo
int *ptr_arreglo;
ptr_arreglo = mi_arreglo;
*(ptr_arreglo + 1) = 20;
ptr_arreglo[2] = 30;
for (int i = 0; i < 3; i++)
{
cout << *(ptr_arreglo + i) << ", ";
}
return 0;
}
EJERCICIO #1 : Escribir un programa que sume los elementos de un
arreglo dado. Usando punteros.

EJERCICIO #2 : Programa que pide cuantos números va a ingresar.

Se ingresan los números y se guardan en un arreglo para que luego se
sumen los elementos del arreglo.

EJERCICIO #3 : Leer un número n>1 definir un arreglo datos[n] y

asignarles valores aleatorios a sus elementos entre 0 y 99. Imprimir los
valores del arreglo de datos.