campo1

Estructuras campo2

Es una colección de una o campo3

mas variables, que pueden ser
o no del mismo tipo, bajo el
mismo nombre. Una estructura
es un registro, en la cual
puedes agrupar varias
variables, bajo el mismo STRUCT
nombre.
 DECLARACION

CEDULA
 Se declaran con la palabra  ejemplo
NOMBRE
reservada STRUCT, seguido del
Struct Alumno
nombre de la estructura.
{int cedula;
Struct nombreStruct EDAD
char nombre[50];
{ tipoDato Variable;
int edad;
tipoDato Variable;
char sexo[30];
tipoDato Variable;
char Carrera[50];
}nombreLLamada; ALUMNO
}datos;

 Donde Alumno es el nombre de la estructura, por medio de ese nombre podemos

crear nuevos datos a partir de ella. Cedula, edad, sexo y Carrera, son las variables
de las estructuras, es donde se guardan la informacion, y datos es el nombre por
el cual se llamaran la estructuras, se puede accede a la informacion.
 DECLARACION
CEDULA
NOMBRE

EDAD

FORMA B
FORMA A
struct alumno struct alumno ALUMNO
{ int cedula; { int cedula;
int edad; int edad;
char nombre[50]; char nombre[50]; Es de tipo
char carrera[50]; char carrera[50];
}datos; };
datos
struct alumno datos;
En la forma B, vemos una diferencia, colocamos el nombre datos, debajo, declarando
como tipo de dato struct alumno, de esta forma podemos declarar tantas variabes de
este tipo como necesitemos.
Estructuras. Acceso a sus miembros
Para accede a los miembros de
la esrucutras lo llamamos por su
nombre seguido de un punto y el
nombre de la variable o campo.
Teniendo e cuenta el ejemplo
anterior
datos.cedula=12354;
datos.edad=21;
datos.nombre="Maria Perez";
datos.carrera="sistemas";
Datos es el nombre de la
estructura por la cual accederemos
a las variables o campos que se
encuentran en el.
 Una estructuras NO se puede
comparer.
 Dentro de una estructura puede
haber otra estructura
 Ejemplo de estructuras: Efectuar un programa
que almacene los datos de 3 alumnos
/*EJEMPLO DE ESTRUCTURAS * */ void menu() void mostrar()
{ printf ("\n\n\t Menu de opciones ");
#include <stdio.h>
printf ("\n\t 1.- Cargar Datos ");
{system("cls");
#include <stdlib.h> printf ("\n\t 2.- mostrar "); printf("\n\n\n DATOS");
struct alumno printf ("\n\t 3.- Salir"); // mostramos alumno 1
printf ("\n\n\t Seleccione una opcion\t");
{ int cedula;
}
printf("\n\t\t ALUMNO 1");
int edad; void llenar() printf("\n NOMBRE:
char nombre[50]; { // GUARDAMOS EL PRIMER ALUMNO EN LA PRIMERA ESTRUCTURA DATO1 \t%s",dato1.nombre);
char carrera[50]; printf ("\n \t\tAlumno 1");
printf ("\n Ingrese su nombre y apellido\t");
printf("\n CEDULA:
}; \t%i",dato1.cedula);
fflush(stdin);// limpia el buffer de entrada
struct alumno dato1,dato2,dato3; gets(dato1.nombre); printf("\n EDAD: \t%i",dato1.edad);
//hemos declarados 3 estructuras alumnos, los cuales puts ("\n Ingrese su CEDULA \t");
printf("\n CARRERA: \t%s",dato1.carrera);
scanf("%i",&dato1.cedula);
// van a contener datos de 3 alumnos diferentes // mostramos alumno 2
printf ("\n Ingrese su edad \t");
void llenar(); scanf("%i",&dato1.edad); printf("\n\t\t ALUMNO 2");
void mostrar(); puts ("\n Ingrese su CARRERA \t"); printf("\n NOMBRE:
void menu(); fflush(stdin);
gets(dato1.carrera); \t%s",dato2.nombre);
int main()
// GUARDAMOS EL SEGUNDO ALUMNO EN LA PRIMERA ESTRUCTURA DATO2 printf("\n CEDULA:
{ int opc; printf ("\n \t\tAlumno 2"); \t%i",dato2.cedula);
do{ printf ("\n Ingrese su nombre y apellido\t");
fflush(stdin);
printf("\n EDAD: \t%i",dato2.edad);
menu();
gets(dato2.nombre); printf("\n CARRERA: \t%s",dato2.carrera);
scanf("%d",&opc); printf ("\n Ingrese su CEDULA \t"); // mostramos alumno 3
switch(opc) scanf("%i",&dato2.cedula);
printf ("\n Ingrese su edad \t");
printf("\n\t\t ALUMNO 3");
{case 1: llenar();
scanf("%i",&dato2.edad); printf("\n NOMBRE:
break;
printf ("\n Ingrese su CARRERA\t"); \t%s",dato3.nombre);
case 2:mostrar(); fflush(stdin);
printf("\n CEDULA:
break; gets(dato2.carrera);
// GUARDAMOS EL TERCER ALUMNO EN LA PRIMERA ESTRUCTURA DATO3 \t%i",dato3.cedula);
default: if ((opc>3)||(opc<1))
printf ("\n \t\tAlumno 3"); printf("\n EDAD: \t%i",dato3.edad);
{ system("cls"); printf ("\n Ingrese su nombre y apellido \t");
printf("\n CARRERA: \t%s",dato3.carrera);
printf("\n\n\n ERROR OPCION INCORRECTA"); fflush(stdin);
printf("\n\n\n Debe ingresar un opcion del menu"); gets(dato3.nombre); }
printf ("\n Ingrese su CEDULA \t");
}
scanf("%i",&dato3.cedula);
}// FIN SWITCH printf ("\n Ingrese su edad \t");
}while(opc!=3); scanf("%i",&dato3.edad);
printf ("\n Ingrese su CARRERA\t");
}//fin main
fflush(stdin);
gets(dato3.carrera);
}
Array de estructuras

 C permite hacer array de estructuras, la sintaxis es la misma, se le agrega la

dimension.
 Siguiendo con el jemplo anterior, la estructura quedaria de la siguiente
manera:
struct alumno
{ int cedula;
int edad;
char nombre[50];
char carrera[50];
};
struct alumno dato[3]; // donde NO creamos tres STRUCT, solo una con 3
dimensiones
 Campo
Nombre Cedula Edad Carrera
Posicion

0 Andre segura 26617300 21 Sistemas

1 Jesus Acurero 17292456 28 Sistemas

2 Rosana
Corona
29701437 20 Sistemas
 Array de estructuras
dato
 Para accede al cada elemento Campo
se efectua tal y como se hace en
un arreglo, en el cual se le coloca Nombre Cedula Edad Carrera
la posicion a la cual se desea
accede Posicion

0
dato[1].edad
Andre
 Donde 1, es la posicion del 26617300 21 Sistemas
segura
arreglo en la cual se va a
almacenar los datos.
 Al igual que en el anterior
ejemplo se coloca el operador (.)
1 Jesus
Acurero
17292456 28 Sistemas

punto, seguido del nombre de la

variable o campo donde se
desea almacenar la informacion. 2 Rosana
Corona
29701437 20 Sistemas
 Ejemplo

Cuando se va a trabajar con multiples datos del

mismo tipo, es recommendable trabajar con
estructuras de arreglos.
Para trabajar con array de estructuras, se
recomienda usar ciclos para recorrelo, se utiliza
del mismo modo como se aplica en los arreglos
unidimensonales y bidimensionales.
Siguiendo el ejemplo anterior:
 Struct sin array Struct con array
void llenar()
{ // GUARDAMOS EL PRIMER ALUMNO EN LA PRIMERA ESTRUCTURA DATO1
void llenar()
printf ("\n \t\tAlumno 1");
printf ("\n Ingrese su nombre y apellido\t"); { int i=0;
fflush(stdin);

gets(dato1.nombre); for (i=0;i<3;i++)

puts ("\n Ingrese su CEDULA \t");
scanf("%i",&dato1.cedula);
printf ("\n Ingrese su edad \t");
{ printf ("\n \t\tAlumno %i",i+1);
printf ("\n Ingrese su nombre y apellido\t");
scanf("%i",&dato1.edad);
puts ("\n Ingrese su CARRERA \t");
fflush(stdin);
gets(dato1.carrera);
fflush(stdin);
// GUARDAMOS EL SEGUNDO ALUMNO EN LA PRIMERA ESTRUCTURA DATO2
printf ("\n \t\tAlumno 2"); gets(dato[i].nombre);
printf ("\n Ingrese su nombre y apellido\t");
fflush(stdin);
gets(dato2.nombre);
puts ("\n Ingrese su CEDULA \t");
printf ("\n Ingrese su CEDULA \t");
scanf("%i",&dato2.cedula); scanf("%i",&dato[i].cedula);
printf ("\n Ingrese su edad \t");
scanf("%i",&dato2.edad);
printf ("\n Ingrese su CARRERA\t");
printf ("\n Ingrese su edad \t");
fflush(stdin);
gets(dato2.carrera); scanf("%i",&dato[i].edad);
// GUARDAMOS EL TERCER ALUMNO EN LA PRIMERA ESTRUCTURA DATO2
printf ("\n \t\tAlumno 3"); puts ("\n Ingrese su CARRERA \t");
printf ("\n Ingrese su nombre y apellido \t");
fflush(stdin);
gets(dato3.nombre);
fflush(stdin);
gets(dato[i].carrera);
printf ("\n Ingrese su CEDULA \t");
scanf("%i",&dato3.cedula);
printf ("\n Ingrese su edad \t");
scanf("%i",&dato3.edad);
printf ("\n Ingrese su CARRERA\t");
}
fflush(stdin);
gets(dato3.carrera); }
}
 Struct sin array Struct con array
void mostrar() void mostrar()
{system("cls");
printf("\n\n\n DATOS"); {system("cls");
// mostramos alumno 1
printf("\n\t\t ALUMNO 1");
printf("\n\n\n DATOS");
printf("\n NOMBRE: \t%s",dato1.nombre); int i;
printf("\n CEDULA: \t%i",dato1.cedula);
printf("\n EDAD: \t%i",dato1.edad); for (i=0;i<3;i++)
printf("\n CARRERA: \t%s",dato1.carrera);
// mostramos alumno 2 {printf("\n\t\t ALUMNO %i",i+1);
printf("\n\t\t ALUMNO 2"); printf("\n NOMBRE: \t%s",dato[i].nombre);
printf("\n NOMBRE: \t%s",dato2.nombre);
printf("\n CEDULA: \t%i",dato2.cedula); printf("\n CEDULA: \t%i",dato[i].cedula);
printf("\n EDAD: \t%i",dato2.edad);
printf("\n CARRERA: \t%s",dato2.carrera); printf("\n EDAD: \t%i",dato[i].edad);
// mostramos alumno 3
printf("\n CARRERA: \t%s",dato[i].carrera);
printf("\n\t\t ALUMNO 3");
printf("\n NOMBRE: \t%s",dato3.nombre); }
printf("\n CEDULA: \t%i",dato3.cedula);
printf("\n EDAD: \t%i",dato3.edad); }
printf("\n CARRERA: \t%s",dato3.carrera);
}
 Veamos el ejemplo complete con array de
STRUCT
void menu()
{ printf ("\n\n\t Menu de opciones ");
printf ("\n\t 1.- Cargar Datos ");
#include <stdio.h> printf ("\n\t 2.- mostrar ");
#include <stdlib.h> printf ("\n\t 3.- Salir");
struct alumno printf ("\n\n\t Seleccione una opcion\t");
{ int cedula; }
int edad; void llenar()
char nombre[50]; { int i=0;
char carrera[50]; for (i=0;i<3;i++)
}; { printf ("\n \t\tAlumno %i",i+1);
struct alumno dato[3]; printf ("\n Ingrese su nombre y apellido\t");
// declaro un array de estructuras de 3 dimensiones fflush(stdin);
void llenar(); gets(dato[i].nombre);
void mostrar(); puts ("\n Ingrese su CEDULA \t");
void menu(); scanf("%i",&dato[i].cedula);
int main() printf ("\n Ingrese su edad \t");
{ int opc; scanf("%i",&dato[i].edad);
do{ puts ("\n Ingrese su CARRERA \t");
menu(); fflush(stdin);
scanf("%d",&opc); gets(dato[i].carrera);
switch(opc) }
{case 1: llenar(); }
break; void mostrar()
case 2: {system("cls");
mostrar(); printf("\n\n\n DATOS");
break; int i;
default: for (i=0;i<3;i++)
if ((opc>3)||(opc<1)) {printf("\n\t\t ALUMNO %i",i+1);
{ system("cls"); printf("\n NOMBRE: \t%s",dato[i].nombre);
printf("\n\n\n ERROR OPCION INCORRECTA"); printf("\n CEDULA: \t%i",dato[i].cedula);
printf("\n\n\n Debe ingresar un opcion del menu"); printf("\n EDAD: \t%i",dato[i].edad);
} printf("\n CARRERA: \t%s",dato[i].carrera);
}// FIN SWITCH }
}while(opc!=3);
}
}
actividad

 Hacer un programa el cual almacene los datos de los productos de

inventario tales como: Nombre del product, Codigo, Presentacion,
Proveedor, precio, el Sistema debe almacenar minimo 10 productos, y
debo mostrarlo.
 Hacer un programa el cual amacene una cola, esdcir el usuario ingresa su
cedula y le asigna un numero, debe tener la opcion de ver la cola actual.

Notas: tomar como guia el ejercicio dado en el contenido, usar estructuras y

funciones.
Favor entregar para el 19 de mayo.