ARREGLOS EN PROGRAMACIÓN.

Un arreglo es una colección de datos del mismo tipo, que se almacenan en

posiciones consecutivas de memoria y reciben un nombre común. Un arreglo
puede tener una colección finita, homogénea y ordenada de elementos. Finita:
Todo arreglo tiene un límite; es decir, debe determinarse cuál será el número
máximo de elementos que podrán formar parte del arreglo. Homogénea: Todos
los elementos del arreglo deben ser del mismo tipo. Ordenada: Se puede
determinar cuál es el primer elemento, el segundo, el tercero,.... y el n-ésimo el
elemento.

Tipos de arreglos

Arreglos unidimensionales.

Arreglos multidimensionales.

Arreglo con múltiple subíndices.

Arreglos unidimensionales

Es un tipo de datos estructurado que está formado de una colección finita y

ordenada de datos del mismo tipo. Es la estructura natural para modelar listas
de elementos iguales. Están formados por un conjunto de elementos de un
mismo tipo de datos que se almacenan bajo un mismo nombre, y se diferencian
por la posición que tiene cada elemento dentro del arreglo de datos. Al declarar
un arreglo, se debe inicializar sus elementos antes de utilizarlos. Para declarar
un arreglo tiene que indicar su tipo, un nombre único y la cantidad de
elementos que va a contener.

Arreglos multidimensionales

Es un tipo de dato estructurado, que está compuesto por dimensiones. Para

hacer referencia a cada componente del arreglo es necesario utilizar n índices,
uno para cada dimensión. El término dimensión representa el número de
índices utilizados para referirse a un elemento particular en el arreglo. Los
arreglos de más de una dimensión se llaman arreglos multidimensionales.

Arreglos con múltiple subíndices

Es la representación de tablas de valores, consistiendo de información

arreglada en renglones y columnas. Para identificar un elemento particular de
 la tabla, deberemos de especificar dos subíndices; el primero identifica el
renglón del elemento y el segundo identifica la columna del elemento. A los
arreglos que requieren dos subíndices para identificar un elemento en particular
se conocen como arreglo de doble subíndice. Note que los arreglos de
múltiples subíndices pueden tener más de dos subíndices. El estándar ANSI
indica que un sistema ANSI C debe soportar por lo menos 12 subíndices de
arreglo.

Declaracion en C de los arreglos Undimensionales y bidimensionales

Arreglos unidimensionales en C++

Los arreglos (array) son un conjunto de valores que se relacionan por medio de
un nombre en común. También se puede decir que son datos que se
almacenan bajo el mismo nombre y para diferenciarlos se utiliza un índice.

En el lenguaje C++ un arreglo puede tener varias dimensiones, en esta ocasión

hablaremos de los arreglos unidimensionales (una dimensión).

Arreglos Unidimensionales

Un arreglo unidimensional es una lista de valores guardados bajo el mismo

nombre y del mismo tipo. Cada valor dentro del arreglo se le conoce como
elemento del arreglo.

Para declarar un arreglo unidimensional en C++ se utiliza la siguiente línea de

código:

tipo_dato identificador[tamaño];

En “tipo de dato” introduciremos que tipo de dato queremos (int, char, float..
etc) , luego en “identificador” introducimos como llamaremos a nuestro arreglo
para ubicarlo e identificarlo de manera rápida. Y entre los corchetes
colocaremos el tamaño que le demos a nuestro array. Quedando de esta
manera:

1 int arreglo[3];

Ya que tenemos declarado nuestro arreglo necesitamos declarar cada uno de

los elementos que lo conforman, para esto utilizamos lo siguiente:

1 arreglo[1]=valor;

Iniciamos con el nombre de nuestro arreglo en el apartado que dice arreglo,

entre los corchetes colocaremos que parte del array utilizaremos, en C++ los
valores se inician en 0, esto quiere decir que si nuestro arreglo es de tamaño 3,
al hacer nuestro índice hay que tomar el 0 como valor inicial quedando [0] , [1]
y [2] completando así nuestros 3 valores del tamaño antes mencionado.
En la parte “valor” asignaremos el valor que le daremos a ese elemento
quedando de la siguiente manera:

1 arreglo[1]=100;

Ejemplo: el siguiente programa carga el arreglo sqrs con los cuadrados de los
números del 1 al 10 y luego los visualiza

#include <iostream>
1
 
2
using namespace std;
3
 
4
int main()
5
{
6
    int sqrs[10];// forma un arreglo de tamaño 10
7
    int i;
8
 
9
    for (i=1;i<11;i++) {
10
        sqrs[i-1]=i*i;
11
    }// un ciclo for para ir aumentando el numero que elevaremos al cuadrado
12
y definir la operación.
13
 
14
    for (i=0;i<10;i++) {
15
        cout<<sqrs[i]<<endl;
16
    }//aumento de posición del índice del arreglo.
17
    
18
    return 0;
19
}

La forma como se almacenan los valores en el arreglo es la siguiente:

sqrs[0] = 1*1

sqrs[1] = 2*2

sqrs[2] = 3*3

sqrs[3] = 4*4

sqrs[4] = 5*5

sqrs[5] = 6*6

sqrs[6] = 7*7

sqrs[7] = 8*8

sqrs[8] = 9*9
sqrs[9] = 10*10

y muestra en pantalla:

 Arreglos Bidimensionales
Un arreglos bidimensional esta compuesto, por un conjunto de elementos
homogéneos y se puede acceder a los datos utilizando dos subíndices, este
tipo de arreglo es también conocido como matriz.

Declaración
Un arreglo bidimensional se define así:

int arreglo[10][10];
float matriz[10][10];
también podemos utilizar constantes para definir la dimensión del arreglo de
dos dimensiones:

const int N = 10;

int arreglo[N][N];

Inicialización

Una matriz o arreglo bidimensional se puede inicializar de este modo:

int matriz[3][3] = {{1,2,3},{4,5,6},{7,8,9}};

Con la anterior asignación se crea en memoria una matriz igual a la de abajo

0 1 2
 

0 1 2 3

1 4 5 6
 2 7 8 9

Fig. 8.1

También podemos utilizar una estructura for dentro de otra estructura for para

inicializar los valores de un arreglo de dos dimensiones como se muestra a
continuación:
Ejemplo 8.1
Leer desde teclado una matriz de números enteros de dimensión 3x3.

#include <iostream.h>
void main()
{
const int TAM=3;
int matriz[TAM][TAM];
for( int i=0; i<TAM ; i++)
{
for( int j=0; j<TAM; j++)
{
cout<<”Ingrese el elemento [“<<i<<”,“<<j<<”] “;
cin>>matriz[I][j];
}
}
}

El tipo de acceso a los arreglos unidimensionales es el

acceso directo, es decir, podemos acceder a cualquier
elemento del arreglo sin tener que consultar a elementos
anteriores o posteriores, esto mediante el uso de un índice
para cada elemento del arreglo que nos da su posición
relativa.
REPRESENTACION EN MEMORIA
Los arreglos se representan en memoria de la forma
siguiente:
                x : array[1..5] of integer
Para establecer el rango del arreglo (número total de
elementos) que componen el arreglo se utiliza la siguiente
formula:

  RANGO = Ls - (Li+1)
donde:
ls = Límite superior del arreglo
li = Límite inferior del arreglo
Para calcular la dirección de memoria de un elemento dentro
de un arreglo se usa la siguiente formula:
                 A[i] = base(A) + [(i-li) * w]
donde :
A = Identificador único del arreglo
i = Indice del elemento
li = Límite inferior
w = Número de bytes tipo componente
Si el arreglo en el cual estamos trabajando tiene un índice
numerativo utilizaremos las siguientes fórmulas:
                RANGO = ord (ls) - (ord (li)+1)

                A[i] = base (A) + [ord (i) - ord (li) * w]

Acceso a los elementos de un arreglo bidimensional

En un arreglo de dos dimensiones necesitamos también dos índices para

acceder a sus elementos.

Si utilizamos: matriz[i][j], entonces i se refiere a la fila y j a la columna.

Para acceder al elemento de la segunda fila y segunda columna de la matriz de
la Fig. 8.1 hacemos:

int nro = matriz[1][1];

En la variable nro se guardara el número 5.

Las matrices o arreglos bidimensionales se suelen utilizar en cálculos

matemáticos, operaciones con matrices, recorridos por matrices, y cualquier
uso que nosotros le podamos dar.

Se pueden definir arreglos de más de 2 dimensiones, pero su manejo se

dificultaría enormemente.

Recorrer un Array en C++

Para obtener todos los datos que se encuentran al interior de un arreglo, es

necesario recorrer el array o vector, para recorrerlo, se usa casi siempre un
ciclo for, en algunos casos mas específicos un ciclo while, pero generalmente
el ciclo for es el ideal para esto, dado que conocemos el tamaño del array. La
lógica de este procedimiento es la siguiente, el ciclo for comenzara desde cero
e ira hasta el tamaño del vector, de modo que la variable de control que
generalmente llamamos "i", será la que va a ir variando entre cero y el tamaño
del array, de esta forma al poner la i al interior de los corchetes, estaremos
accediendo al valor de cada casilla del vector y podremos hacer lo que sea
necesario con dicho valor, veamos:
Nota: A veces no es posible determinar con facilidad el tamaño exacto de un
vector, pero en C++ existen varias formas de determinar el tamaño de un array
o vector fácilmente, aquí explicare un método. Cabe notar que este tamaño es
el que ira como tope del ciclo for y sería equivalente a que nosotros mismos, en
caso de saber el tamaño del vector, lo pongamos allí, sin embargo como
veremos en otra sección no siempre es posible saber con certeza el tamaño de
un vector, es por esto que explico cómo hacerlo.

#include "iostream"

using namespace std;

int main()

int edades[] = {1,2,9,8,16,32,9,50,36,20,1,87};

int limite = (sizeof(edades)/sizeof(edades[0]));

for (int i = 0; i < limite; i++)

cout<<edades[i]<<endl;

Vamos a ver de forma resumida en qué consiste y que hace cada una de estas
líneas

Línea 1:

Tenemos en la primera línea la declaración de un vector que contiene las

edades de 12 personas, notemos que entre los corchetes no se puso ningún
numero, pues no es necesario, ya que el vector tendrá el tamaño según la
cantidad de elementos que declaremos entre las llaves, evidentemente si
pusiéramos un 12 entre los corchetes, no habría ningún problema.
Línea 2:

En la segunda línea, tenemos la declaración del límite del ciclo o en otras

palabras el tamaño del array. El tamaño de un array se puede calcular de
varias formas, aquí lo obtenemos calculando el tamaño del array entero,
dividido por el tamaño del primer elemento de dicho array, para mas detalles de
esto, verifica la información sobre el operador sizeof.

Línea 3 a 6:

Desde la tercera línea hasta la sexta, tenemos entonces un ciclo for que
comienza en cero y termina en el límite (es importante notar que la condición
usada es estrictamente menor "<" y no menor o igual "<="), al interior de este
ciclo, es donde accedemos a cada uno de los elementos del vector por medio
de la sintaxis explicada anteriormente

Línea 5:

La quinta línea es quizá la más vital aunque sin las demás no tendríamos nada.
En esta línea, estamos accediendo a cada uno de los elementos del array de
edades, un elemento por cada vuelta que da el ciclo, accedemos a cada
elemento poniendo entre los corchetes la variable i, que es la que esta
cambiando a medida que el ciclo va girando, así estaremos accediendo a todos
los elementos e imprimiéndolos por pantalla

¿Cómo inicializar un Array en C++?

En cuanto tenemos declarado un vector, es posible asignarle valores,

evidentemente estos valores deben coincidir con el tipo de dato que le
asignamos a dicho vector, no tendría sentido ingresar como valores de un
vector cadenas de caracteres si el tipo de dato de dicho vector es numérico.

string vector[5] = {"5", "hola", "2.7", "8,9", "adios"};

Aquí hemos declarado un vector de tipo string tamaño 5 y lo hemos inicializado

con diferentes valores, es necesario notar que cada valor va entre comillas
dobles "" puesto que son strings. El valor inicial corresponde a la casilla o
índice 0 y tiene el valor de "5", el índice 1 el valor es "hola" y el índice 4 el valor
es "adiós", es importante notar que el primer índice de n array o vector no es el
UNO sino que es el CERO.
Referencias

 Schildt Herbert, C++ Para programadores. McGraw-Hill. 1996

 Lenguaje C++ Arreglos unidimensionales y multidimensionales. Prof.
Elías Cisneros República Bolivariana de Venezuela Aldea Universitaria
Fray Pedro de Agreda PNFSI 2009