ARREGLO BIDIMENSIONAL

Un arreglo bidimensional tiene dos dimensiones y es un caso particular de los arreglos

multidimensionales. En C#, las dimensiones se manejan por medio de un par de
corchetes, dentro de los que se escriben, separados por comas, los valores de las dos
dimensiones.
La sintaxis para la declaracin de un arreglo de dos dimensiones es:
tipo_de_dato nombre_del_arreglo [NmerodeFilas] [NmerodeColumnas];
Algunos ejemplos de declaracin de arreglos bidimensionales son:
char lista[80][30];
int puestos[6][8] ;
int equipos[4] [30];
int matriz[4][2];
Los arreglos bidimensionales se pueden inicializar, al igual que los de una dimensin,
cuando se declaran. La inicializacin
consta de una lista de constantes separadas por comas y encerradas entre llaves, como
en los siguientes ejemplos:
int tabla[2][3] = {51, 52, 53, 54, 55, 56};
o bien en los formatos mas amigables:
int tabla[2][3]= { {51, 52, 53},
{ 54 , 55, 56}} ;
int tabla[2][3] = {{51, 52, 53}, {54, 55, 56}};
Se puede acceder a los elementos de un arreglo bidimensional de la misma manera que
se accede a los elementos de un
arreglo unidimensional, es decir, a travs de sus subndices. La diferencia es que en un
arreglo bidimensional hay que
especificar los subndices de las filas y las columnas.
tabla[2][3] = 4.5;
asientos[4][7] = 19;
ventas = tabla[2][5];
Las funciones de entrada o salida se aplican de igual forma a los elementos de un arreglo
bidimensional. Por ejemplo,

int tabla[3][4];
float resistencias[4][5];
scanf(%d, &tabla[2][3]);
printf(%d,tabla[1][1]);
scanf(%f, &resistencias[2][4]);
Se puede acceder a los elementos de un arreglo bidimensionales mediante bucles
anidados. Su sintaxis es:
int x,y, datos[5][5];
for(x = 0; x < 5; x++)
{
for(y=0; y < 5; y++)
{
scanf(%d, &datos[x][y]);
}
}
}
ARREGLOS DIMENSIONALES
Los arreglos (arrays) permiten almacenar
unidimensionales sirven para manejar vectores.

vectores

matrices.

Los

arreglos

La palabra dimensional no indica que se trata de vectores en espacios de dimensin uno;

indica que su manejo se hace mediante un subndice.
El siguiente ejemplo muestra la definicin de tres arreglos, uno de 80 elementos doble
precisin, otro
de 30 elementos enteros y uno de 20 elementos tipo carcter.
double x[80];
int factores[30];
char codSexo[20];
Los nombres deben cumplir con las normas para los identificadores. La primera lnea
indica que se han
reservado 80 posiciones para nmeros doble precisin. 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 subndices estn fuera del rango previsto; esto es responsabilidad del
programador.
Por ejemplo, si en algn momento el programa debe utilizar x[90], lo usa sin importar si
los resultados
son catastrficos.
Cuando un parmetro de una funcin es un arreglo, se considera implcitamente que es
un parmetro
por referencia. O sea, si en la funcin se modifica algn elemento del arreglo, entonces se
modific realmente
el valor original y no una copia. Pasar un arreglo como parmetro de una funcin y llamar
esta
funcin es muy sencillo. Se hace como en el esquema siguiente.
... funcion(..., double x[], ...); // prototipo
//-----------------------------------------------int main(void)
{
double v[30];
...
... funcin(..., v, ...); // llamado a la funcin
59
5. ARREGLOS
...
}
//-----------------------------------------------... funcin(..., double x[],...)// definicin de la funcin

{
// cuerpo de la funcin
...
}
En el esquema anterior, el llamado a la funcin se hizo desde la funcin main. Esto no es
ninguna
obligacin; el llamado se puede hacer desde cualquier funcin donde se define un arreglo
o donde a su
vez llega un arreglo como parmetro.
Tambin se puede hacer el paso de un arreglo como parmetro de la siguiente manera.
Es la forma
ms usual. Tiene involucrada la nocin de apuntador que se ver en el siguiente captulo.
... funcion (..., double *x, ...); // prototipo
//-----------------------------------------------int main(void)
{
double v[30];
...
... funcin(..., v, ...); // llamado a la funcin
...
}
//-----------------------------------------------... funcin(..., double *x, ...)// definicin de la funcin
{
// cuerpo de la funcin
...
}
PUNTEROS
Un puntero es una variable que contiene la direccin de memoria de un dato o de otra
variable que contiene al dato en un arreglo. Esto quiere decir, que el puntero apunta al
espacio fsico donde est el dato o la variable. Un puntero puede apuntar a un objeto de

cualquier tipo, como, por ejemplo, a una estructura o una funcin. Los punteros se pueden
utilizar para referencia y manipular estructuras de datos, para referenciar bloques de
memoria asignados dinmicamente y para proveer el paso de argumentos por referencias
en las llamadas a funciones.
Muchas de las funciones estndares de C, trabajan con punteros, como es el caso
del scanf o strcpy. Estas funciones reciben o devuelve un valor que es un puntero. Por
ejemplo: A scanf se le pasa la direccin de memoria del dato a leer...
char a;
scanf ("%c",&a);
En este caso se le pasa la direccin de memoria de la variable a, la cual tiene reservado
un espacio en la memoria por el compilador. Podramos hacer lo mismo con este cdigo:
char *a = (char) malloc (sizeof (char));
scanf ("%c", a);
En este cdigo, al scanf le pasamos el puntero en s. El puntero es una variable, como
bien se ha dicho anteriormente, que contiene una direccin de memoria, por tanto, no es
necesario el uso de & para pasarle la direccin de memoria a scanf. Anteriormente hemos
tenido que reservar un espacio de memoria con malloc(), que se ver su uso ms
adelante.
Este cdigo sera errneo y dara una violacion de segmento:
char *a;
scanf ("%c", a);
En este caso, no hemos reservado memoria, por lo tanto, la funcin escribir en una
direccin de memoria que no le pertenece, y por ello se producir la susodicha violacin
de segmento.
Ya se dijo que un puntero es una variable que guarda la direccin de memoria de otra
variable, haciendo lgica a esto, decimos que un puntero se declara igual que cualquier
otra variable, pero anteponiendo un * (asterisco) antes del nombre de la variable.
Su sintaxis seria:
tipo *NombrePuntero;
Donde tipo es el tipo de dato al que referenciar este puntero, es decir, que, si se
necesita guardar la direccin de memoria de un dato int, se necesita un puntero de
tipo int.

#include <stdio.h>
int main()
{
int a=0; //Declaracin de variable entera de tipo entero
int *puntero; //Declaracin de variable puntero de tipo entero
puntero = &a; //Asignacin de la direccin memoria de a
printf("El valor de a es: %d. \nEl valor de *puntero es: %d. \n",a,*puntero);
printf("La direccion de memoria de *puntero es: %p",puntero);
return 0;
}

Igual que cuando usamos un &, en la lectura de datos con scanf, igual de esta forma
lo usamos aqu, tal vez te acordaras que decamos que las cadenas de caracteres
(%s) no usaban este operador, esto es porque en una cadena de caracteres es un
arreglo de caracteres, por lo que el primer carcter es la direccin de inicio de la
cadena.
El operador *, nos permite acceder al valor de la direccin del puntero, en este caso
nos permite acceder al valor que contiene a la variable a. De esta forma "a" y
"*puntero" muestran el mismo dato, pero esto no quiere decir que sea lo mismo, uno
es un entero el otro un puntero.
La impresin con %p, es para poder imprimir la direccin de memoria en valor
hexadecimal (0x...), tambin podemos imprimir: ...%p",&a) y funciona de la misma
forma, y es lgico que tanto a, como puntero tienen la misma direccin de memoria.