Asignatura: Fundamentos de programación.

Unidad de aprendizaje #3: Funciones y estructuras de datos.

Evidencia de Aprendizaje: Codificación de algoritmos
modulares e implementación de una estructura de datos.

Ciudad de México, marzo del 2023.

Diseño: DL-CPL
 1

ÍNDICE

ÍNDICE..................................................................................................................... 1
Índice de figuras.......................................................................................................2
Índice de tablas........................................................................................................ 2
INTRODUCCIÓN..................................................................................................... 3
Redacta las características de los arreglos, de las estructuras de datos y los
módulos................................................................................................................ 3
DESARROLLO DE LA ACTIVIDAD.........................................................................4
Pseudocódigo.......................................................................................................4
Diagrama de flujo..................................................................................................7
Prueba de escritorio............................................................................................11
Código fuente del programa en lenguaje C........................................................13
Ejecución del programa en lenguaje C...............................................................18
CONCLUSIONES...................................................................................................20
Describe cómo se aplicó el diseño descendente y cómo se implementó arreglos
y estructuras de datos........................................................................................ 20
REFERENCIAS BIBLIOGRÁFICAS.......................................................................21
 2

Índice de figuras

Figura 1 Pseudocódigo hecho a mano parte 1. Evidencia de Aprendizaje.

Elaboración propia................................................................................................... 4
Figura 2 Pseudocódigo hecho a mano parte 2. Evidencia de Aprendizaje.
Elaboración propia................................................................................................... 5
Figura 3 Pseudocódigo hecho a mano parte 3. Evidencia de Aprendizaje.
Elaboración propia................................................................................................... 6
Figura 4 Diagrama de flujo hecho a mano. Menú principal del programa BD para
Agencia de Autos. Elaboración Propia.....................................................................7
Figura 5 Diagrama de flujo hecho a mano. Subproceso Consultas del programa
BD Agencia de Autos. Elaboración Propia...............................................................8
Figura 6 Diagrama de flujo hecho a mano. Subproceso Editar y Subproceso
Registrar del programa BD Agencia de Autos. Elaboración Propia.........................9
Figura 7 Diagrama de flujo hecho a mano. Subproceso Editar del programa BD
Agencia de Autos. Elaboración Propia...................................................................10
Figura 8 Prueba de escritorio hecha a mano del programa BD Agencia de Autos,
parte 1. Elaboración Propia....................................................................................11
Figura 9 Prueba de escritorio hecha a mano del programa BD Agencia de Autos,
parte 2. Elaboración Propia....................................................................................12
Figura 10 Comprobación de compilado y ejecución del programa. Registro de
Clientes y Consulta de Clientes. Elaboración propia. Fuente: DevC++.................18
Figura 11 Comprobación de compilado y ejecución del programa. Editar Cliente y
Consulta de Clientes. Elaboración propia. Fuente: DevC++..................................18
Figura 12 Comprobación de compilado y ejecución del programa. Salir del
programa. Elaboración propia. Fuente: DevC++....................................................19

Índice de tablas

No se encuentran elementos de tabla de ilustraciones.

 3

INTRODUCCIÓN

Redacta las características de los arreglos, de las estructuras de

datos y los módulos.

Los arreglos son estructuras de datos relacionados en un conjunto de datos del

mismo tipo. En lo que se refiere a las características de los arreglos, éstos tienen
un determinado tamaño, el cual, a su vez, hace referencia a la cantidad de objetos
del mismo tipo que pueden almacenar. Otra característica de los arreglos es que,
éstos, son entidades estáticas debido a que – previamente – se declara su tamaño
y, dicho tamaño lo conservarán a lo largo de la ejecución del programa en el cual
fue declarado.

Las estructuras de datos son colecciones de variables relacionadas bajo un

nombre. Se caracterizan porque pueden contener variables de muchos tipos
diferentes de datos y, es eso precisamente lo que las diferencian de los arreglos,
ya que éstos, solo pueden contener únicamente elementos de un mismo tipo de
datos.

Por último, los módulos (también llamados funciones) son los que permiten crear
un programa en C, ya que se crea combinando el uso de dichas funciones, las
cuales son definidas por el usuario; pueden ser escritas por el programador o bien,
ya existen predefinidas (vienen en las bibliotecas del lenguaje C) y permiten
manejar strings, caracteres específicos, caracteres para cálculos matemáticos, por
citar ejemplos.

(Universidad de la República de Uruguay, 2023)

(Universidad de la República de Uruguay, 2023)
(Universidad Nacional de San Luis, 2023)
 4

DESARROLLO DE LA ACTIVIDAD
Pseudocódigo.

Figura 1 Pseudocódigo hecho a mano parte 1. Evidencia de Aprendizaje. Elaboración propia.

 5

Figura 2 Pseudocódigo hecho a mano parte 2. Evidencia de Aprendizaje. Elaboración propia.

 6

Figura 3 Pseudocódigo hecho a mano parte 3. Evidencia de Aprendizaje. Elaboración propia.

 7
Diagrama de flujo.

Figura 4 Diagrama de flujo hecho a mano. Menú principal del programa BD para Agencia de Autos. Elaboración Propia.
 8

Figura 5 Diagrama de flujo hecho a mano. Subproceso Consultas del programa BD Agencia de
Autos. Elaboración Propia.
 9

Figura 6 Diagrama de flujo hecho a mano. Subproceso Editar y Subproceso Registrar del programa
BD Agencia de Autos. Elaboración Propia.
 10

Figura 7 Diagrama de flujo hecho a mano. Subproceso Editar del programa BD Agencia de Autos.
Elaboración Propia.
 11
Prueba de escritorio.

Figura 8 Prueba de escritorio hecha a mano del programa BD Agencia de Autos, parte 1.
Elaboración Propia
 12

Figura 9 Prueba de escritorio hecha a mano del programa BD Agencia de Autos, parte 2.
Elaboración Propia
 13
Código fuente del programa en lenguaje C.
#include <stdio.h>
#include <string.h>
//Estructura del tipo cliente
struct Cliente
{
char nombre[30];
int codigo;
char direccion[60];
int telefono;
};
//Funcion de consulta
void Consulta(struct Cliente C[],int *cont)
{
int i;
//Estructura condicional if
if(*cont==0)
{
printf("No hay clientes registrados\n");
}else
{
//Estructura ciclica for
for(i=0;i<*cont;i++)
{
printf("Codigo: %d\n",C[i].codigo+1);
printf("Nombre: %s\n",C[i].nombre);
printf("Direccion: %s",C[i].direccion);
printf("Telefono: %d\n",C[i].telefono);
printf("----------------------------\n");
}
}
 14
}
//Funcion de registro
void Registrar(struct Cliente C[],int *cont)
{

C[*cont].codigo = *cont;
printf("Ingrese su nombre: ");
fflush(stdin);
fgets(C[*cont].nombre,30,stdin);
printf("Ingrese su direccion: ");
fgets(C[*cont].direccion,60,stdin);
fflush(stdin);
//Estructura condicional if
if ((strlen(C[*cont].nombre) > 0) &&
(C[*cont].nombre[strlen(C[*cont].nombre) - 1] == '\n'))
{
C[*cont].nombre[strlen(C[*cont].nombre) - 1] = '\0';
}
printf("Ingrese su telefono: ");
scanf("%d",&C[*cont].telefono);
*cont= *cont + 1;
}
//Funcion de editar
void Editar(struct Cliente c[],int *p)
{
printf("Ingrese su nombre: ");
fflush(stdin);
fgets(c[*p].nombre,30,stdin);
printf("Ingrese su direccion: ");
fgets(c[*p].direccion,60,stdin);
fflush(stdin);
//Estructura condicional if
 15
if ((strlen(c[*p].nombre) > 0) && (c[*p].nombre[strlen(c[*p].nombre) - 1] == '\
n'))
{
c[*p].nombre[strlen(c[*p].nombre) - 1] = '\0';
}
fflush(stdin);
printf("Ingrese su telefono: ");
scanf("%d",&c[*p].telefono);
}
//Funcion de eliminar
void Eliminar(struct Cliente c[],int *d, int *cont)
{
int i;
//Estructura ciclica for
for(i=*d;i<*cont;i++)
{
strcpy(c[i].direccion,c[i+1].direccion);
strcpy(c[i].nombre,c[i+1].nombre);
c[i].telefono = c[i+1].telefono;
}
*cont= *cont - 1;
}
//Funcion principal
int main()
{
//Declaracion de varibles
int op,edit,del;
int c = 0;
//Declaracion de arreglo de estructura
struct Cliente clientes[50];
//Estructura ciclica do while
do
{
 16
printf("MENU\n");
printf("1.- Consultar Clientes\n");
printf("2.- Registrar Cliente\n");
printf("3.- Editar Cliente\n");
printf("4.- Eliminar Cliente\n");
printf("5.- Salir\n");
printf("Selecciona una opcion: ");
scanf("%d",&op);
//Estructura condicional switch
switch(op)
{
case 1:
Consulta(clientes,&c);
break;
case 2:
Registrar(clientes,&c);
break;
case 3:
printf("Ingrese el numero de cliente que desea editar: ");
scanf("%d",&edit);
edit--;
Editar(clientes,&edit);
break;
case 4:
printf("Ingrese el numero de cliente que desea eliminar:
");
scanf("%d",&del);
del--;
Eliminar(clientes,&del,&c);
break;
default:
printf("Opcion no dentro del menu.\n");
}
 17

}while(op!=5);
printf("NOMBRE: DILAN JORDI CARRETO ANGULO\nMATRICULA:
ES202118954\nCORREO: dilan.carretoang@nube.unadmexico.mx\n");
printf("Fecha entrega: 29/03/2023\nNombre de actividad:
DFPR_U3_EA_DICA\nCaso de Estudio: BD para Agencia de autos\n ");
return 0;
}
 18
Ejecución del programa en lenguaje C.

Figura 10 Comprobación de compilado y ejecución del programa. Registro de Clientes y Consulta

de Clientes. Elaboración propia. Fuente: DevC++.

Figura 11 Comprobación de compilado y ejecución del programa. Editar Cliente y Consulta de

Clientes. Elaboración propia. Fuente: DevC++.
 19

Figura 12 Comprobación de compilado y ejecución del programa. Salir del programa. Elaboración
propia. Fuente: DevC++.
 20

CONCLUSIONES

Describe cómo se aplicó el diseño descendente y cómo se

implementó arreglos y estructuras de datos.

La Unidad de Apoyo para el Aprendizaje de la UNAM, define en su plataforma de

la Coordinación de Universidad Abierta y Educación a Distancia (CUAED) que, el
“refinamiento progresivo es una técnica de análisis y diseño de algoritmos basada
en la división del problema principal en problemas más simples. Partiendo de
problemas más sencillos se logra dar una solución más efectiva, ya que el número
de variables y casos asociados a un problema simple es más fácil de manejar que
el problema completo. Esta técnica se conoce como top-down (arriba-abajo) y es
aplicable a la optimización del desempeño y a la simplificación de un algoritmo,
conocida también como diseño descendente, consiste en establecer una serie de
niveles de mayor a menor complejidad (arriba-abajo) que den solución al
algoritmo”. (CUAED - UNAM, 2017)

En lo que se refiere a la realización del programa para esta Evidencia de

Aprendizaje, el diseño descendente se aplicó en el momento en que se definieron
subprocesos (los cuales se identifican en los diagramas de flujo).

En cuanto a los arreglos, éstos fueron usados directamente en el programa y,

fueron complementados por las estructuras, es prudente recordar en este punto
que, los arreglos son estructuras de datos relacionados en un conjunto de datos
del mismo tipo, con un determinado tamaño y que hace referencia a la cantidad de
objetos del mismo tipo que pueden almacenar.

Por otro lado, las estructuras de datos son colecciones de variables relacionadas
bajo un nombre. Se caracterizan porque pueden contener variables de muchos
tipos diferentes de datos, por ejemplo, el struck de cliente, le cual está conformado
por: char nombre[30]; int codigo; char direccion[60] e int teléfono.
 21

REFERENCIAS BIBLIOGRÁFICAS

CUAED - UNAM. (2017). Sistematizando Algoritmos - programas.cuaed.unam.mx.

https://programas.cuaed.unam.mx/repositorio/moodle/pluginfile.php/1184/
mod_resource/content/1/contenido/index.html
Rancel, M. R. (2006). Abstracción II. Ejemplos. Diseño top-down de algoritmos y
estrategias de programación. Esquemas (CU00226A) -
www.aprenderaprogramar.es.
https://www.aprenderaprogramar.es/index.php?
option=com_content&view=article&id=260:abstraccion-ii-ejemplos-diseno-
top-down-de-algoritmos-y-estrategias-de-programacion-esquemas-
cu00226a&catid=36&Itemid=60
UNADM. (2023). Programa de la asignatura: Fundamentos de programación.
Unidad 3. Funciones y estructuras de Datos. CDMX: UNADM.
Universidad Autónoma del Estado de Hidalgo. (2023). 1.1.3 Programación
Modular - cidecame.uaeh.edu.mx.
http://cidecame.uaeh.edu.mx/lcc/mapa/PROYECTO/libro32/113_programaci
n_modular.html
Universidad de la República de Uruguay. (2023). Principios de Programación. El
lenguaje C. Arreglos - www.fing.edu.uy.
https://www.fing.edu.uy/tecnoinf/mvd/cursos/prinprog/material/teo/prinprog-
teorico07.pdf
Universidad de la República de Uruguay. (2023). Principios de Programación. El
lenguaje C. Estructuras. - www.fing.edu.uy.
https://www.fing.edu.uy/tecnoinf/mvd/cursos/prinprog/material/teo/prinprog-
teorico08.pdf
Universidad de Murcia. (18 de septiembre de 2017). Programación Estructurada -
webs.um.es. https://webs.um.es/ldaniel/iscyp17-18/10-
programacionEstructurada.html
Universidad Europea. (24 de agosto de 2022). Programación orientada a objetos -
universidadeuropea.com.
https://universidadeuropea.com/blog/programacion-orientada-objetos/
Universidad Nacional de San Luis. (2023). Introducción a la Programación − Notas
de Clase - proguno.unsl.edu.ar. http://proguno.unsl.edu.ar/t2.pdf