Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
Estructuras
Como hemos visto antes el array es una estructura de datos cuyos elementos son
del mismo tipo, ahora nos enfocaremos en las estructuras (también conocidas
como registros) que son estructuras de datos cuyos elementos individuales pueden
ser de distinto tipo.
Estos elementos individuales dentro de una estructura se llaman miembros.
Para utilizar estructuras en C se requieren de 2 cosas:
1. Declarar la estructura con todos sus miembros.
2. Declarar la variable del nuevo tipo de dato creado.
1.
Struct identificador Donde struct es una palabra reservada de
{ C, la cual es requerida siempre, ya que
Tipo 1, miembro hace referencia a que es una estructura.
1;
Tipo 2, miembro Identificador es el nombre del tipo de dato.
2;
. Tipo 1 es el tipo de dato del miembro.
.
. miembro, es el nombre de la variable que
Tipo n, miembro n; pertenece a la estructura.
2.
Para declarar una variable de tipo estructura seria:
Struct identificador
{
Tipo 1, miembro
1;
Tipo 2, miembro
2;
.
.
.
Tipo n, miembro n;
tienda
Id_empleado
Nombre [40]
Sueldo
depto
Struct tienda
{
Int Id_empleado;
char nombre[40];
float sueldo;
char depto;
};
Ahora bien, cabe mencionar que estructuras diferentes pueden contener nombres
de miembros iguales, por ejemplo:
También podemos hacer esto, declarar una estructura dentro de otra, pero la
estructura que este dentro de esta se deberá declarar antes. Por ejemplo:
Struct fecha
{
Int mes:
Int dia;
Int anio;
};
Struct tienda
{
Int Id_empleado;
char nombre[40];
float sueldo;
char depto;
Struct fecha nacimiento;
} altas, bajas;
tienda
Id_empleado
Nombre [40]
Sueldo
Depto
Nacimiento
mes
dia
anio
Una estructura también se puede declarar como array, de este modo la declaración
seria así:
Con este tipo de arreglo, hacemos referencia a que abra 20 estructuras empleados
de tipo tienda, en cada casilla del array empleados abra una estructura igual.
Por ejemplo:
Struct tienda Struct tienda
{ {
Int Id_empleado; Int Id_empleado;
char nombre[40]; char nombre[40];
float sueldo; float sueldo;
char depto; char depto;
} empleados[1]; } empleados[2];
} empleados[3]; }empleados[20];
En las estructuras solo podemos acceder a los miembros de uno en uno, esto es,
que podemos pedir o mostrar miembros de uno en uno, y se realiza mediante la
siguiente anotación:
Variable.miembro
Donde variable es el nombre precisamente de la variable de tipo estructura, y
miembro -el que va enseguida de el punto- es el nombre de la variable de uno de
los miembros que pertenecen a dicha estructura.
Ejemplo:
Ahora pues sabiendo esto, agrego varios ejemplitos, en los cuales se utiliza el
acceso a 1 miembro y se procesa con los tipos de sentencias.
scanf(“%f”,&altas.sueldo);
altas.depto=’A’;
if (altas.sueldo<50)
{
altas.sueldo *=10;
}
Agrego un ejemplo realizado por su servidor, este consiste en dar de altas, bajas,
hacer cambios, consultas, etc. de alumnos en una escuela, utilizando estructuras.
Ejemplo completo en C.
#include "myli.h"
#include <string.h>
void inicia (void);
void alta (void);
void baja (void);
void cambio(void);
void cons_uno(void);
void cons_todos (void);
void elige(entero op);
entero menu(void);
struct talu
{
entero clave;
car descri[35];
deci calif[3];
deci prom;
car sexo;
}alumnos[16],reg_alu;
entero opc,i;
entero ren,col,cve;
car resp;
deci prome;
void main()
{
pantalla();
inicia();
do
{
opc= menu();
elige(opc);
}while(opc!=6);
}
void inicia(void)
{
reg_alu.clave=0;
for(i=0;i<35;i++){
reg_alu.descri[i]=' ';
}
for(i=0;i<3;i++)
{
reg_alu.calif[i]=0.0;
reg_alu.prom=0.0;
reg_alu.sexo=' ';
}
for(i=1;i<=15;i++)
{
alumnos[i]=reg_alu;
}
}
entero menu(void)
{
entero ops;
printf("\t\t\t 1.Altas 2.Bajas \n");
printf("\t\t\t 3.Cambios 4.Consulta uno \n");
printf("\t\t\t 5.Consulta todos 6.Terminar \n");
printf("\n\t\t\t Dame opcion (1-6) ");
ren=wherey();
col=wherex();
ops=v_rango(1,6,col,ren);
return(ops);
}
void alta(void)
{
textbackground (BLUE);
textcolor(WHITE);
clrscr();
printf("Dame clave : ");
ren=wherey();
col=wherex();
cve=v_rango(1,15,col,ren);
prome=0;
if(alumnos[cve].clave==cve)
{
printf("El alumno con clave %d ya existe",cve);
getch();
}
else
{
reg_alu.clave=cve;
puts("\nDame nombre: ");
scanf(" %[^\n]",reg_alu.descri);
puts ("\nDame calificaciones: ");
for (i=0;i<3;i++){
scanf("%f",®_alu.calif[i]);
prome+=reg_alu.calif[i];
}
reg_alu.prom=(prome/3.0);
printf("\nSexo: ");
scanf("%s",&resp);
reg_alu.sexo=toupper(resp);
printf("\nProcede a la alta? S/N ");
resp=getche();
if(toupper(resp)=='S'){
alumnos[cve]=reg_alu;
}
}
pantalla();
}
void cons_todos(void)
{
entero k;
textbackground(0);
textcolor(2);
clrscr();
i=1;
printf("clave: Nombre\t\t Calificaciones Promedio Sexo\n");
do
{
if(alumnos[i].clave==i)
{
printf(" %2d\t ",i);
printf("%-35s",alumnos[i].descri);
for (k=0;k<3;k++)
{
printf("%4.1f",alumnos[i].calif[k]);
}
printf(" %4.1f",alumnos[i].prom);
printf("\t %c\n",alumnos[i].sexo);
}
else
{
if (i==16)
{
printf("\n\t\t\t!!!!No hay mas registros!!!!"); }
}
i++;
}while(i!=16);
getch();
pantalla();
}
void elige(entero op)
{
switch(op)
{
case 1:
alta();
break;
case 2:
baja ();
break;
case 3:
cambio();
break;
case 4:
cons_uno();
break;
case 5:
cons_todos();
break;
}
}
void cambio(void)
{
textbackground (3);
textcolor(13);
clrscr();
printf("Dame clave : ");
ren=wherey();
col=wherex();
cve=v_rango(1,15,col,ren);
reg_alu.clave=0;
for(i=0;i<35;i++){
reg_alu.descri[i]=' ';
}
for(i=0;i<3;i++)
{
reg_alu.calif[i]=0.0;
reg_alu.prom=0.0;
reg_alu.sexo=' ';
}
alumnos[cve]=reg_alu;
prome=0;
if(alumnos[cve].clave==cve)
{
}
else
{
reg_alu.clave=cve;
puts("\nDame nombre: ");
scanf(" %[^\n]",reg_alu.descri);
puts ("\nDame calificaciones: ");
for (i=0;i<3;i++)
{
scanf("%f",®_alu.calif[i]);
prome+=reg_alu.calif[i];
}
reg_alu.prom=(prome/3.0);
printf("\nSexo: ");
scanf("%s",&resp);
reg_alu.sexo=toupper(resp);
printf("\nProcede a la alta? S/N ");
resp=getche();
if(toupper(resp)=='S'){
alumnos[cve]=reg_alu;
}
}
pantalla();
}
Como ustedes se dieron cuenta al inicio hay una extraña librería: # include "myli.h".
Bueno aunque la siguiente explicación este fuera del propósito de este texto les
comento que es una librería hecha por un servidor (osease que yo), esto es, que
ustedes mismos pueden hacer una librería y agregarle instrucciones (con las cuales
trabajen mucho) las cuales en un proyecto ahorran bastante sus códigos, y
precisamente eso es lo que hice… acortar un poco el codigo, y también se habrán
dado cuenta (también al principio) al declarar una variable no lo hice del modo
cotidiano: int variable; sino que use un tipo definido por el usuario que agregue a
la librería, y así es como puedo declarar: entero variable;. Otra cosa también se
abran dado cuanta de una función llamada pantalla(); la cual utilizo
frecuentemente al finalizar una función y esta también viene incluida en la dichosa
librería y por ultimo la ultima cosa que agregue a la librería es una función, la cual
se llama v_rango; la cual simplemente compara una cifra dada por el usuario de
entre 2 cifras y si se sale del rango borra línea y vuelve nuevamente a pedir la cifra
al usuario.
Como verán con una librería creada por ustedes mismos ahorran bastante codigo,
y es muy útil, si quieren aprender a hacer una librería consulten mi otro manual,
ya que no es asunto de este tema, y por ultimo todo lo demás del codigo ya esta
explicado.