Está en la página 1de 21

UNIVERSIDAD

AUTNOMA DEL ESTADO


DE HIDALGO
INSTITUTO DE CIENCIAS BSICAS E
INGENIERA
CIMA
PROGRAMACIN I
LICENCIATURA EN FSICA Y
TECNOLOGA AVANZADA


KARLA I. LPEZ DE LA CRUZ
mailto:lopezdelacruz.ki@gmail.com

Enero 2016



Este documento contiene las notas de la Unidad 4 para el curso de Programacin I. La unidad tiene
como objetivo conocer y dominar los conceptos de arreglo y las operaciones que se llevan a cabo con
estos, adems de crear y manipular estructuras.










Contenido Unidad 4


4. Arreglos y Estructuras.

4.1. Concepto y representacin de un arreglo

4.2. Arreglos unidimensionales

4.3. Ejemplos y ejercicios y problemas

4.4. Arreglos multidimensionales

4.5. Ejemplos y ejercicios y problemas

4.6. Estructuras (struct)

4.7. Ejemplos, ejercicios y problemas de cada una de las estructuras.





























5. Arreglos y Estructuras.


5.1 Concepto y representacin de un arreglo

Un arreglo es un grupo de posiciones en memoria relacionadas entre s, del mismo tipo
que se denominan por un nombre comn. En C todos los arreglos constan de
posiciones de memoria contiguas. La direccin ms baja corresponde al primer
elemento y la direccin ms alta al ltimo elemento. Los arreglos pueden tener una o
varias direcciones. Los arreglos unidimensionales son en esencia listas de informacin
del mismo tipo.

Se accede a un elemento especfico del arreglo mediante un ndice. Para referirse a
una posicin en particular o elemento dentro del arreglo especificamos el nombre del
arreglo y el nmero de posicin del elemento particular dentro del mismo.

En la figura 4.1 se muestra un arreglo de enteros llamado c. este arreglo contiene 12
elementos. Cualquiera de estos elementos puede ser referenciado con el nombre del
arreglo seguido por el nmero de posicin de dicho elemento en particular entre
corchetes ([ ]).


c[0] -45
c[1] 6
c[2] 0
c[3] 72
c[4] 1234
c[5] -89
c[6] 0
c[7] 2
c[8] 34
c[9] 62
c[10] -3
c[11] 6892
Figura 4.1: Arreglo de 12
elementos


El nombre del arreglo es c, sus doce elementos se conocen como c[0], c[1], c[2], ...,
c[11]. El valor de c[0] es -45, el valor de c[1] es 6 y el valor de c[11] es 6892. El primer
elemento de cualquier arreglo es el elemento cero, entonces el primer elemento del
arreglo c se conoce como c[0] y el elemento de orden i del arreglo c se conoce como
c[i-1].

Los nombres de los arreglos siguen las mismas reglas que los dems nombres de
variables.

El nmero de posicin que aparece dentro de los corchetes se conoce como subndice.
Un subndice debe ser un entero o una expresin entera. Si un programa utiliza una
expresin como subndice, entonces la expresin se evala para determinar el
subndice. Por ejemplo, observe las siguientes lneas de cdigo.

int a=5, b=6;

c[a+b]+=2;

Aade 2 al elemento del arreglo c[11].

Observe las siguientes sentencias

printf(%d,c[0]+c[1]+c[2]);

Imprime la suma de los valores contenidos en los primeros tres elementos del arreglo
c.

x=c[6]/2;

Divide el valor del sptimo elemento del arreglo c entre 2 y asigna el resultado a la
variable x.



5.2 Arreglos unidimensionales

Para declarar un arreglo se especifica el tipo de cada elemento y el nmero de
elementos requerido por cada arreglo.

La forma general de declaracin de un arreglo unidimensional es:

tipo nombre_arreglo [tamao];

Donde tipo declara el tipo base del arreglo, que es el tipo de cada elemento del
arreglo. Tamao indica cuntos elementos contendr el arreglo.

Todos los arreglos tienen el 0 como ndice de su primer elemento. Por ejemplo,
observe la siguiente declaracin.

char p[10];

Se est declarando un arreglo de caracteres que tiene 10 elementos desde p[0] hasta
p[9].
Observe el siguiente programa

#include <stdio.h>

main()
{
int n[10],i;
for(i=0;i<10;i++)
{
n[i]=0;
}
printf("Elemento\tValor\n\n");
for(i=0;i<10;i++)
{
printf(" %d\t\t %d\n",i,n[i]);
}
return 0;
}

El programa utiliza la estructura for para inicializar los elementos de un arreglo entero
de diez elementos n a ceros, e imprime el arreglo en formato tabular.

Los elementos de un arreglo tambin pueden ser inicializados en la declaracin del
arreglo, colocando despus de la declaracin un signo igual y una lista separada por
comas, encerrada entre llaves, de inicializadores. Por ejemplo, observe el siguiente
programa.

#include <stdio.h>

main()
{
int n[10]={32,27,64,87,1,90,52,100,418,7};
int i;
printf("Elemento\tValor\n\n");
for(i=0;i<10;i++)
{
printf(" %d\t\t %d\n",i,n[i]);
}
return 0;
}

El programa inicializa un arreglo entero con diez valores y lo imprime en forma tabular.

Si dentro del arreglo existe un nmero menor de inicializadores que de elementos, los
elementos restantes son inicializados a cero automticamente. Por ejemplo, observe
las siguientes sentencias.

int n[10]={0};

Se inicializa el primer elemento de manera explcita y los nueve elementos restantes se
inicializan a cero de manera automtica porque existen menos inicializadores que
elementos en el arreglo.

int n[5]={32, 27, 64, 87, 1, 90};

Genera un error de sintaxis porque en el arreglo existen 6 inicializadores y 5
elementos.

Los arreglos no son inicializados de forma automtica. El programador debe inicializar
por lo menos el primer elemento a cero para que los dems elementos se inicialicen.

Si en una declaracin con una lista de inicializacin se omite el tamao del arreglo, el
nmero de elementos en el arreglo ser el nmero de elementos incluidos en la lista
inicializadora. Por ejemplo, observe la siguiente sentencia.

int n[]={1,2,3,4,5};

Crea un arreglo de 5 elementos.

Observe los siguientes programas.

#include <stdio.h>
#define size 10

main()
{
int s[size],i;
for(i=0;i<size;i++)
{
s[i]=2+2*i;
}
printf("Elemento\tValor\n\n");
for(i=0;i<10;i++)
{
printf(" %d\t\t %d\n",i,s[i]);
}
return 0;
}

El programa inicializa los elementos de un arreglo s a los valores 2, 4, 6, ..., 20 y lo
imprime en formato tabular.

#include <stdio.h>
#define size 10
main()
{
int n[size]={32,27,64,87,1,90,52,10,18,7};
int i,sum=0;
printf("Elemento\tValor\n\n");
for(i=0;i<size;i++)
{
printf(" %d\t\t %d\n",i,n[i]);
sum+=n[i];
}
printf("\nLa suma de los elementos del arreglo es
%d\n",sum);
return 0;
}

El programa suma los valores contenidos en el arreglo n. La sentencia en el cuerpo del
ciclo for se encarga de la acumulacin.

#include <stdio.h>
#define sizec 40
#define sizef 11

main()
{
int
c[sizec]={9,8,7,10,6,7,8,9,9,10,6,7,9,8,9,10,5,8,6,10,4,8,7,1,9,
10,8,7,4,8,8,9,0,5,3,8,7,9,10,10};
int f[sizef]={0};
int i;

printf("Elemento\tCalificacin\n\n");
for(i=0;i<sizec;i++)
{
printf(" %d\t\t %d\n",i,c[i]);
++f[c[i]];
}
printf("\n\nCalificacin\tFrecuencia\n\n");
for(i=0;i<sizef;i++)
{
printf(" %d\t\t %d\n",i,f[i]);
}
return 0;
}

El programa calcula la frecuencia de calificaciones en una lista de 40 alumnos. El
arreglo f cuenta el nmero de ocurrencias de cada calificacin, donde cada calificacin
es un subndice del arreglo f. El primer ciclo for toma las calificaciones del arreglo c una
por una e incrementa uno de los once contadores (f[0] a f[10]) en el arreglo f.

La sentencia ++f[c[i]]; incrementa el contador f apropiado dependiendo del valor
de la calificacin c[i]. por ejemplo, cuando la variable del contador i es 0, c[i] es 9, por
lo tanto ++f[c[i]]; se interpreta como ++f[9]; lo que incrementa el elemento 9
del arreglo y as sucesivamente.

#include <stdio.h>
#define sizec 40
#define sizef 11

main()
{
int
c[sizec]={9,8,7,10,6,7,8,9,9,10,6,7,9,8,9,10,5,8,6,10,4,8,7,1,9,
10,8,7,4,8,8,9,0,5,3,8,7,9,10,10};
int f[sizef]={0};
int i,j;

printf("Elemento\tCalificacin\n\n");
for(i=0;i<sizec;i++)
{
printf(" %d\t\t %d\n",i,c[i]);
++f[c[i]];
}
printf("\n\nCalificacin\tFrecuencia\tHistograma\n\n");
for(i=0;i<sizef;i++)
{
printf("\n %d\t\t %d\t\t",i,f[i]);
for(j=1;j<=f[i];j++)
{
printf("*");
}
}
return 0;
}

El programa representa la informacin en forma de una grfica de barras o histograma,
cada nmero es impreso y a continuacin a lado del nmero se imprime una barra
formada por asteriscos.

#include <stdio.h>
#define sizec 40

main()
{
int
x[sizec]={9,18,7,710,26,27,38,49,89,10,56,67,9,78,89,310,95,68,1
6,910,44,78,87,91,109,10,8,7,4,58,18,9,30,45,53,28,67,69,10,10};
int i,may,men;
float sum=0,prom;

may=x[0];
men=x[0];

printf("Elemento\tValor\n\n");
for(i=0;i<sizec;i++)
{
printf(" %d\t\t %d\n",i+1,x[i]);
if(x[i]<men)
{
men=x[i];
}
if(x[i]>may)
{
may=x[i];
}
sum=(float)sum+x[i];
}

prom=sum/sizec;
printf("\n\nElemento mayor: %d",may);
printf("\nElemento menor: %d",men);
printf("\nSuma de elementos: %f",sum);
printf("\nPromedio de elementos: %f",prom);
return 0;
}

El programa determina los elementos mayor y menor de un arreglo y calcula el
promedio.



4.4 Arreglos multidimensionales

En C, los arreglos pueden tener varias dimensiones. La forma ms simple de un arreglo
multidimensional es el arreglo bidimensional, que es esencialmente un arreglo de
arreglos unidimensionales. Una utilizacin comn de los arreglos bidimensionales es la
representacin de tablas de valores, que consisten en informacin arreglada en filas y
columnas. Para identificar un elemento particular en la tabla se especifican dos
subndices; el primero identifica la fila del elemento y el segundo identifica la columna
del elemento como se muestra en la figura 4.2.


Columna 0 Columna 1 Columna 2 Columna 3
Fila 0 a[0][0] a[0][1] a[0][2] a[0][3]
Fila 1 a[1][0] a[1][1] a[1][2] a[1][3]
Fila 2 a[2][0] a[2][1] a[2][2] a[2][3]
Figura 4.2: Arreglo bidimensional de 3 filas y 4 columnas


La figura muestra un arreglo bidimensional a. el arreglo contiene 3 filas y 4 columnas,
por lo que se dice que se trata de un arreglo de 3 por 4. en general un arreglo de m
filas y n columnas se llama arreglo de m por n.

Cada uno de los elementos del arreglo a est identificado por un nombre de elemento
de la forma a[i][j]; a es el nombre del arreglo, i y j son los subndices que identifican de
forma nica a cada elemento dentro de a.

Los arreglos bidimensionales se declaran utilizando la siguiente forma general.

tipo nombre_arreglo[filas][columnas];

Observe la siguiente declaracin.

int d[10][20];

Declara un arreglo de nombre d, de enteros, bidimensional de 10 filas y 20 columnas.

Para acceder a la posicin 3,5 del arreglo d, se escribe:

d[3][5];

Un arreglo bidimensional puede ser inicializado en su declaracin de forma similar a un
arreglo unidimensional. Por ejemplo, observe la siguiente sentencia.

int b[2][2]={{1,2},{3,4}};

Declara un arreglo b bidimensional de 2 filas por dos columnas y lo inicializa agrupando
los valores por renglones entre llaves. Por lo tanto b[0][0]=1, b[0][1]=2, b[1][0]=3 y
b[1][1]=4.

Si para un rengln no se proporcionan suficientes inicializadores, los elementos
restantes de dicho rengln se inicializarn a cero. Por ejemplo, la siguiente sentencia.

int b[2][2]={{1},{3,4}};

Inicializa b[0][0]=1, b[0][1]=0, b[1][0]=3 y b[1][1]=4.

Observe los siguientes programas

#include <stdio.h>

void printar(int[][3]);

main()
{
int a1[2][3]={{1,2,3},{4,5,6}},
a2[2][3]={1,2,3,4,5},
a3[2][3]={{1,2},{4}};

printf("\n\n\nArreglo 1\n\n");
printar(a1);
printf("\n\n\nArreglo 2\n\n");
printar(a2);
printf("\n\n\nArreglo 3\n\n");
printar(a3);
return 0;
}

void printar(int a[][3])


{
int i,j;
for(i=0;i<2;i++)
{
for(j=0;j<3;j++)
{
printf("[%d][%d] %d ",i,j,a[i][j]);
}
printf("\n");
}
}

El programa declara tres arreglos de 3 filas y 2 columnas. La declaracin de a1
proporciona 6 inicializadores en 2 sublistas. La primer sublista inicializa la primera fila a
1, 2 y 3 y la segunda sublista inicializa la segunda fila a 4, 5 y 6. Si se quitan las llaves de
cada sublista, el compilador inicializa los elementos de la primera fila seguido por los
elementos de la segunda fila. La declaracin de a2 proporciona 5 inicializadores

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <math.h>

main()
{
float a,b,m,o,d,ni,in,vv[200][2];
int i;
printf("Clculo de funcin gaussiana");
printf("Punto A: ");
scanf("%f",&a);
printf("Punto B: ");
scanf("%f",&b);
printf("Punto M: ");
scanf("%f",&m);
printf("Amplitud: ");
scanf("%f",&o);
printf("Intervalo: ");
scanf("%f",&d);
printf("\nA:%f\n B:%f\n M:%f\n O:%f\n I:%f\n",a,b,m,o,d);
in=(b-a)/d;
printf("\nNmero de intervalos calculados: %f ",in);
ni=a;
printf("\n\n X \t\t Y\n");
for(i=0;i<=in;i++)
{
vv[i][0]=ni;
vv[i][1]=exp((-(vv[i][0]-m)*(vv[i][0]-m)/(2*o*o)));
ni=ni+d;
printf("\n %f",vv[i][0]);
printf("\t %f",vv[i][1]);
}
}

El programa utiliza el arreglo vv para almacenar los valores calculados de una funcin,
dados los lmites superior e inferior y un intervalo.

#include <stdio.h>
#define maximo 10

main()
{

int i,j,n,suma=0;
int arre[maximo][maximo];

printf("Ingrese el orden de la matriz: ");


scanf("%d",&n);

for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
printf("[%d][%d]: ",i,j);
scanf("%d", &arre[i][j]);
}
printf("\n");
}

for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
if(i==j)
{
suma=suma+arre[i][j];
}
}
}

printf("\nLa suma de los elementos en la diagonal


principal es: %d",suma);
return 0;
}

El programa recibe los elementos de un arreglo bidimensional y calcula la suma de los
elementos en la diagonal principal.

#include <stdio.h>
#define maximo 10

main()
{
int i,j,n;
int arre[maximo][maximo];
printf("Ingrese el orden de la matriz: ");
scanf("%d",&n);

for(i=0;i<=n;i++)
{
for(j=0;j<=n;j++)
{
arre[i][j]=0;
}
}

for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
printf("[%d][%d]: ",i,j);
scanf("%d",&arre[i][j]);
}
printf("\n");
}

for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
arre[i][n]=arre[i][n]+arre[i][j];
arre[n][j]=arre[n][j]+arre[i][j];
}
}

for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
printf("[%d][%d]: %d\t",i,j,arre[i][j]);
}
printf("\n");
}

printf("\nLas sumas de los elementos por filas es:\n");


for(i=0;i<n;i++)
{
printf("\nFila %d: %d",i,arre[i][n]);
}

printf("\n\nLas sumas de los elementos por columnas


es:\n");
for(i=0;i<n;i++)
{
printf("\nColumna %d: %d",i,arre[n][i]);
}

return 0;
}

El programa recibe los elementos de un arreglo bidimensional y calcula la suma de los
elementos por filas y por columnas.

#include <stdio.h>
#define maximo 10

main()
{
int i,j,n,aux;
int arre[maximo][maximo];
printf("Ingrese el orden de la matriz: ");
scanf("%d",&n);

for(i=0;i<=n;i++)
{
for(j=0;j<=n;j++)
{
arre[i][j]=0;
}
}

for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
printf("[%d][%d]: ",i,j);
scanf("%d",&arre[i][j]);
}
printf("\n");
}

printf("\n\nMatriz\n\n");
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
printf("[%d][%d]: %d\t",i,j,arre[i][j]);
}
printf("\n");
}

for(i=0;i<n;i++)
{
for(j=0;j<i;j++)
{
aux=arre[i][j];
arre[i][j]=arre[j][i];
arre[j][i]=aux;
}
}

printf("\n\nMatriz traspuesta\n\n");
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
printf("[%d][%d]: %d\t",i,j,arre[i][j]);
}
printf("\n");
}

return 0;
}

El programa recibe un arreglo bidimensional y lo traspone.




Arreglos de caracteres

Los arreglos son capaces de contener datos de cualquier tipo, por ejemplo, se pueden
almacenar cadenas en arreglos de caracteres. Un arreglo de caracteres puede ser
inicializado utilizando una literal de cadena. Por ejemplo, observe la siguiente
declaracin.

char string1[]=UAEH;

Inicializa los elementos de la cadena string1 a los caracteres individuales de la literal de
cadena uno. El tamao del arreglo string1, en la declaracin anterior queda
determinado por el compilador, basado en la longitud de la cadena. La cadena UAEH
contiene cuatro caracteres, ms un caracter especial de terminacin de cadena,
conocido como caracter nulo. Entonces, el arreglo string1 contiene cinco elementos. La
representacin del caracter nulo es \0. En C todas las cadenas terminan con este
caracter.

Un arreglo de caracteres, representando una cadena, debe declararse siempre de un
tamao suficiente para contener el nmero de caracteres de la cadena, incluyendo el
caracter nulo de terminacin.

Los arreglos de caracteres tambin pueden ser inicializados con constantes
individuales de caracteres en una lista de inicializacin. Por ejemplo, observe la
siguiente declaracin, equivalente a la anterior.

char string1[]={U,A,E,H};

Dado que la cadena es un arreglo de caracteres, se puede tener acceso directo a los
caracteres individuales de una cadena, utilizando la notacin de subndices de arreglos.
Por ejemplo, string1[0], es el caracter U y string1[3] es el caracter H.

Es posible introducir desde el teclado una cadena en un arreglo de caracteres,
utilizando scanf y la conversin %s. por ejemplo, observe las siguientes sentencias.

char string2[20];

Crea un arreglo de caracteres capaz de almacenar una cadena de 19 caracteres y un
caracter nulo de terminacin.

scanf(%s,string2);

Lee una cadena del teclado y la coloca en string2. El nombre del arreglo se pasa a scanf
sin colocar el & precedente, que se utiliza en otras variables. El & es utilizado para
darle a scanf una localizacin de variable en memoria con el propsito de almacenar
un valor ah. Dado que el nombre de un arreglo es la direccin del inicio del arreglo, &
no es necesario.

Scanf() lee caracteres del teclado hasta que encuentra el primer caracter de espacio en
blanco sin importarle qu tan grande es el arreglo. Por lo tanto, scanf() podra escribir
ms all del tamao del arreglo.

Un arreglo de caracteres que represente una cadena puede ser sacado utilizando
printf() y el especificador de conversin %s. por ejemplo, observe la siguiente
instruccin.

printf(%s\n,string2);

Imprime el arreglo string 2. A printf no le importa qu tan grande es el arreglo de
caracteres, los caracteres de la cadena sern impresos, hasta que un caracter de
terminacin nulo sea encontrado.

Observe el siguiente programa.

#include <stdio.h>

main()
{

char string1[20], string2[]="cadena de caracteres";


int i;

printf("Ingrese una cadena: ");


scanf("%s",string1);
printf("\nstring1: %s",string1);
printf("\nstring2: %s",string2);
printf("\nstring1 con espacios entre caracteres: ");

for(i=0;string1[i]!='\0';i++)
{
printf("%c ",string1[i]);
}

return 0;
}

El programa inicializa un arreglo de caracteres con una literal de caracteres, lee una
cadena a un arreglo de caracteres e imprime un arreglo de caracteres como una
cadena y accede a caracteres individuales de una cadena.

Se utiliza la estructura for para desplazarse a travs del arreglo string1 e imprimir los
caracteres individuales separados por espacios mediante la especificacipn de
conversin %c. la condicin en la estructura for, string1[i]1=\0, es verdadera en tanto,
dentro de la cadena, el caracter nulo de terminacin no sea encontrado.




Arreglos de cadenas.

Para crear un arreglo de cadenas se utiliza un arreglo bidimensional. El tamao del
primer ndice determina el nmero de cadenas y el tamao del segundo ndice
determina la longitud mxima de cada cadena. Por ejemplo, observe la siguiente
declaracin.

char cadenas[3][80];

Declara un arreglo de 30 cadenas, cada una con una longitud mxima de 79 caracteres,
cada cadena del arreglo termina en un nulo.

Para acceder a una cadena individual, se especifica slo el primer ndice. Por ejemplo,
observe la siguiente sentencia.

gets (cadenas[2]);

Llama a gets con la tercera cadena de cadenas



4.6 Estructuras (struct)

Las estructuras son colecciones de variables relacionadas bajo un mismo nombre. Las
estructuras pueden contener variables de muchos tipos diferentes de datos.
Generalmente las estructuras se utilizan para definir registros a almacenar en archivos.
Las estructuras proporcionan un medio eficaz de mantener junta la informacin
relacionada. La declaracin de una estructura forma una plantilla que puede utilizarse
para crear variables de estructura. Cada elemento de la estructura est relacionado
lgicamente con los otros.

La forma general de una definicin de estructura es:

struct etiqueta
{
tipo nombre_variable1;
tipo nombre_variable1;
tipo nombre_variable1;
.
.
.
} variables_tipo_estructura;

La etiqueta es el nombre de la estructura, no un nombre de variable. Las
variables_tipo_estructura son una lista de nombres de variables separados por comas.
Se puede omitir o bien la etiqueta o bien las variables_tipo_estructura, pero no ambas.
Por ejemplo, observe la siguiente declaracin:

struct dir
{
char nombre[20];
int edad;
char direccion[100];
char telefono1[30];
char telefono2[30];
char correo[30];
};

La palabra reservada struct presenta la definicin de la estructura, el identificador dir
es la etiqueta de la estructura. La etiqueta de la estructura da nombre a la definicion
de la misma y se utiliza con la palabra reservada struct para declarar variables del tipo
estructura. Las variables declaradas dentro de las llaves de la estructura son los
miembros de la estructura, los miembros de la misma estructura deben tener nombres
nicos, pero dos estructuras diferentes pueden contener miembros con el mismo
nombre sin entrar en conflicto. Los miembros de una estructura pueden ser variables
de los tipos de datos bsicos o agregados, como arreglos y otras estructuras. Cada
definicin de estructura debe terminar con un punto y coma ya que una declaracin de
estructura es una sentencia.

Una estructura no puede contener una instancia de s misma, sin embargo puede ser
incluido un apuntador a s misma. Una estructura que contenga un miembro que es un
apuntador al mismo tipo de estructura, se conoce como una estructura
autoreferenciada. La definicin de una estructura no reserva ningn espacio en
memoria, mas bien genera un nuevo tipo de dato, que se utiliza para declarar
variables.

Las variables de estructura se declaran como se declaran las variables de otros tipos.
Para declarar una variable con esta estructura se escribe:

struct dir info_dir, tabla[50], *c;

Esto declara una variable de estructura de tipo struct dir llamada info_dir, declara
tabla como un arreglo con 52 elementos de tipo struct dir y declara c como un
apuntador a struct dir. Cuando se declara una estructura se est definiendo un tipo
complejo de variable compuesto por los elementos de la estructura. O existe
realmente una variable de este tipo hasta que se declara.

Se puede declarar una o ms variables a la vez que se define una estructura.

Ejemplo

struct dir
{
char nombre[20];
char apellidos[30];
char direccion[100];
char telefono1[30];
char telefono2[30];
char telefono3[30];
char correoe[30];
}info_dir,ainfo,binfo;

Declara un tipo de estructura llamado dir y declara las variables info_dir,a info y bingo
de dicho tipo.

Si slo se necesita una variable de estructura, entonces no se necesita el nombre de
estructura. Por ejemplo, observe la siguiente declaracin

struct
{
char nombre[20];
char apellidos[30];
char direccion[100];
char telefono1[30];
char telefono2[30];
char telefono3[30];
char correoe[30];
}info_dir;

Declara una variable llamada info_dir definida por la estructura que le precede.


Referencia a los elementos de una estructura

Se hace referencia a los elementos individuales de una estructura utilizando el
operador . (operador punto).

La forma general de acceso es:

nombre_variable_estructura.nombre_elemento

El nombre de la variable de estructura seguido de un punto y el nombre del elemento
hace referencia a ese elemento individual de la estructura. Por ejemplo, observe la
siguiente instruccin.

info_dir.correoe=algo@algomas.com;

Para desplegar el correo electrnico en pantalla, escribimos:

printf(Correo electrnico: %s, info_dir.correoe);

Imprime el correo electrnico que contiene la variable correo de la variable de
estructura info_dir.

Observe el siguiente programa.

#include <stdio.h>
#define maximo 100

struct dir
{
char nombre[30];
int edad;
char direccion[80];
char tel1[10];
char tel2[10];
char correo[30];
}directorio[maximo];

main()
{

int i,n;
int arre[maximo][maximo];

printf("Cuntos registros desea ingresar? ");


scanf("%d",&n);

for(i=0;i<n;i++)
{
printf("\n\n%d. \n",i+1);
printf("Nombre: ");
scanf("%s",directorio[i].nombre);
printf("Edad: ");
scanf("%d",&directorio[i].edad);
printf("Direccin: ");
scanf("%s",directorio[i].direccion);
printf("Telfono 1: ");
scanf("%s",directorio[i].tel1);
printf("Telfono 2: ");
scanf("%s",directorio[i].tel2);
printf("Correo electrnicoe: ");
scanf("%s",directorio[i].correo);
}

printf("Tu directorio contiene %d elementos",n);


for(i=0;i<n;i++)
{
printf("\n\n%d. \n",i+1);
printf("\nNombre: %s",directorio[i].nombre);
printf("\nEdad: %d", directorio[i].edad);
printf("\nDireccin: %s", directorio[i].direccion);
printf("\nTelfono 1: ", directorio[i].tel1);
printf("\nTelfono 2: ", directorio[i].tel2);
printf("\nCorreo electrnicoe: ",
directorio[i].correo);
}

return 0;
}

El programa crea un arreglo de estructuras, recibe datos que almacena en el arreglo y
finalmente despliega su contenido.