Arreglos en c++
Sirven para manejar vectores y los arreglos bidimensionales para matrices. Sin embargo, las matrices
tambien se pueden almacenar mediante arreglos unidimensionales y por medio de apuntadores a
apuntadores, temas que se ver´an en el cap´ıtulo siguiente.
La palabra unidimensional no indica que se trata de vectores en espacios de dimensi´on uno; indica
que su manejo se hace mediante un sub´ındice. El manejo de los arreglos bidimensionales se hace mediante
dos sub´ındices.
Arreglos unidimensionales
El siguiente ejemplo muestra la definici´on de tres arreglos, uno de 80 elementos doble precisi´on, otro
de 30 elementos enteros y uno de 20 elementos tipo car´acter.
double x[80];
int factores[30];
char codSexo[20];
Los nombres deben cumplir con las normas para los identificadores. La primera l´ınea indica que se han
reservado 80 posiciones para n´umeros doble precisi´on. 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 ´ultimo 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´an fuera del rango previsto; esto es responsabilidad del programador.
Por ejemplo, si en alg´un momento el programa debe utilizar x[90], lo usa sin importar si los resultados
son catastr´oficos.
Cuando un par´ametro de una funci´on es un arreglo, se considera impl´ıcitamente que es un par´ametro
por referencia. O sea, si en la funci´on se modifica alg´un elemento del arreglo, entonces se modific´o realmente
el valor original y no una copia. Pasar un arreglo como par´ametro de una funci´on y llamar esta
funci´on es muy sencillo. Se hace como en el esquema siguiente.
... funcion(..., double x[], ...); // prototipo
//------------------------------------------------
int main(void)
{
double v[30];
...
... funcion(..., v, ...); // llamado a la funcion
59
5. ARREGLOS
...
}
//------------------------------------------------
... funcion(..., double x[],...)// definicion de la funcion
{
// cuerpo de la funcion
...
}
Arreglos multidimensionales
La declaraci´on de los arreglos bidimensionales, caso particular de los arreglos multidimensionales, 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 £ 4 = 12 elementos doble precisi´on. El primer sub´ındice
var´ıa entre 0 y 2, y el segundo var´ıa entre 0 y 3. Usualmente, de manera an´aloga a las matrices, se dice
que el primer sub´ındice indica la fila y el segundo sub´ındice indica la columna.
Un arreglo tridimensional se declarar´ıa as´ı:
double c[20][30][10];
Los sitios para los elementos de a est´an contiguos en el orden fila por fila, o sea, a[0][0], a[0][1],
a[0][2], a[0][3], a[1][0], a[1][1], a[1][2], a[1][3], a[2][0], a[2][1], a[2][2], a[2][3].
En el siguiente ejemplo, el programa sirve para leer matrices, escribirlas y calcular el producto. Lo
hace mediante la utilizaci´on de funciones que tienen como par´ametros arreglos bidimensionales.
// Arreglos bidimensionales
// Lectura y escritura de 2 matrices y calculo del producto
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
//------------------------------------------------
void lectA0(double a[][40], int m, int n, char c );
void escrA0(double a[][40], int m, int n );
int prodAB0(double a[][40], int m, int n, double b[][40],
int p, int q, double c[][40]);
//================================================
int main()
{
double a[50][40], b[20][40], c[60][40];
int m, n, p, q;
printf("\n Producto de dos matrices.\n\n");
printf(" num. de filas de A : ");
scanf( "%d", &m);
printf(" num. de columnas de A : ");
scanf( "%d", &n);
// es necesario controlar que m, n no son muy grandes
// ni negativos
printf(" num. de filas de B : ");
scanf( "%d", &p);
printf(" num. de columnas de B : ");
scanf( "%d", &q);
// es necesario controlar que p, q no son muy grandes
ARREGLOS MULTIDIMENSIONALES
// ni negativos
if( n != p ){
printf(" Producto imposible\n");
exit(1);
}
lectA0(a, m, n, 'A');
printf(" A : \n");
escrA0(a, m, n);
lectA0(b, n, q, 'B');
printf(" B : \n");
escrA0(b, n, q);
if( prodAB0(a,m,n, b,p,q, c) ){
printf(" C : \n");
escrA0(c, m, q);
}
else printf("\ ERROR\n");
return 0;
}
//================================================
void lectA0(double a[][40], int m, int n, char c )
{
// lectura de los elementos de una matriz.
int i, j;
for( i = 0; i < m; i++){
for( j=0; j < n; j++){
printf(" %c[%d][%d] = ", c, i+1, j+1);
scanf("%lf", &a[i][j] );
}
}
}
//------------------------------------------------
void escrA0(double a[][40], int m, int n )
{
// escritura de los elementos de una matriz
int i, j;
int nEltosLin = 5; // numero de elementos por linea
for( i = 0; i < m; i++){
for( j = 0; j < n; j++){
printf("%15.8lf", a[i][j]);
if((j+1)%nEltosLin == 0 || j==n-1)printf("\n");
}
}
}
//------------------------------------------------
int prodAB0(double a[][40], int m, int n, double b[][40],
ARREGLOS
int p, int q, double c[][40])
{
// producto de dos matrices, a mxn, b pxq
// devuelve 1 si se puede hacer el producto
// devuelve 0 si no se puede
int i, j, k;
double s;
if(m<0||n<0||p<0||q<0 || n!= p ) return 0;
for( i=0; i < m; i++){
for( j=0; j < q; j++){
s = 0.0;
for( k=0; k<n; k++) s += a[i][k]*b[k][j];
c[i][j] = s;
}
}
return 1;
}
No hay comentarios:
Publicar un comentario