TIPOS DE DATOS AVANZADOS

VECTORES MULTIDIMENSIONALES

El C admite vectores de más d una dimensión. La sintaxis de la declaración de un vector multidimensional es la siguiente:

tipo nome[dim1][dim2]...[dimN];

int matrix[4][10][3]

crea un vector entero de 4x10x3. Los vectores de más de dos dimensiones no son muy comunes (en el MSDOS) a causa de la cantidad de memoria necesaria para contenerlos.

Vectores bidimensionales

Constituyen la forma más simple de los vectores multidimensionales. siguiendo la forma general, su declaración es:

tipo nombre[dim1][dim2];

void main()
int t,i,num[3][4];
for(t=0;t<3;t++)
for(i=0;i<4;i++)num[t][i]=4*t+i;

La representación en memoria sería la indicada en la tabla que sigue.

Como se indica en la tabla la dirección M del vector es la dirección del primer elemento en este caso num[0][0]. Quiere esto decir que num=&num[0][0].


Elemento	dirección	Valor
num[0][0]	M	0
num[0][1]	M+1	1
num[0][2]	M+2	2
num[0][3]	M+3	3
num[1][0]	M+4	4
num[1][1]	M+5	5
num[1][2]	M+6	6
num[1][3]	M+7	7
num[2][0]	M+8	8
num[2][1]	M+9	9
num[2][2]	M+10	10
num[2][3]	M+11	11

VECTOR DE STRINGS

Un vector de strings es un vector bidimensional de tipo carácter (char) donde la dimensión del índice izquierdo determina el número del string mientras el índice derecho especifica la longitud máxima que pueden tener los strings.

#include <stdio.h>
char text[3][5]; /* Texto de 3 strings con 4 caracteres en cada uno mas `\0' de terminación del string*/
main()
int i;
for (i=0;i<3;i++)
{
printf("\n linea-%1d ? ",i);
scanf("%4s",text[i]); /* input tst0 tst1 tst2 */
}
for(i=0;i<3;i++)printf("\n%s",text[i]);


Elemento	Direccón	Valor
text[0][0]	M	't'
text[0][1]	M+1	's'
text[0][2]'	M+2	't'
text[0][3]'	M+3	'0'
text[0][4]	M+4	'\0'
text[1][0]	M+5	't'
text[1][1]	M+6	's'
text[1][2]	M+7	't'
text[1][3]	M+8	'1'
text[1][4]'	M+9	'\0'
text[2][0]	M+10	't'
text[2][1]	M+11	`s'
text[2][2]'	M+12	`t'
text[2][3]	M+13	`2'
text[2][4]	M+14	'\0'

VECTOR DE PUNTEROS

Los punteros pueden ser almacenados en vectores como cualquier otro tipo de dato. La sintaxis para su declaración es la siguiente:

tipo *nome[dimensione];

#include <stdio.h>
char *mensaje[3]; /* vector de tres punteros de tipo char */
main()
int i;
mensaje[0]="Abrir";
mensaje[1]="Salvar";
mensaje[2]="Cerrar";
for (i=0;i<3;i++)printf("\n %s",mensaje[i]);

Inicialización de vectores de tipo string

El ejemplo anterior se podría haber escrito de una forma más elegante y fácil como se indica en el ejemplo que sigue

#include <stdio.h>
char *mensaje[3]={"Abrir","Salvar","Cerrar"}
main()
int i;
for(i=0;i<3;i++)printf("\n %s",mensaje[i]);

;

ESTRUCTURAS

En C una estructura es un conjunto de variables identificadas con un nombre. Las variables que constituyen la estructura se llaman elementos o miembros de la estructura. Una estructura en C equivale a un record en Pascal. La palabra llave struct señala al compilador la definición de la estructura

struct ALUMNO
unsined int numero;
char nombre[30];
char curso[20];
char login[12];

Como se puede observar la declaración termina con un punto y coma. Esto es porque la declaración de una estructura es una instrucción y como ya se ha dicho repetidas veces una instrucción tiene que acabar siempre en un punto y coma.
Debe hacerse notar que una declaración de una estructura no declara ninguna variable. Se limita sólo a definir la forma que deberá tener una variable que corresponda al tipo de la misma. Para declarar una variable de tipo estructura es necesario recurrir a la sintaxis de declaración de variables. Así para declarar por ejemplo una variable alumno de tipo ALUMNO se escribiría:

struct ALUMNO alumno;

Esta instrucción declara una variable estructura cuyo nombre es alumno y cuyo tipo es ALUMNO.
Las variables de tipo estructura se pueden declarar al mismo tiempo que la declaración de la estructura

struct ALUMNO
unsined int numero;
char nombre[30];
char curso[20];
char login[12];

alumno_informatica,alumno_mecanica,alumno_electronica;

La instrucción define un tipo de estructura ALUMNO y declara las variables alumno_informatica,alumno_mecanica,alumno_electronica de tipo struct ALUNO.

El identificador de la estructura, tal como se indica en el ejemplo que sigue, puede ser omitido.

struct
unsined int numero;
char nombre[30];
char curso[20];
char login[12];

alumno;

Referencia a los miembros de una estructura

El operador especial punto permite seleccionar los miembros de una estructura. Para asignar por ejemplo el valor 125 al miembro numero de la variable alumno se procedería

alumno.numero=125;

La sintaxis general es la siguiente:

nombre_var.nombre_elemento

Vector de estructuras

Para declarar un vector de estructuras es necesario primero definir una estructura y después declara una variable vector de aquel tipo. Con el ejemplo siguiente se puede declarar un vector de estructura de 100 elementos de tipo ALUMNO (definido anteriormente):

#include <stdio.h>
struct ALUMNO
unsined int numero;
char nombre[30];
char curso[20];
char login[12];

;
struct ALUMNO alumno[100];
void main()

{

int i;
for(i=0;i<100;i++)
{
printf("\n nombre ? ");scanf("%29s",alumno[i].nombre);
if(alumno[i].nombre[0]==27)break;/* codigo de scape */
printf("\n curso ? ");scanf("%19s",alumno[i].curso);
printf("\n login ? ");scanf("%29s",alumno[i].login);
alumno[i].numero=i;
}

Asignación de estructuras

Si dos variables de tipo estructura son del mismo tipo es posible asignar una a la otra. En este caso todos los elementos de la estructura a la izquierda del operador de asignación reciben los valores correspondientes de los elementos a la derecha.

#include <stdio.h>
void main()
struct S
int i;
double d;
s1,s2;
s1.i=10;
s1.d=98.6
s2=s1;
printf("\n %d %lf",s2.i,s2.d);

Punteros a estructuras.

El C admite punteros a estructuras del mismo modo que a otros tipos de variables. No obstante existen aspectos particulares inherentes a estos punteros que requieren una profundización en el tema.

Declaración

Los punteros a estructuras se declaran anteponiendo delante del nombre de la variable el signo *. Por ejemplo:

struct ALUMNO * p_alumno;

Utilización

Los punteros a estructuras tienen múltiples aplicaciones. Con ellos por ejemplo permiten efectuar una llamada por referencia a una función. También es posible con ellos la creación de las llamadas listas dinámicas (linked lists).

#include <stdio.h>
struct ALUMNO
unsined int numero;
char nombre[30];
char curso[20];
char login[12];
;
struct ALUMNO alumno,*p;
void main()
p=&alumno; /*El puntero p contiene la dirección de la variabile alumno */
p->numero=10;
prinf("\n nombre del alumno número 10 ? );
scanf("%29s",p->nombre);

Se hubiera podido referirse al miembro número de la estructura con el empleo explícito del operador.*

(*p).numero=10;

pero dado que al acceso a los miembros de una estructura por medio de punteros es muy común el C preve un operador especial. Se trata de -> que esta constituido por el signo menos seguido del signo mayor. Este operador se utiliza en lugar del punto cuando se accede a una estructura por medio de un puntero.

Estructuras dentro de otras estructuras (anidadas)

Los elementos de una estructura pueden ser de cualquier de datos válidos en el C, inclusive vectores y estructuras. Una estructura anidada es una estructura dentro de otra.

#include <stdio.h>
struct ALUMNO
unsined int numero;
char nombre[30];
char curso[20];
char login[12];
;
struct CISAP
{
struct ALUMNO alumno;
char inscrito[20], retirado[20];
}

cisap;

void main()
sprintf(cisap.alumno.nombre,"Eleuterio Sanchez");
sprintf(cisap.inscrito,"09.10.93");
sprintf(cisap.retirado,"01.07.94");

La estructura CISAP es por definición de tres elementos. El primero está representado por la estructura ALUMNO que contiene los datos de un alumno. El segundo y el tercer miembro son los datos de inscripción y retiro.