1

Universidad Abierta y a Distancia

de México
División de Ciencias Exactas, Ingeniería y
Tecnología Desarrollo de software

Semestre: Primero
Unidad didáctica: Fundamentos de programación
Unidad de aprendizaje: Funciones y estructuras de
datos
Actividad: Evidencia de aprendizaje. Codificación de
algoritmos modulares e implementación de una
estructura de datos.
Nombre del estudiante: Jesús Edgar Solano
Sánchez
Matrícula: ES251117963
Grupo: DS-DFPR-2601-B1-027
Figura académica: Carlos Raul Montaño Espinosa
Fecha de entrega: 10 de marzo de 2026
Ciudad de México, marzo del 2026
 2

ÍNDICE

Contenido
ÍNDICE...............................................................................................................................2

INTRODUCCIÓN...............................................................................................................4

Comunicación entre Módulos: Paso de Parámetros......................................................6

Organización de la Información: Estructuras de Datos..................................................6

DESARROLLO DE LA ACTIVIDAD...................................................................................9

...........................................................................................................................................9

Construye tu propuesta de solución en lenguaje C..................................................10

.........................................................................................................................................11

Código fuente...............................................................................................................12

CONCLUSIÓN.................................................................................................................30

REFERENCIAS BIBLIOGRÁFICAS................................................................................32

GLOSARIO DE TERMINOS............................................................................................33
 3

INTRODUCCIÓN

La evolución de la informática ha transformado la manera en que los seres humanos

resuelven problemas, pasando de una programación manual y física en las primeras

computadoras a lenguajes de alto nivel que simplifican la escritura de código, en sus inicios el

desarrollo del lenguaje C recibió influencia directa de los lenguajes BCPL y B a finales de los

sesenta, consolidándose como una herramienta fundamental en la ingeniería para evitar el

desorden lógico conocido como "código espagueti". En este contexto, el dominio de

metodologías como el diseño descendente (Top-Down), la implementación técnica mediante

funciones y la organización de la información a través de estructuras de datos resultan pilares

indispensables para el desarrollo de software profesional, eficiente y mantenible. (Battistutti

Cairó, 2006, pág. 22).

En los albores de la computación, los programas se escribían en una sola pieza, pero la

complejidad creciente exigió la modularización o descomposición funcional, el diseño

descendente es una metodología basada en la reducción de problemas, la cual consiste en

dividir un problema general extenso en subproblemas más pequeños y manejables. Este

enfoque permite la abstracción, es decir, que el programador se concentre en el "panorama

general" ignorando temporalmente los detalles técnicos de bajo nivel. Si la solución se diseña

correctamente de arriba hacia abajo, el programa resultante será significativamente más fácil

de entender, depurar y modificar. (Farrell, 2013, pág. 62)

En el lenguaje C, la solución a cada subproblema identificado en el diseño modular se

expresa mediante una función, la cual es un bloque de código diseñado para realizar una tarea

específica.
 4

 Declaración, Definición e Invocación: Un programa en C constituye una secuencia de

funciones donde el control siempre inicia en la función main, el proceso requiere una

declaración o prototipo para informar al compilador sobre la existencia de la función,

una definición que contiene las instrucciones lógicas reales y una invocación o llamada

que atrae al módulo para su ejecución, regresando el control al punto de partida una vez

finalizada la tarea.

 Alcance de las variables: El alcance o ámbito define la región del programa donde una

variable es visible y utilizable, las variables locales están limitadas a la función donde se

definen y desaparecen al terminar ésta, mientras que las variables globales tienen un

alcance amplio en todo el programa. Por razones de seguridad y eficiencia, se prefiere

el uso de variables locales para asegurar la independencia de los módulos.

Comunicación entre Módulos: Paso de Parámetros

La interacción entre funciones se logra mediante el paso de parámetros, permitiendo

que los datos fluyan de manera controlada.

 Llamada por Valor: En este método, se pasa una copia de la variable original a la

función. Si el parámetro se altera dentro de la función, la variable original en el

programa principal no se ve afectada.

 Llamada por Referencia: A diferencia del anterior, aquí se envía la dirección de memoria

de la variable mediante el uso de apuntadores. Esto permite que cualquier cambio

realizado dentro de la función afecte directamente al valor de la variable original.

 5

Organización de la Información: Estructuras de Datos

La importancia de las estructuras de datos radica en su capacidad para representar

información compleja del mundo real que no podría manejarse con tipos simples de datos.

 Arreglos (Arrays): Son colecciones finitas, homogéneas y ordenadas de elementos del

mismo tipo almacenados de forma contigua en memoria, lo que facilita el procesamiento

de grandes volúmenes de datos mediante ciclos. En C, los arreglos siempre se pasan a

las funciones por referencia.

 Cadenas (Strings): Técnicamente, son arreglos unidimensionales de tipo char que

deben finalizar obligatoriamente con el carácter nulo (\0) para marcar el fin de la

información.

 Estructuras (Structs): Representan una herramienta poderosa al permitir agrupar

elementos heterogéneos (de diferentes tipos de datos) bajo un solo nombre o

identificador. Esto permite modelar "objetos" reales, como un alumno con su matrícula,

nombre y promedio, agrupando datos que lógicamente pertenecen a una misma

entidad.

En conclusión, la integración de estas técnicas desde la planeación jerárquica hasta la

gestión estricta de datos y memoria es lo que garantiza que un software sea finito, definido y

preciso, cumpliendo con los estándares de calidad necesarios para la ingeniería moderna.

El objetivo primordial de esta actividad, centrada en el Caso de estudio “PAE”, es

automatizar el control del Programa de Actividades Extracurriculares que la preparatoria

"Fuerte de San Diego" oferta a sus alumnos de primer año, mediante el desarrollo de un

programa funcional en lenguaje C.

 6

Los aspectos tratados en la tarea se delimitan con precisión en los siguientes

componentes técnicos y lógicos:

 Codificación de algoritmos modulares: Aplicación del diseño descendente para

estructurar la solución en bloques independientes y manejables.

 Implementación de estructuras de datos: Uso de tipos estructurados para organizar y

almacenar la información de los estudiantes, tales como el número de registro, nombre,

apellido y fecha.

 Interfaz mediante menú interactivo: Desarrollo de un ciclo de control que presente

opciones de registro de estudiante, asignación de PAE y consulta de demanda, el cual

debe ejecutarse de forma continua hasta que el usuario decida salir.

 Procesos de búsqueda y validación: Uso de la matrícula como clave para buscar

alumnos dentro de la estructura; si el estado es "Registrado", el sistema permite asignar

una actividad específica como Danza, Pintura o Debate.

 Identificación institucional: El programa debe desplegar al inicio los datos del estudiante

(nombre, matrícula, grupo) y la unidad didáctica correspondiente.

 Gestión de capacidad: Emisión de mensajes informativos cuando la estructura de datos

alcance su límite máximo de registros.

 Salida de información: Generación de reportes que muestren la demanda de los PAE y

los estudiantes asignados a cada uno.

 7

DESARROLLO DE LA ACTIVIDAD

Figura 1.

Diagrama de flujo modular.

Nota. Elaboración propia del autor (Solano, 2026).

 8

Construye tu propuesta de solución en lenguaje C.

Figura 2.

Programa en lenguaje en entorno Dev-C++.

Nota. Elaboración propia del autor (Solano, 2026).

Explicación:

La imagen muestra un programa en lenguaje C desarrollado en el entorno Dev-C++. El

propósito principal del programa es realizar un sistema para automatizar el control del

“Programa de Actividades Extracurriculares (PAE)” , que se oferta a los alumnos de primer año.
 9

Figura 3.

Programa en ejecución.

Nota. Elaboración propia del autor. (Solano, 2026).

Explicación:

La imagen muestra un programa en lenguaje C siendo ejecutado, mostrando el menú

principal y las diferentes opciones que se tienen para realizar diversas actividades, a modo de

ejemplo se ingresan datos del alumno para la prueba arrojando un registro exitoso con salida.
 10

Código fuente

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <ctype.h>

#include <time.h>

#define MAX_ESTUDIANTES 6

#define MAX_PAE 3

#define MAX_POR_PAE 2

/* Estructura de datos del estudiante */

typedef struct {

int numRegistro;

char fecha[11];

char matricula[5];

char nombre[50];

int estado;

int paeAsignado;

} Estudiante;

/* Variables globales */

Estudiante estudiantes[MAX_ESTUDIANTES];

int totalRegistrados = 0;
 11

int cuposPAE[MAX_PAE + 1] = {0, 0, 0, 0}; /* index 1=Danza,2=Pintura,3=Debate */

char nombresPAE[MAX_PAE + 1][10] = {"", "DANZA", "PINTURA", "DEBATE"};

/* ==================== FUNCIONES DE VALIDACION ====================

*/

/*

* Limpia el buffer de entrada para evitar que caracteres sobrantes

* contaminen la siguiente lectura (scanf deja '\n' en el buffer).*/

void limpiarBuffer() {

int c;

while ((c = getchar()) != '\n' && c != EOF);

/* Rechaza letras, simbolos y valores fuera del rango [min, max].*/

int leerEnteroSeguro(int min, int max) {

char linea[20];

int valor;

char *fin;

while (1) {

/* Leer linea completa como texto */

if (fgets(linea, sizeof(linea), stdin) == NULL) {

 12

continue;

/* Eliminar salto de linea al final */

linea[strcspn(linea, "\n")] = '\0';

/* Verificar que no este vacio */

if (strlen(linea) == 0) {

printf(" Entrada vacia. Intente de nuevo: ");

continue;

/* Convertir a entero y verificar que TODA la cadena sea numerica */

valor = (int)strtol(linea, &fin, 10);

if (*fin != '\0') {

/* fin no apunta al final: habia letras o simbolos */

printf(" Solo se permiten numeros enteros. Intente de nuevo: ");

continue;

/* Verificar rango */

if (valor < min || valor > max) {

printf(" Opcion fuera de rango (%d-%d). Intente de nuevo: ", min, max);

continue;
 13

return valor;

/*

* Obtiene la fecha actual del sistema y la devuelve como enteros.

* diaHoy, mesHoy, anioHoy se llenan por referencia.

*/

void obtenerFechaHoy(int *diaHoy, int *mesHoy, int *anioHoy) {

time_t t = time(NULL);

struct tm *hoy = localtime(&t);

*diaHoy = hoy->tm_mday;

*mesHoy = hoy->tm_mon + 1; /* tm_mon es 0-11 */

*anioHoy = hoy->tm_year - 100; /* tm_year desde 1900, queremos 2 digitos */

/*

* Valida que la cadena tenga el formato DD/MM/AA:

* - Longitud exacta de 8 caracteres

* - Posiciones correctas de digitos y '/'

* - Dia 01-31, Mes 01-12

* - La fecha no puede ser anterior a la fecha actual del sistema

* Retorna 1 si es valida, 0 si no.

 14

*/

int validarFecha(const char *f) {

int dia, mes, anio;

int diaHoy, mesHoy, anioHoy;

if (strlen(f) != 8) return 0;

if (!isdigit(f[0]) || !isdigit(f[1])) return 0;

if (f[2] != '/') return 0;

if (!isdigit(f[3]) || !isdigit(f[4])) return 0;

if (f[5] != '/') return 0;

if (!isdigit(f[6]) || !isdigit(f[7])) return 0;

dia = (f[0]-'0')*10 + (f[1]-'0');

mes = (f[3]-'0')*10 + (f[4]-'0');

anio = (f[6]-'0')*10 + (f[7]-'0');

if (dia < 1 || dia > 31) return 0;

if (mes < 1 || mes > 12) return 0;

/* Comparar contra la fecha actual del sistema */

obtenerFechaHoy(&diaHoy, &mesHoy, &anioHoy);

if (anio < anioHoy) return 0;

if (anio == anioHoy && mes < mesHoy) return 0;

 15

if (anio == anioHoy && mes == mesHoy && dia < diaHoy) return 0;

return 1;

/*

* Valida que la matricula tenga exactamente 4 digitos numericos.

* Retorna 1 si es valida, 0 si no.

*/

int validarMatricula(const char *m) {

int i;

if (strlen(m) != 4) return 0;

for (i = 0; i < 4; i++) {

if (!isdigit(m[i])) return 0;

return 1;

/*

* Valida que el nombre no este vacio y solo contenga letras y espacios.

* Retorna 1 si es valido, 0 si no.

*/

int validarNombre(const char *n) {

int i, len;

len = strlen(n);
 16

if (len == 0) return 0;

for (i = 0; i < len; i++) {

if (!isalpha(n[i]) && n[i] != ' ') return 0;

return 1;

/* ==================== FUNCIONES MODULARES ==================== */

/* Datos del alumno y actividad */

void mostrarEncabezado() {

printf("============================================================

===========\n");

printf("Nombre completo : Jesus Edgar Solano Sanchez\n");

printf("Matricula : ES2511117963\n");

printf("Grupo : DS-DFPR-2601-B1-027\n");

printf("============================================================

===========\n");

printf("Evidencia de Aprendizaje: Codificacion de algoritmos modulares\n");

printf("e implementacion de una estructura de datos\n");

printf("============================================================

===========\n\n");

/* Muestra el menu principal */

 17

void mostrarMenu() {

printf("==========================================\n");

printf(" PROGRAMA DE ACTIVIDADES\n");

printf(" EXTRACURRICULARES (PAE)\n");

printf("==========================================\n");

printf("1. Registro estudiante\n");

printf("2. Asignacion PAE\n");

printf("3. Consultar demanda PAE's\n");

printf("4. Salir\n\n");

printf("Selecciona una opcion: ");

/* Busca estudiante por matricula, retorna indice o -1 si no existe */

int buscarEstudiante(char matricula[]) {

int i;

for (i = 0; i < MAX_ESTUDIANTES; i++) {

if (estudiantes[i].estado > 0 &&

strcmp(estudiantes[i].matricula, matricula) == 0) {

return i;

return -1;

/* Opcion I: Registro de estudiante */

 18

void registrarEstudiante() {

char opcion[5];

printf("==========================================\n");

printf("1. REGISTRO ESTUDIANTE\n");

printf("==========================================\n");

if (totalRegistrados >= MAX_ESTUDIANTES) {

printf("YA NO SE PUEDEN REGISTRAR MAS ESTUDIANTES.\n");

return;

do {

int idx = totalRegistrados;

estudiantes[idx].numRegistro = totalRegistrados + 1;

estudiantes[idx].estado = 1;

estudiantes[idx].paeAsignado = 0;

printf("\nRegistro No.: %d\n\n", estudiantes[idx].numRegistro);

/* --- Validacion de fecha DD/MM/AA (no anterior a hoy) --- */

int dHoy, mHoy, aHoy;

obtenerFechaHoy(&dHoy, &mHoy, &aHoy);

while (1) {
 19

printf("Fecha(DD/MM/AA): ");

if (fgets(estudiantes[idx].fecha, sizeof(estudiantes[idx].fecha), stdin) == NULL)

continue;

estudiantes[idx].fecha[strcspn(estudiantes[idx].fecha, "\n")] = '\0';

if (validarFecha(estudiantes[idx].fecha)) break;

printf(" Fecha invalida. Use DD/MM/AA con numeros y no anterior a hoy

(%02d/%02d/%02d): ",

dHoy, mHoy, aHoy);

/* --- Validacion de matricula (4 digitos y no duplicada) --- */

char matTemp[10];

while (1) {

printf("\nMatricula (4 digitos): ");

if (fgets(matTemp, sizeof(matTemp), stdin) == NULL) continue;

matTemp[strcspn(matTemp, "\n")] = '\0';

if (!validarMatricula(matTemp)) {

printf(" La matricula debe tener exactamente 4 digitos numericos.");

continue;

}
 20

/* Verificar que la matricula no este ya registrada */

if (buscarEstudiante(matTemp) != -1) {

printf(" Esa matricula ya esta registrada. Ingrese una diferente.");

continue;

/* Copiar al arreglo solo si paso todas las validaciones */

strncpy(estudiantes[idx].matricula, matTemp, 5);

break;

/* --- Validacion de nombre (solo letras y espacios) --- */

while (1) {

printf("\nEstudiante (nombre y apellido): ");

if (fgets(estudiantes[idx].nombre, sizeof(estudiantes[idx].nombre), stdin) ==

NULL) continue;

estudiantes[idx].nombre[strcspn(estudiantes[idx].nombre, "\n")] = '\0';

if (validarNombre(estudiantes[idx].nombre)) break;

printf(" El nombre solo puede contener letras y espacios, no puede estar

vacio.");

}
 21

totalRegistrados++;

printf("\nESTUDIANTE REGISTRADO.\n");

if (totalRegistrados >= MAX_ESTUDIANTES) {

printf("YA NO SE PUEDEN REGISTRAR MAS ESTUDIANTES.\n");

break;

/* --- Validacion de opcion R/M --- */

while (1) {

printf("\n¿Registrar otro estudiante[R] o regresar al menu[M]?: ");

if (fgets(opcion, sizeof(opcion), stdin) == NULL) continue;

opcion[strcspn(opcion, "\n")] = '\0';

if (strlen(opcion) == 1 &&

(opcion[0]=='R' || opcion[0]=='r' || opcion[0]=='M' || opcion[0]=='m')) break;

printf(" Opcion invalida. Escriba R o M.");

} while (opcion[0] == 'R' || opcion[0] == 'r');

/* Opcion II: Asignacion PAE */

 22

void asignarPAE() {

char matricula[10];

int idx, paeElegido;

printf("==========================================\n");

printf("2. ASIGNACION PAE\n");

printf("==========================================\n\n");

/* --- Validacion de matricula --- */

while (1) {

printf("Ingresa la matricula (4 digitos): ");

if (fgets(matricula, sizeof(matricula), stdin) == NULL) continue;

matricula[strcspn(matricula, "\n")] = '\0';

if (validarMatricula(matricula)) break;

printf(" La matricula debe tener exactamente 4 digitos numericos.\n");

idx = buscarEstudiante(matricula);

if (idx == -1) {

printf("\nMATRICULA NO ENCONTRADA.\n");

return;

}
 23

printf("\nNo. Registro: %d\n", estudiantes[idx].numRegistro);

printf("Fecha registro: %s\n", estudiantes[idx].fecha);

printf("Estudiante: %s\n", estudiantes[idx].nombre);

if (estudiantes[idx].estado == 2) {

printf("\nEstado: ASIGNADO - %s\n", nombresPAE[estudiantes[idx].paeAsignado]);

printf("\nESTUDIANTE CUENTA CON REGISTRO Y PAE ASIGNADO.\n");

return;

printf("\nEstado: REGISTRADO\n");

printf("\nSelecciona PAE\n\n");

printf("1. DANZA\n");

printf("2. PINTURA\n");

printf("3. DEBATE\n\n");

/* --- Validacion opcion PAE --- */

printf("Escribe el numero: ");

paeElegido = leerEnteroSeguro(1, 3);

if (cuposPAE[paeElegido] >= MAX_POR_PAE) {

printf("\nPAE SIN CUPO\n");

return;

}
 24

/* Realizar asignacion */

cuposPAE[paeElegido]++;

estudiantes[idx].paeAsignado = paeElegido;

estudiantes[idx].estado = 2;

printf("\nESTUDIANTE ASIGNADO AL PAE DE %s\n", nombresPAE[paeElegido]);

/* Opcion III: Consultar demanda PAE's */

void consultarDemanda() {

int p, i, encontrados;

printf("==========================================\n");

printf("3. CONSULTAR DEMANDA PAE'S\n");

printf("==========================================\n\n");

/* Verificar que exista al menos un estudiante registrado */

if (totalRegistrados == 0) {

printf("No hay estudiantes registrados en el sistema.\n");

return;

for (p = 1; p <= MAX_PAE; p++) {

printf("====%s====\n", nombresPAE[p]);

encontrados = 0;
 25

/* Solo recorrer hasta totalRegistrados, no MAX_ESTUDIANTES */

for (i = 0; i < totalRegistrados; i++) {

if (estudiantes[i].estado == 2 && estudiantes[i].paeAsignado == p) {

printf(" %s\n", estudiantes[i].nombre);

encontrados++;

/* Mensaje cuando el PAE no tiene asignados todavia */

if (encontrados == 0) {

printf(" (Sin estudiantes asignados)\n");

printf("\n");

printf("Presiona Enter para continuar...");

getchar();

/* Opcion IV: Salir */

void salir() {

printf("\nGRACIAS POR USAR EL PROGRAMA DE ACTIVIDADES

EXTRACURRICULARES.\n");

}
 26

/* ==================== FUNCION PRINCIPAL ==================== */

int main() {

int opcion;

/* Inicializar arreglo de estudiantes */

memset(estudiantes, 0, sizeof(estudiantes));

mostrarEncabezado();

do {

mostrarMenu();

/* --- Validacion del menu principal: solo enteros 1-4 --- */

opcion = leerEnteroSeguro(1, 4);

printf("\n");

switch (opcion) {

case 1:

registrarEstudiante();

break;

case 2:

asignarPAE();

break;

case 3:
 27

consultarDemanda();

break;

case 4:

salir();

break;

printf("\n");

} while (opcion != 4);

return 0;

CONCLUSIÓN
 28

En conclusión, el desarrollo del Caso de estudio “PAE” permitió integrar de manera

práctica los fundamentos de la programación estructurada y modular para resolver un problema

de automatización escolar. Los puntos clave tratados incluyeron la aplicación de la metodología

de diseño descendente (Top-Down), la implementación de funciones con paso de parámetros y

el uso de estructuras de datos complejas como arreglos de estructuras y cadenas de

caracteres. (Codigofacilito, 2017).

El objetivo planteado se logró al construir un software funcional que automatiza el

control del programa de actividades extracurriculares, mediante una arquitectura modular

coordinada por la función main, se garantizó el registro ordenado de hasta seis estudiantes, la

búsqueda precisa por matrícula y la asignación efectiva a actividades como danza, pintura o

debate, controlando en todo momento el cupo máximo por taller.

En cuanto a la reflexión sobre los aprendizajes, destaca la importancia de la

abstracción, que permite descomponer el sistema en subproblemas manejables e

independientes. Asimismo, se comprendió que el uso de variables locales y el paso de

parámetros por valor y referencia es vital para mantener la independencia de los módulos y la

integridad de la memoria.

Los desafíos enfrentados se centraron principalmente en la planeación lógica, evitar el

"código espagueti" requirió un esfuerzo intelectual profundo para "desenredar" los procesos y

transformarlos en estructuras de secuencia, selección y ciclo coherentes. Además, la gestión

de los límites de las estructuras de representó un reto técnico para asegurar la estabilidad del

programa bajo diferentes escenarios de uso.

 29

Finalmente, este trabajo refuerza la relevancia del tema en el contexto de la ingeniería y

el desarrollo de sistemas de control, el dominio del lenguaje C y sus estructuras no solo permite

crear software confiable y eficiente que se acerca al hardware, sino que sienta las bases

indispensables para transitar hacia paradigmas más avanzados como la programación

orientada a objetos.
 30

REFERENCIAS BIBLIOGRÁFICAS

Battistutti Cairó, O. (2006). Fundamentos de programacion. Piensa en C. (P. M. Rosas, Ed.)

Ciudad de México, México : Pearson Educación de México. Recuperado el 09 de 02 de

2026

Codigofacilito. (14 de 03 de 2017). Curso Basico de C. Estructuras. Obtenido de YouTube :

[Link]

v=6eEYpo0CIRY&list=TLGGll5v9qgXx1swOTAzMjAyNg

Farrell, J. (2013). Introducción a la programación lógica y diseño (7ma ed.). Cd de México,

Mexico: Cencage Learnig Editores. Recuperado el 11 de 02 de 2026

 31

GLOSARIO DE TERMINOS

 Abstracción: Proceso mental que permite al programador concentrarse en el

"panorama general" de un problema, ignorando temporalmente los detalles técnicos de

bajo nivel para simplificar el diseño.3

 Alcance de las variables (o ámbito): Define la región del programa donde una variable

es visible y utilizable. Se divide principalmente en arreglos locales (limitadas a una

función) y globales (con alcance en todo el programa).4

 Arreglos (Arrays): Colecciones finitas, homogéneas y ordenadas de elementos del

mismo tipo que se almacenan de forma contigua en la memoria.5

 Cadenas (Strings): Técnicamente son arreglos unidimensionales de tipo char que

deben finalizar obligatoriamente con el carácter nulo (\0) para marcar el fin de la

información.5

 Código espagueti: Término que describe un desorden lógico en la escritura de código,

característico de programas escritos sin una metodología estructurada.3

 Código fuente: Conjunto de instrucciones escritas en un lenguaje de programación

(como el lenguaje C) que conforman la lógica técnica y funcional de un sistema de

software.10

 Declaración (o prototipo): Instrucción que informa al compilador sobre la existencia de

una función, detallando su nombre y tipo antes de su ejecución.4

 Definición (de función): Bloque de código que contiene las instrucciones lógicas

reales diseñadas para realizar una tarea específica.4

 Diagrama de flujo modular: Representación gráfica que ilustra la descomposición de

un problema complejo en módulos independientes y manejables.7

 32

 Diseño descendente (Top-Down): Metodología basada en la reducción de problemas,

que consiste en dividir un problema general extenso en subproblemas más pequeños y

fáciles de procesar.3

 Estructuras (Structs): Herramienta poderosa que permite agrupar elementos

heterogéneos (de diferentes tipos de datos) bajo un solo nombre o identificador para

modelar objetos de la realidad.5

 Invocación (o llamada): Acción de ejecutar una función, lo que atrae al módulo para

procesar sus instrucciones y, al finalizar, regresa el control al punto de partida en el

programa.4

 Llamada por referencia: Método de interacción donde se envía la dirección de

memoria de una variable a una función, permitiendo que cualquier cambio afecte

directamente al valor original.4

 Llamada por valor: Método en el que se pasa una copia de la variable original a la

función; los cambios realizados dentro de la función no afectan a la variable en el

programa principal.4

 Modularización: Técnica de descomposición funcional necesaria para manejar la

complejidad creciente de los programas, dividiéndolos en piezas independientes.3

 Paso de parámetros: Mecanismo mediante el cual las funciones interactúan,

permitiendo que los datos fluyan de manera controlada entre diferentes módulos.4

 Variables locales: Datos definidos dentro de una función específica que desaparecen

al terminar la ejecución de esta, garantizando la independencia de los módulos y la

integridad de la memoria.4