ARREGLOS UNIDIMENSIONALES Y BIDIMENSIONALES

Arreglo: Es un espacio creado en memoria que se usa para guardar un conjunto de datos
del mismo tipo.
Arreglo Unidimensional: Puede ser accedido mediante un solo subndice (i).
Arreglo Bidimensional: Puede ser accedido mediante 2 subndices (i, j).
Subndice: Es una variable de tipo entero que siempre inicia en 0, su funcin es permitir el
acceso a las posiciones del arreglo. Generalmente se le asignan nombres cortos. Ejemplo: i,
j, ant, sig, etc. Un subndice recorre las posiciones del arreglo.
SINTAXIS DE UN ARREGLO
A[3] = 6
Donde A es el nombre del arreglo, 3 es la posicin donde se desea acceder y 6 es el valor
asignado.

Ejercicio: Llenar un arreglo B de 3 posiciones con los valores 3, 9, 12.

1. Para declarar el arreglo se hace lo siguiente:
int B[3];
2. Para llenar el arreglo se hace los siguiente:
B[0] = 3;
B[1] = 9;
B[2] = 12;
3. El arreglo queda as:
3
0

9
1

12
2

En este arreglo he marcado las posiciones con color rojo. La posicin 0 del arreglo B
contiene el valor 3, la posicin 1 del mismo arreglo B contiene el valor 9 y la posicin
2 del mismo arreglo B contiene el valor 12.

En lenguaje C, quedara as:

Al compilarlo muestra lo siguiente:

Tengan en cuenta que en la declaracin, estamos diciendo int B[3], es decir, es un arreglo de
3 posiciones, pero al recorrerlo debemos usar las posiciones 0, 1 y 2 (fjense que son 3
posiciones). Si queremos usar un arreglo de 6 posiciones, se recorren las posiciones 0, 1, 2,
3, 4 y 5.

Ahora imaginen que necesitamos llenar y recorrer un arreglo de 5000 posiciones. No resulta
prctico llenar y recorrer posicin por posicin. Para dar solucin a esta situacin, usamos
ciclos.
Vamos a hacer el ejercicio anterior, usando el ciclo for.

Hice un ciclo for para llenar los valores del arreglo y otro ciclo for para imprimirlos. La
variable i comienza en 0 y va aumentando hasta llegar a 2. Cuando queda en 3 se sale.
Realizare una prueba de escritorio para que quede ms claro.
i
0
1
2
3

B[i]
B[0]= 3
B[1]= 9
B[2]= 12
Cuando i vale 3 se
sale del ciclo.

Fjense que B en la posicin 0 tiene un 3, en la posicin 1 tiene un 9 y en la posicin 2 tiene

un 12. La variable encargada de tomar los valores 1, 2 y 3 es i.

Ejercicio:
Hacer un programa que permita llenar con valores mltiplos de 3 un arreglo A de 9
posiciones.

Para solucionar este ejercicio usar el ciclo While, por favor comprenlo con el ejercicio
anterior que estaba resuelto con el ciclo For.

Les explicar el cdigo lnea por lnea:

//Declaro las librerias

#include "stdafx.h"
#include "iostream"
#include "stdlib.h"
#include "conio.h"
#include "math.h"
using namespace std;
//Funcin principal
void main()
{
//Declaracin del Arreglo A que almacenar 9 valores de tipo entero, tambin estoy declarando la variable i
//y la varibale num de tipo entero
//En num se guardar el valor capturado desde el teclado
int A[9], i=0, num;
//Por medio del subndice i se recorrer el arreglo A, si observan desde la declaracin de datos i comienza en 0
//El ciclo while permite que i no pase de la posicin 8, en total desde 0 hasta 8 hay 9 posiciones
while (i<=8)
{
// por teclado se captura un nmero
cout<<"Ingrese un nmero "<< endl;
cin >>num;
// el condicional evala si el nmero ingresado es mltiplo de 3. Recuerden que el smbolo %, obtiene el mod
// de un nmero. Ejemplo: 7 % 5 = 2. Esto se lee, 7 mod 5 es 2.
if (num % 3 == 0)
{
//pasamos al arreglo A el nmero ingresado. Fjense que esto ocurre solo si dicho nmero es mltiplo de 3
A[i]=num;
//i incrementa para alistar el arreglo en la siguiente posicin
i++;
}
else
{
//si el nmero no es mltiplo de 3 le recuerda al usuario mediante un mensaje
//que debe ingresar nmeros mltiplos de 3
cout<< "Recuerde ingresar unicamente valores mltiplos de 3 "<<endl;
}
}
//cuando finaliza el ciclo while en el arreglo A ya estn almacenados 9 valores mltiplos de 3
//si se fijan bien al terminar el ciclo while i qued en 9, de lo contrario no se hubiera salido del ciclo

//como ahora vamos a volver a recorrer el arreglo

//en esta oportunidad para imprimirlo
//volvemos a usar la variable i como subndice, esto no afecta lo que ya hizo el algoritmo
//es necesario hacer que i vuelva a comenzar en 0 y con el ciclo while validamos para que no se pase de 8
//recuerden que estamos haciendo que i recorra el arreglo desde la posicin 0 hasta la posicin 8
i=0;
while (i<=8)
{
cout<< "El arreglo en la posicion " << i << " contiene el valor " << A[i]<<endl;
i++;
}
getch();
}