Professional Documents
Culture Documents
Arreglos en C++
Los arreglos (arrays) permiten almacenar vectores y matrices. Un arreglo es una colección ordenada de
variables del mismo tipo. Las variables que pertenecen a un arreglo se conocen por el nombre de
elementos. El término ordenado significa que en la colección hay un primer elemento, un segundo elemento,
un tercer elemento, y así sucesivamente. Además, los elementos pueden a su vez organizarse en subgrupos
llamadas dimensiones. El subgrupo más pequeño posible se conoce como un arreglo de una dimensión. Un
arreglo de dos dimensiones se subdivide en arreglos de una dimensión. Un arreglo de tres dimensiones se
subdivide en arreglos de dos dimensiones los cuales a su vez se dividen en arreglos de una dimensión. Un
arreglo de cuatro dimensiones se subdivide en arreglos de tres dimensiones los cuales a su vez se dividen en
arreglos de dos dimensiones los cuales a su vez se dividen en arreglos de una dimensión. La misma idea se
aplica en arreglos de más dimensiones.
En resumen, un arreglo:
1. El tipo de los elementos (ejemplo, int, char, double, bool o un tipo definido por el programador).
2. El nombre del arreglo.
3. La cantidad de dimensiones y sus tamaños; cada dimensión comienza con el signo [ seguido por el tamaño
de la dimensión y termina con el signo ].
Arreglos Unidimensionales
Los arreglos unidimensionales sirven para manejar vectores. La palabra unidimensional no indica que se
trata de vectores en espacios de dimensión uno; indica que su manejo se hace mediante un subíndice.
El siguiente ejemplo muestra la definición de tres arreglos, uno de 80 elementos doble precisión, otro de 30
elementos enteros y uno de 20 elementos tipo carácter.
double x[80];
int numeros[30];
char nombre[20];
La primera línea indica que se han reservado 80 posiciones para números con doble precisión. Estas
posiciones son contiguas. Es importante recalcar que en C++, a diferencia de otros lenguajes, el primer
elemento es x[0], el segundo es x[1], el tercero es x[2], y así sucesivamente; el último elemento es x[79]. En
x hay espacio reservado para 80 elementos, pero esto no obliga a trabajar con los 80; el programa puede
utilizar menos de 80 elementos.
C++ no controla si los subíndices están fuera del rango previsto; esto es responsabilidad del programador.
Por ejemplo, si en algún momento el programa debe utilizar x[90], lo usa sin importar si los resultados son
catastróficos.
Bueno chamacos, ahora vamos a lo bueno, a continuación les mostraré algunos ejemplos utilizando arreglos
unidimensionales sale…
}
cout <<"La Serie De Números es la Siguiente:"<<endl;
cout<<"|";
//Con este ciclo desplegamos la serie de números almacenados en el vector
for (i=0; i<=9; i++){
cout <<numeros[i]<<"|";
}
getch();
}
int numeros[10],i,num=3;
En esta línea declaro un arreglo de tipo entero de una sola dimensión y de tamaño 10, es decir, numeros[10].
numeros es el nombre del arreglo y [10] indica el tamaño, en nuestro caso es 10. las otras variables son i la
cual la utilizo como contador en el ciclo for y num que es utilizada para los números del arreglo, a ésta la
inicializo en tres que es el primer número de la serie.
En este momento se me hace indispensable mostrar mediante una prueba de escritorio lo que sucede con el
primer ciclo, para lo cual les mostraré el código y su respectiva tablita: Tomando en cuenta que num=3
Como pueden ver siguiendo al pie de la letra la tablita anterior, en realidad es el código explicado de manera
clara, y el siguiente ciclo lo único que hace es mostrar en la pantalla el contenido del vector numeros, es
decir, 3 6 9 … 30.
Bueno pues, el ejemplo anterior será el único ejemplo que comentaré, lo cual quiere decir que los siguientes
ejemplos quedará de ustedes entenderlos y si no logran captarlos a la primera, pues ya saben chamacos,
realicen la prueba de escritorio y seguramente los comprenderán y en otro caso, pues investiguen.
Arreglos Bidimensionales
Los arreglos bidimensionales son parecidos a una tabla, es decir, con filas y columnas y son conocidos como
Matrices. La declaración de los arreglos bidimensionales, se hace como en el siguiente ejemplo:
double a[3][4];
int pos[10][40];
char list[25][25];
En la primera línea se reserva espacio para 3 x 4 = 12 elementos doble precisión. El primer subíndice varía
entre 0 y 2, y el segundo varía entre 0 y 3. Usualmente en las matrices se dice que el primer subíndice indica
la fila y el segundo subíndice indica la columna.
cout<<"|";;
for (i=0; i<3; i++){
for (j=0; j<3; j++){
cout <<tabla[i][j]<<"|";
}
cout<<endl;
if (i<2){
cout<<"|";
}
}
getch();
}
Bueno, comenzaré diciéndoles que una matriz o arreglo bidimensional es algo así como una tabla, es decir,
con filas y columnas, en nuestro caso la matriz se llama tabla y es de dimensión o tamaño [3][3], esto quiere
decir que cuenta con 3 filas y tres columnas. Cada fila y cada columna cuenta con un subíndice. Para
comprender esto mucho mejor, se los voy a explicar con una tablita sale…
Subíndice j
Esto quiere decir que si pensamos en la salida del ejemplo del código anterior, los elementos de la matriz
estarían almacenados de la siguiente forma:
7 5 1
4 5 7
1 1 3
Entonces si quisiéramos hacer referencia al elemento que contiene el número 4, su posición seria tabla[1][0].
Y si quisiéramos hacer referencia al elemento que contiene el numero 3, su posición sería tabla[2][2].
Dada esta explicación, pienso que el código del ejemplo anterior es demasiado comprensible ya que tiene
comentarios explícitos, y de no ser así, pues para eso estoy en clase con ustedes para despejar cualquier duda.
Los siguientes ejemplos también son de matrices o arreglos bidimensionales, ojala y los lean detenidamente y
los comprendan.
}
}
//Solicitamos al usuario los elementos de la MatrizB
cout<<endl<<endl<<"Ingresando elementos de la Matriz B"<<endl;
for (i=0; i<3; i++){
for (j=0; j<3; j++){
cout<<"Ingrese el elemento "<<i<<","<<j<<" de la Matriz B: ";
cin>>MatrizB[i][j];
}
}
//Mostramos en la pantalla el contenido de la MatrizA
cout<<endl;
for (i=0; i<3; i++){
for (j=0; j<3; j++){
cout <<MatrizA[i][j]<<"\t";
}
cout<<endl;
}
cout<<endl<<"\tX"<<endl;
//Mostramos en la pantalla el contenido de la MatrizB
cout<<endl;
for (i=0; i<3; i++){
for (j=0; j<3; j++){
//cout <<MatrizB[i][j]<<"|";
cout <<MatrizB[i][j]<<"\t";
}
cout<<endl;
}
cout<<endl<<"\t="<<endl;
//Realizamos el producto de la MatrizA y MatrizB
for(i=0;i<3;i++){
for(j=0;j<3;j++){
MatrizProd[i][j]=0;
for(k=0;k<3;k++){
MatrizProd[i][j]=MatrizProd[i][j]+(MatrizA[i][k]*MatrizB[k][j]);
}
}
}
//Mostramos el producto de las Matrices MatrizProd
cout<<endl;
for(i=0;i<3;i++){
for(j=0;j<3;j++){
cout<<MatrizProd[i][j]<<"\t";
}
cout<<endl;
}
getch();
}
Bueno pues hasta aquí termina lo relacionado a los arreglos, espero y le hayan entendido aunque sea a un
80%, si no es así, pues en clase lo veremos mucho mejor.