Vous êtes sur la page 1sur 11

Estructuras en C

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 nom_variable;

O también se podría definir asi:

Struct identificador
{
Tipo 1, miembro
1;
Tipo 2, miembro
2;
.
.
.
Tipo n, miembro n;

Realizado por: Pablo Juárez López


Estructuras en C

Ejemplificando gráficamente una estructura seria:

tienda

Id_empleado

Nombre [40]

Sueldo

depto

Declarando esta estructura en C quedaría:

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:

Struct uno Struct dos


{ {
Int b; char a;
char c; float b, c;
float a; };
};

Realizado por: Pablo Juárez López


Estructuras en C

Una estructura dentro de otra

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;

Su representación grafica seria:

tienda

Id_empleado

Nombre [40]

Sueldo

Depto

Nacimiento

mes

dia

anio

Realizado por: Pablo Juárez López


Estructuras en C

Estructuras de arrays unidimensionales.

Una estructura también se puede declarar como array, de este modo la declaración
seria así:

Struct tienda empleados [20];

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];

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[3]; }empleados[20];

Y así sucesivamente hasta 20 veces la misma estructura, con esto podemos


manejar 20 empleados (o dependiendo del tamaño en que se declare el array) con
las características señaladas en el registro (miembros).

Realizado por: Pablo Juárez López


Estructuras en C

Acceder a una estructura.

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:

Struct uno Para acceder al miembro c seria:


{
Int b; letras.c
char c;
float a;
} letras;

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.

printf(“Cual es el sueldo: ”);

scanf(“%f”,&altas.sueldo);

printf(“Nombre del empleado: %s,” altas.nombre[i]);

altas.depto=’A’;

if (altas.sueldo<50)
{
altas.sueldo *=10;
}

Realizado por: Pablo Juárez López


Estructuras en C

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;
}
}

Realizado por: Pablo Juárez López


Estructuras en C

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",&reg_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();
}

Realizado por: Pablo Juárez López


Estructuras en C

void baja (void)


{
struct talu reg_aux;
textbackground (GREEN);
textcolor(YELLOW);
clrscr();
printf("Dame clave:");
ren=wherey();
col=wherex();
cve=v_rango(1,15,col,ren);
if(alumnos[cve].clave==cve)
{
printf("Nombre:%s",alumnos[cve].descri);
puts("\nCalificaciones");
for(i=0;i<3;i++){
printf("%4.1f\t",alumnos[cve].calif[i]);
}
printf("\n Promedio %4.1f\n",alumnos[cve].prom);
printf("Sexo: %c\n",alumnos[cve].sexo);
puts("Procede la baja? S/N");
scanf("%c",&resp);
if (toupper(resp)=='S')
{reg_aux.clave=0;
alumnos[cve]=reg_aux;
}getch();
} else
{
printf("El alumno con clave %d no existe",cve);getch();
}pantalla();
}
void cons_uno(void)
{
textbackground (RED);
textcolor(WHITE);clrscr();
printf("Dame clave:");
ren=wherey(); col=wherex();
cve=v_rango(1,15,col,ren);
if(alumnos[cve].clave==cve)
{ printf("Nombre:%s",alumnos[cve].descri);
puts("Calificaciones");
for(i=0;i<3;i++)
{
printf("%4.1f",alumnos[cve].calif[i]);
}
printf("Promedio%4.1f",alumnos[cve].prom);
printf("Sexo:%c\n",alumnos[cve].sexo);
getch();
}
else
{
printf("El alumno con clave %d no existe",cve);
getch();
}
pantalla();
}
Realizado por: Pablo Juárez López
Estructuras en C

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;
}
}

Realizado por: Pablo Juárez López


Estructuras en C

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",&reg_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();
}

Realizado por: Pablo Juárez López


Estructuras en C

Observaciones ~ (Acerca del programa antes puesto) ~.

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.

Cualquier duda, aclaración o sugerencia será bien recibida y me podrás contactar


Vía mail: paul_d.luffy@hotmail.com

Realizado por: Pablo Juárez López