UNIVERSIDAD DE LAS FUERZAS ARMADAS ESPE-L

CONSULTA N°1.U3
TEMA:
ESTRUCTURAS EN C

AUTORES:
Jean Pierre Ruiz Espinoza

Darwin Casco

DOCENTE:
Gloria Ivone Arias.

NRC:
2601

Carrera:
Mecatrónica

Nivel:

Segundo

Paralelo:

“A”
Período Académico
PREGRADO S-I MRZ19 - JUL19
 OBJETIVOS
Objetivo General

Investigar es estudiar las características y utilidades de las estructuras en C para solucionar

problemas de programación.

Objetivos Específicos

 Realizar ejercicios que fortalezcan la agilidad para usar la herramienta de las estructuras
 Mostrar la teoría correspondiente a cada utilidad de las estructuras
 Realizar el código de un programa donde se apliquen la mayoría de los conocimientos
adquiridos.

MARCO TEÓRICO

1. Concepto de Estructuras en C
Las estructuras conocidas generalmente con el nombre de registros representan un tipo de
datos estructurados. Se utilizan para resolver problemas que involucran tipos de datos
estructurados, heterogéneos. (Kesquivel, 2013)

“Una estructura es una colección de elementos finita y heterogénea”.

Finita: Porque se puede determinar el número de componentes y heterogénea porque todos

los elementos pueden ser de tipos de datos diferentes. Cada componente de la estructura se
denomina campo y se identifica con un nombre único. (Kesquivel, 2013)

2. Declaración y definición de variables tipo STRUCT

La estructura debe declararse antes de ser utilizada, se hace de esta manera:

Struct <nombre de la estructura>

{
<tipo de dato miembro1><nombre miembro>
<tipo de dato miembro>2<nombre miembro>
<tipo de dato miembro>3<nombre miembro>
……..
}

Cada definición de variable para una estructura dada crea un área en memoria en donde los
datos se almacenan de acuerdo con el formato estructurado declarado.
 Las variables de estructuras se pueden definir de dos formas:

1. Primera Forma: Listándolas inmediatamente después de la llave de cierre de la

declaración de la estructura
2. Segunda Forma: Listando el tipo de la estructura creada por las variables
correspondiente en cualquier lugar del programa antes de utilizarlas. (Platea, 2011)

Ejemplo:
Vamos a declarar la estructura Alumno, la cual contara con varias variables dentro de sí:

Primera Forma
Struct Alumno
{
char num_carne[11];
char nombre_alumno[60];
int edad;
char dirección [60];
}alum1,alum2,alum3;

Segunda Forma
Struct Alumno alum1, alum2, alum3;

3. Inicialización de una variable de tipo STRUCT

Una estructura se puede inicializar de dos formas:

 Dentro de la sección de código de su programa

 Como parte de la definición de la estructura, especificando los valores iniciales,
entre llave, después de la definición de variables estructura. (Fing, 2012)

El formato general en este caso es:

struct <tipo><nombre variable estructura>

{
valor miembro1;
valor miembro2;
valor miembro3;
……..
valor miembron;
}variable_estructura={datos de inicialización};
 Ejemplo #1: Este programa imprime el valor de una variable de tipo struct info_libro
que fue inicializada durante la declaración.
CÓDIGO
#include<stdio.h>
struct info_libro{
char titulo_lib[50];
char autor [30];
char editorial[30];
int fecha;
}libro1={"La Ladrona de Libros","Markus Zusak","Collin Anderson",2010};

main(){
printf("Titulo del libro: %s\n",libro1.titulo_lib);
printf("Autor del libro: %s\n",libro1.autor);
printf("Editorial del libro: %s\n",libro1.editorial);
printf("Fecha de edicion: %d\n",libro1.fecha);
}
EJECUCIÓN

4. Tamaño de una estructura

El operador sizeof se aplica sobre un tipo de datos, o bien sobre una variable. Se puede
aplicar para determinar el tamaña que ocupa en memoria una estructura. El siguiente
programa ilustra el uso del operador sizeof para determinar el tamaño de una estructura:

Ejemplo #2: Este programa permite visualizar el tamaño en bytes de una estructura
CÓDIGO
#include<stdio.h>
struct persona{
char nombre[30];
int edad;
float altura;
float peso;
};
main(){
struct persona per;
printf("El tamayo en bytes de struct(persona) es %d\n",sizeof(per));
}
EJECUCIÓN
5. Acceso a una estructura de datos mediante el operador punto:
La asignación de datos a los miembros de una variable estructura se puede hacer mediante
el operador punto. (Platea, 2011)
La sintaxis en C es la siguiente:
<Nombre variable estructura>.<Nombre miembro de la estructura>=datos;
Ejemplos:

strcpy(libro1.titulo_lib,”C-C++”);
strcpy(libro1.autor,”Francisco Javier Ceballos”);
strcpy(libro1.editorial,”RA-MA”);
libro1.anyo=2002;

El operador punto proporciona el camino directo al miembro correspondiente. Los datos

que se almacenan en un miembro dado deben ser del mismo tipo que el tipo declarado para
ese miembro. (Fing, 2012)

6. Lectura y recuperación de información de una estructura

Se puede almacenar información en una estructura mediante inicialización, asignación
directa o lectura del teclado. (Villa, 2013)

Ejemplo #3: Este programa lee del teclado los datos de una variable de tipo estructura
llamada “trabajadores” y los visualiza utilizando el operador punto para acceder a los
datos miembros de la estructura.
CÓDIGO
#include<stdio.h>
struct trabajadores{
char nombre[30];
int edad;
};

main(){
struct trabajadores tra;
printf("\nIntroduce el nombre del trabajor:\n");
gets(tra.nombre);
printf("\nIntroduce la edad del trabajador:\n");
scanf("%d",&tra.edad);
printf("\n\n");
printf("DATOS DE TRABAJADOR \n");
printf("\nNombre: %s\n", tra.nombre);
printf("Edad: %d\n",tra.edad);
return 0;
 }
EJECUCIÓN

7. Creación de sinónimos o alias

La instrucción typedef permite al usuario definir alias o sinónimos, es decir, nuevos tipos
de datos equivalentes a los que ya existen. El objetivo de esta instrucción consiste en utilizar
nombres más apropiados y cortos para los tipos de datos, puesto que evitamos escribir la
palabra struct en la declaración de las variables. (Platea, 2011)

Ejemplo #4: Este programa lee del teclado los datos de una variable tipo struct
llamada “estudiante”, calcula e imprime el promedio de las 5 calificaciones de un
estudiante.
CÓDIGO
#include<stdio.h>
#include<string.h>
typedef struct estudiante{
char nombre[30];
char num_carne[11];
int nota[5];
}estud;

main(){
estud est;
int n,sum=0;
float prom;
printf("Nombre Estudiante:");
gets(est.nombre);
printf("Numero de Carnet:");
fflush(stdin);
gets(est.num_carne);
printf("Ingrese las 5 calificaciones:\n");
for(n=0;n<5;n++){
printf("Nota [%d]:",n+1);
 scanf("%d",&est.nota[n]);
sum=sum+est.nota[n];
}
prom=(float)sum/5;

printf("\n---DATOS DEL ESTUDIANTE---\n");

printf("Nombre: %s\n",est.nombre);
printf("Numero de Carnet: %s\n",est.num_carne);
printf("Promedio: %.2f",prom);
}
EJECUCIÓN

8. Acceso a una estructura de datos mediante el operador puntero “->“

El operador puntero -> sirve para acceder a los elementos de la estructura a partir de un
puntero. Para utilizar este operador se debe definir primero una variable puntero para
apuntar a la estructura. (Fing, 2012)

La asignación de datos a estructuras utilizando el operador -> tiene el siguiente formato:

<Puntero estructura>-><Nombre miembro>=datos;

Ejemplo #5: El mismo código usado en el ejercicio 6, pero usando punteros

CÓDIGO
#include<stdio.h>
#include<string.h>
struct estudiante{
char nombre[30];
char num_carne[11];
int nota[5];
};

main(){
 struct estudiante est,*ptr_est;
ptr_est=&est;
int n,sum=0;
float prom;
printf("Nombre Estudiante:");
gets(ptr_est->nombre);
printf("Numero de Carnet:");
fflush(stdin);
gets(ptr_est->num_carne);
printf("Ingrese las 5 calificaciones:\n");
for(n=0;n<5;n++){
printf("Nota [%d]:",n+1);
scanf("%d",&ptr_est->nota[n]);
sum=sum+ptr_est->nota[n];
}
prom=(float)sum/5;

printf("\n---DATOS DEL ESTUDIANTE---\n");

printf("Nombre: %s\n",ptr_est->nombre);
printf("Numero de Carnet: %s\n",ptr_est->num_carne);
printf("Promedio: %.2f",prom);
}
EJECUCIÓN

9. Estructuras anidadas
Una estructura puede contener otras estructuras llamadas estructuras anidadas, las cuales
ahorran tiempo en la escritura de programas que utilizan estructuras similares. Se han de
definir los miembros comunes sólo una vez en su propia estructura y a continuación utilizar
esa estructura como miembro de otra estructura. (Kesquivel, 2013)

Ejemplo #6: Programa que permite almacenar la información de una agenda

telefónica implementando estructuras anidadas.
CÓDIGO
 #include<stdio.h>
#include<string.h>
struct fecha{
int dia,mes,anyo;
};

typedef struct agenda_personal{

char nombre[30];
char telefono[11];
struct fecha f_cumple;
}agenda;

main(){
agenda one;
printf("Nombre:");
scanf("%s",one.nombre);
printf("Telefono:");
scanf("%s",one.telefono);
fflush(stdin);
printf("fecha de Nacimiento(dd-mm-aa):");
scanf("%d %d %d",&one.f_cumple.mes,&one.f_cumple.dia,&one.f_cumple.anyo);
printf("\n---DATOS DE CONTACTO---\n");
printf("Nombre: %s\n",one.nombre);
printf("Telefono: %s\n",one.telefono);
printf("Fecha de Cumpleanios: %d-%d-
%d\n",one.f_cumple.dia,one.f_cumple.mes,one.f_cumple.anyo);
return 0;
}

EJECUCIÓN

10. Arrays de estructuras

Se puede crear un array de estructuras tal como se crea un array de otros tipos. Los arrays
de estructuras son idóneos para alamcenar un archivo completo de empleados, un archivo
de inventario o cualquier otro conjunto de datos que se adapte a un formato de estructura.
 Mientras que los arrays proporcionan un medio práctico de almacenar diversos valores de
diferentes tipos, agrupados como estructuras. (Kesquivel, 2013)

Ejemplo #7: Programa que permite el ingreso de N notas de los nombre y edades de N
estudiantes y además calcular el promedio de las notas ingresadas, todo basándose en
el uso de un vector de estructura.
CÓDIGO
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

struct datos{
int edad;
char nombre[30];
char apellido[30];
int calificacion[100];
float promedio;
}alum[100];
main(){
int num_cal,num_al;
printf("---ESTE PROGRAMA PERMITE INGRESAR DATOS DE LOS
ALUMNOS QUE DESEE Y CALCULA EL PROMEDIO DE SUS NOTAS---");
printf("\n---Ingrese el numero de alumnos---\n");
scanf("%d",&num_al);
printf("---Ingrese el numero de calificaciones por cada alumno---\n");
scanf("%d",&num_cal);
printf("\n\n");
for(int i=0;i<num_al;i++){
printf("Alumno [%d]",i+1);
fflush(stdin);
printf("\nIngrese Nombre:");
gets(alum[i].nombre);
fflush(stdin);
printf("Ingrese Apellido:");
gets(alum[i].apellido);
printf("Ingrese Edad:");
scanf("%d",&alum[i].edad);
for(int j=0;j<num_cal;j++){
printf("Ingrese calificacion N[%d]:",j+1);
scanf("%d",&alum[i].calificacion[j]);
}
printf("\n\n");
}
float sum=0,prom;
for(int i=0;i<num_al;i++){
for(int j=0;j<num_cal;j++)
 sum=sum+alum[i].calificacion[j];
prom=(float)sum/num_cal;
alum[i].promedio=(float)prom;
}
printf("\n---RESULTADOS---\n");
printf("\n# de Alumno Nombre y Apellido Edad
Promedio\n");
for(int i=0;i<num_al;i++){
printf("[%d] %s %s %d
%.2f\t\n",i+1,alum[i].nombre,alum[i].apellido,alum[i].edad,alum[i].promedio);
}

}
EJECUCIÓN
 CONCLUSIONES
Tras una ardua tarea de realización y ejecución de los ejemplos correspondientes a cada
utilidad de las estructuras en C es posible finalizar reflexionando que estas resultan
extremadamente útiles para minimizar el número de líneas que el programador requiere
cuando realiza un programa.

RECOMENDACIONES
Se recomienda seguir buscando aplicaciones a las estructuras en C, pues existe una gran
cantidad de problemas cuya resolución programable puede ser reducida.

BIBLIOGRAFÍA
Fing. (16 de Marzo de 2012). Principios de Programación. Recuperado el 1 de Julio de 2019, de El
lenguaje C: https://www.fing.edu.uy/tecnoinf/mvd/cursos/prinprog/material/teo/prinprog-
teorico08.pdf

Kesquivel. (12 de Junio de 2013). UNAN. Recuperado el 1 de Julio de 2019, de Estructuras en C:

https://kesquivel.files.wordpress.com/2013/05/estructuras2013final2.pdf

Platea. (16 de Junio de 2011). PNTIC. Recuperado el 1 de Julio de 2019, de Cadenas de texto:
http://platea.pntic.mec.es/vgonzale/cyr_0204/cyr_01/control/lengua_C/cadenas.htm

Villa, D. (19 de Mayo de 2013). Arco. Recuperado el 1 de Julio de 2019, de Usar struct para combinar
variables: http://arco.esi.uclm.es/~david.villa/pensar_en_C++/vol1/ch03s08s02.html