Introducción A La Informática: Algoritmos y Porgramación en Lenguaje C

See
discussions, stats, and author profiles for this publication at: https://www.researchgate.net/publication/251740349
Introducción a la Informática: Algoritmos y

Porgramación en Lenguaje C
Book · January 2001
CITATIONS READS
0 946
3 authors:
Miguel Angel Niño Zambrano Carlos Cobos

Universidad del Cauca Universidad del Cauca
34 PUBLICATIONS 28 CITATIONS 91 PUBLICATIONS 373 CITATIONS
SEE PROFILE SEE PROFILE
Martha Eliana Mendoza

Universidad del Cauca
44 PUBLICATIONS 236 CITATIONS
SEE PROFILE
Some of the authors of this publication are also working on these related projects:
CVN-Virtual E-Commerce Community View project
Cpe-Unicauca View project
All content following this page was uploaded by Miguel Angel Niño Zambrano on 23 December 2013.
The user has requested enhancement of the downloaded file.

Introducción a
la informática
Algoritmos y Programación en Lenguaje C
Miguel Ángel Niño Zambrano

Carlos Alberto Cobos Lozada
Martha Eliana Mendoza Becerra
TOMO II
PRIMERA EDICION
UNIVERSIDAD DEL CAUCA

FACULTAD DE INGENIERÍA ELECTRÓNICA Y TELECOMUNICACIONES
DEPARTAMENTO DE SISTEMAS
POPAYÁN,
2001
INTRODUCCION A LA INFORMATICA
Algoritmos y Programación en Lenguaje C
MIGUEL ANGEL NIÑO ZAMBRANO

CARLOS ALBERTO COBOS LOZADA
MARTHA ELIANA MENDOZA BECERRA
UNIVERSIDAD DEL CAUCA

FACULTAD DE INGENIERÍA ELECTRÓNICA Y
TELECOMUNICACIONES
DEPARTAMENTO DE SISTEMAS
POPAYÁN
2001
CONTENIDO
Pag.
FUNDAMENTOS DE PROGRAMACIÓN 1
4.1. CONCEPTOS BÁSICOS DE ALGORITMOS 2
4.1.1 Algoritmo 2
4.1.2. Diferencia entre el lenguaje algorítmico y el informático. 2
4.1.3. Características de un algoritmo 2
4.1.4. Planteamiento de Problemas. 3
4.2. METAALGORITMO PARA CREAR ALGORITMOS 4
4.2.1. Fase de Formulación del Problema 4
4.2.2. Fase de resolución del problema 4
4.2.3. Fase de Implementación 6
4.3. EJERCICIOS RESUELTOS 9
4.3.1. Ejemplo 1: Lanzar dados hasta obtener par 10
4.3.2. Ejemplo 2: Conversión de temperaturas 14
4.3.3. Ejemplo 3: Ir al cine 15
4.3.4. Ejemplo 4: Palíndromo 16
4.4. EJERCICIOS PROPUESTOS 18
INTRODUCCIÓN A LAS ESTRUCTURAS DE DATOS 19
4.5. CONCEPTOS BÁSICOS DE ESTRUCTURAS DE DATOS 20
4.5.1. Tipos de datos 20
4.5.2. Clasificación de los Datos 20
4.5.3. Tipos de Datos en C 22
4.5.4. Operadores 23
4.5.5. Operadores en Lenguaje C 25
4.5.6. Representación de los datos, constantes, variables y tipos definidos 26
HERRAMIENTAS DE PROGRAMACIÓN 35
4.8. HERRAMIENTAS DE PROGRAMACIÓN 36
4.8.1. Tipos de Herramientas de programación 36
PROGRAMACIÓN ESTRUCTURADA 59
4.11. PROGRAMACIÓN ESTRUCTURADA 60
4.11.1. Estructura general de un programa 60
4.11.2. Estructuras Básicas de Control de Programa 68
PROGRAMACIÓN MODULAR 87
4.13. PROGRAMACIÓN MODULAR 88
4.13.1. Subprogramas 88
4.13.2. Tipos de Subprogramas 89
4.13.3. Recursividad 114
LISTA DE CUADROS
Pag.
Cuadro 1: Algunas Funciones Predefinidas En Los Lenguajes 29
Cuadro 2: Comparación Entre Diagramas De Flujo, Pseudocódigo Y

Programación C ¡ERROR! MARCADOR NO DEFINIDO.
Cuadro 3: Estructura De Los Tipos De Recursividad 115
Cuadro 4 Alcance De Las Variables En C/C++ 123
Cuadro 5 Prefijos Para Los Tipos De Datos Básicos De C 124
Cuadro 6 Prefijos Para El Alcance De Las Variables 124

LISTA DE FIGURAS
Pag.
Figura1: Análisis Del Problema De Lanzar Dados Hasta Obtener Par 10
Figura 2: A,B Anidamientos Correctos, C Anidamiento Incorrecto 73
Figura 3: Explicación De La Recursividad 116

LISTA DE EJEMPLOS
Pag.
Ejemplo 1: Tirar Los Dados Hasta Obtener Par 13
Ejemplo 2: Conversión De Temperaturas 14
Ejemplo 3: Ir Al Cine 15
Ejemplo 4: Palíndromo 17
Ejemplo 5: Hallar El Área De Un Triángulo 39
Ejemplo 6: Calcular El Mayor De Tres Números 40
Ejemplo 7: Imprimir Un Menú De Opciones 42
Ejemplo 8: Calculo De La Potencia Xn 42
Ejemplo 9: Hallar El Área De Un Triángulo Pseudocódigo 44
Ejemplo 10: Uso De Constantes (Calculo Del Perímetro) 48
Ejemplo 11: Uso De Variables 50
Ejemplo 12: Uso De Operadores 54
Ejemplo.13: Uso De Printf 56
Ejemplo 14: Calculo De Promedio De Un Estudiante 57
Ejemplo 15: Establecer Si Un Número Es Negativo 70
Ejemplo 16: Establecer Si Un Número Es Par O Impar 72

Ejemplo.17: Determinar Si Es Bebe, Niño O Adulto 75
Ejemplo 18: Menu De Operaciones Matemáticas 80
Ejemplo 19: Presentar Los Números Del 1 Al 100 Menos El 25 82
Ejemplo 20: Tablas De Multiplicar 84
Ejemplo 21: Función Valor Absoluto 105
Ejemplo 22: Función Factorial 107
Ejemplo 23: Programa Completo De Funciones 112
Ejemplo 24: Función Valor Absoluto 118

PARTE II: EL COMPUTADOR COMO HERRAMIENTA PARA LA
SOLUCIÓN DE PROBLEMAS ALGORITMICOS
OBJETIVOS
OBJETIVO GENERAL
ü Mediante este tomo se logrará conocer las metodologías y herramientas
utilizadas en la solución de problemas por computadora.
OBJETIVOS ESPECÍFICOS
ü Establecer los diferentes métodos para analizar y solucionar un problema dado
por medio de un algoritmo.
ü Configurar un modelo a seguir para analizar los problemas de tal forma que se
guíen con una estructura propia.
ü Manipular y conocer las diferentes He rramientas de Diseño de algoritmos como
diagramas de flujo, diagramas N-S y pseudocódigo.
ü Establecer una guía estándar para la elaboración de los algoritmos mediante
diagramas de flujo y pseudocódigo.
ü Manipular el lenguaje de programación C para implementar un algoritmo.
ü Establecer la cultura de la comprobación del algoritmo, que permita refinarlo y
darle una depuración mas adecuada.
ü Identificar claramente las partes de un algoritmo, de tal forma que se pueda dar
uniformidad y estructura a la solución de problemas.
FUNDAMENTOS DE PROGRAMACIÓN
Introducción:
En este capitulo se van a explorar los conceptos fundamentales de la creación de

algoritmos, se darán guías y pasos a seguir para diseñar e implementar de una
forma eficiente y adecuada un algoritmo. Se presenta una plantilla llamada
metaalgoritmo para crear algoritmos, la cual se constituye en un modelo a
seguir para la creación de los mismos, otro elemento importante es la
presentación del enfoque sistémico para el entendimiento y diseño de
soluciones, el cual plantea un modelo práctico para analizar y definir acciones a
seguir en el algoritmo. Finalmente se presenta una plantilla de solución de
problemas por medio de algoritmos, la cual será utilizada a lo largo del libro
para presentar los pasos en el desarrollo de los problemas, además, en una
apartado se da una introducción al lenguaje C.
1
4.1. CONCEPTOS BÁSICOS DE ALGORITMOS
4.1.1. Algoritmo. Un algoritmo es el conjunto de operaciones y

procedimientos que deben seguirse para resolver un problema. La palabra
"algoritmo" deriva del nombre latinizado del gran matemático árabe Mohamed Ibn
Moussa Al Kow Rizmi, el cual escribió entre los años 800 y 825 su obra Quitab Al
Jabr Al Mugabala, donde se recogía el sistema de numeración hindú y el
concepto del cero. Fue Fibonacci, el que tradujo su obra al latín y la inició con
las palabras: Algoritmi dicit.
4.1.2. Diferencia entre el lenguaje algorítmico y el informático. El lenguaje

algorítmico es aquel por medio del cual se realiza un análisis previ o del problema
a resolver y además permite encontrar un método para resolverlo. Al conjunto de
todas las operaciones a realizar así como el orden en el que deben efectuar, se le
denomina algoritmo.
El lenguaje informático es aquel por medio del cual dicho algoritmo se codifica a
un sistema comprensible por el ordenador o computador. Este tipo de lenguaje es
más cercano a la máquina que al ser humano y podemos distinguir distintos tipos
dependiendo de la proximidad que se da a esta ultima. Se denomina lenguaje de
alto nivel aquel que es más cercano a la comprensión humana y lenguaje de bajo
nivel a aquellos que son más comprensibles por la máquina. En nuestro caso,
nosotros vamos a estudiar un lenguaje en la frontera de uno de bajo nivel y de uno
de alto nivel. La posibilidad de utilizar el lenguaje 'C' como un lenguaje de bajo
nivel, le da al mismo una potencia y rapidez especial.
4.1.3. Características de un algoritmo. Las carateristicas son:

ü Preciso: Un algoritmo debe describir claramente el orden de realización de
cada uno de sus pasos.
ü Definido: Un algoritmo es definido cuando al ejecutarse con datos iguales en
distintas ocasiones, produce resultados iguales en todas las ocasiones.
ü Finito: Los algoritmos deben estar constituidos por un número finito de pasos.
ü Independiente del Lenguaje de Programación: Los algoritmos deben ser
diseñados de forma independiente al lenguaje de programación en el que se
implemente. Es decir, su implementación debe ser posible en cualquier
lenguaje de programación.
2
4.1.4. Planteamiento de Problemas. Lo que pretende un algoritmo es sintetizar
de alguna forma una tarea, cálculo o mecanismo antes de ser trascrito al
ordenador. Los pasos que se deben seguir son los siguientes:
ü Análisis previo del problema.

ü Visión preliminar del método de resolución.
ü Descomposición en módulos (Programación estructurada).
ü Búsqueda de soluciones parciales.
ü Ensamblaje de soluciones finales.
Uno de los mejores métodos de diseño de algoritmos consiste en partir los

conceptos generales en conceptos especificos (buscando ir de lo general hacia lo
particular), con refinamientos sucesivos. A esto se le conoce como metodología
TOP–DOWN.
Veamos un ejemplo inicial de un algoritmo y su solución:
Descripción del problema:

Calcular y mostrar las raíces reales para una ecuación de segundo grado de la
forma ax2 +bx+c=0
Pseudocódigo:
Algoritmo raíces;
Variables reales a, b, c, x, y;
Inicio
Escribir "Introduzca los coeficientes de mayor a menor grado."
Leer a, b, c
Si (sqr(b)>= 4*a*c) entonces

X=(-b + sqrt(b^2 -4*a*c))/2*a
Y=(-b - sqrt(b^2-4*a*c))/2*a
Mostrar X, Y
Sino
Escribir "No existen raíces reales."
Finsi
Fin.
Ejemplo pseudocódigo raíces ax2+bx+c=0
Todas las actividades que hacemos, en su mayoría siguen una serie consecutiva y
ordenada de pasos o algoritmos. Desde el momento en que estamos planeando
hacer algo, estamos diseñando un algoritmo. Por ejemplo: estando en casa, de
pronto se daña una bombilla, nuestro primer movimiento es el de cambiarla por
una nueva. El primer acto reflejo sería el tomar la bombilla dañada y bajarla de su
sitio. Después de un corto tiempo empezamos a analizar el problema con mayor
3
detenimiento y nos preguntamos ciertas cosas que nos hacen falta (datos de
entrada). ¿Dónde esta las bombillas nuevas?, como bajo la bombilla dañada,
siendo el caso que se encuentre en un sitio alto o difícil de tomar?; resolviendo
estas dudas sé que lo primero es apagar el circuito o en dado caso cortar la
energía en la caja de electricidad, luego buscar una butaca para alcanzar la
bombilla dañada, pero antes debo proteger mi mano, por si la bombilla esta aún
caliente, pero si es de neón no me preocupo esta no se calienta mucho (datos
auxiliares), luego debo ir por la bombilla nueva, enroscarla o colocarla con mucho
cuidado y prender el circuito para verificar que quedo bien instalada la bombilla
(datos de salida).
De esta manera podemos establecer unas etapas o pasos que nos permitan
solucionar problemas de forma algorítmica.
4.2. METAALGORITMO PARA CREAR ALGORITMOS
En este apartado presentamos un modelo para la creación de algoritmos, en éste

se encuentran unas pautas o pasos específicos que permiten concebir y crear
algoritmos eficientes. Con ello no pretendemos establecer una camisa de fuerza
para la solución de los problemas. Ver la Figura1.
4.2.1. Fase de Formulación del Problema. Esta fase corresponde a la forma de

hacer la postulación del problema, cabe destacar el orden que se debe llevar para
los mismos, por esta razón se debe llevar un código que necesariamente debe
ser consecutivo, una palabra o conjunto de palabras clave para determinar el
origen del problema o el nombre del problema, y finalmente el enunciado de
manera concisa y precisa.
4.2.2. Fase de resolución del problema. En esta fase se hace el análisis y diseño
del algoritmo, para tener una buena visión de la misma se den tener en cuenta los
siguientes elementos en el análisis del problema:
ü Descripción: Corresponde a una interpretación personal que consiste en

palabras, gráficos o cualqui er tipo de especificación propia de la persona que
diseña el algoritmo. Eso le permitirá asimilar y comprender el problema y las
posibles soluciones al mismo. En el ejemplo anterior la solución fácil y efectiva
era la aplicación de la fórmula cuadrática (=(-b +- sqrt(b^2-4*a*c))/2*a) junto
con la evaluación del determinante para conocer si la ecuación tiene raíces
reales.
4
Código
Fase de formulación Nombre
del problema Enunciado
Análisis del Problema

Etapas para Fase de resolución del
resolver problema
problemas Diseño y verificación
del Algoritmo
Codificación y
Fase de Comprobación del
Implementación programa
Autodocumentación y
presentación
Figura 1: Etapas para resolver problemas
ü Entradas: Corresponde a la información dada al problema. En el ejemplo

anterior los datos de entrada son los coeficientes de la fórmula a, b, c.
ü Procesos: Son todas las operaciones y/o cálculos que se realizan en el

algoritmo. En el ejemplo anterior los procesos corresponden a la lectura de los
coeficientes, verificación de raíces reales y cálculo de la formula.
ü Salidas: Son las respuestas que presenta el algoritmos, y el objeto por el cual
se resuelve y satisface el problema dado. En el ejemplo anterior las salidas
corresponden a las raíces reales x, y o el mensaje “No Existen raíces reales”.
ü Datos Auxiliares: Corresponde a datos que permiten tomar decisiones o se

convierten en limitantes y restricciones al problema. En el ejemplo anterior la
restricción que se manejó fue el determinante de la ecuación cuadrática.
Aplicando el modelo clásico de sistemas (entradas, procesos, salidas,

realimentación). Un modelo adecuado para ayudar a identificar las Entradas,
procesos y salidas de un algoritmo sería:
5
ENTRADAS PROCESOS SALIDAS
Proceso 1;
¿Cuántas salidas hay?
¿Cuántos Datos? Proceso 2;
¿Cuáles son salidas?
¿Qué Datos? ... ¿Cuál es la Precisión
¿Cuáles son Válidos? Proceso N;
de los resultados?
Fin.
¿Qué límites?
REALIMENTACIO
¿Los resultados son correctos?
Figura 2: Modelo de Análisis de los problemas
Las preguntas del modelo, permiten establecer los Datos de Entrada, los Datos de
Salida, los Datos Auxiliares, y los procesos que se deben realizar para modelar y
diseñar el algoritmo.
Existen a su vez herramientas de programación que permitirán establecer el

diseño del algoritmo en formatos estandarizados 1 tal como se vera en un tema
posterior a este. Estos son los Diagramas de flujo, Diagramas N–S, y el
pseudocódigo. Con estas herramientas se modela el problema y se puede
comprobar lo que se conoce como traza de un algoritmo, y consiste en hacer la
prueba del mismo, verificando y refinándolo a partir de datos significativos (son
todas las posibles variaciones de los datos de entrada de un algoritmo) y sobre el
papel.
4.2.3. Fase de Implementación. Es la fase de codificación o traducción del

algoritmo al lenguaje de programación escogido, que ha de ser completado con la
ejecución y comprobación del programa en la computadora.
En la fase de implementación a menudo los programas se diseñan sin ningún tipo

de presentación y documentación. Hoy en día es tan importante que un programa
funcione correctamente, como la autodocumentación en la misma línea de
codificación de los mismos. La reutilización de programas por diferentes usuarios
en las empresas, y hasta por el mismo creador del programa, hace que necesite
entender y modificar rápidamente el código ya escrito. Esta tarea puede ser tan
tediosa y costosa como la de volver a diseñar los algoritmos desde cero. Por esto
es preciso establecer desde el principio estándares tanto en la pseudocodificación
como el la codificación y documentación de los programas escritos. El Anexo A
1
Estos estándares han sido modificados y adaptados a las necesidades del Programa de
Ingeniería de Sistemas de la Facultad de Ingeniería Electrónica y Telecomunicaciones de la
Universidad del Cauca.
6
presenta las Normas que escogeremos en este texto para la documentación de los
programas.
LENGUAJES DE PROGRAMACION
Un lenguaje de programación es una notación para escribir programas, es decir,

para describir algoritmos dirigidos al computador. Un lenguaje viene dado por una
gramática o conjunto de reglas que se aplican a un alfabeto. El primer lenguaje de
programación que se utilizó fue el lenguaje máquina, el único que entiende
directamente el computador, cuyo alfabeto es el binario, formado por los símbolos
0 y 1. El lenguaje ensamblador, resultó de la evolución del lenguaje máquina, al
sustituir las cadenas de símbolos binarios por mnemotécnicos. Posteriormente
surgieron los lenguajes de alto nivel, cuya evolución es:
• 1955: FORTRAN.
• 1960: LISP, ALGOL, COBOL.
• 1965: APL, SNOBOL, PL/1, BASIC.
• 1970: PROLOG, ALGOL68, SIMULA67.
• 1975: C, PASCAL.
• 1980: MODULA-2, LIS, EUCLID.
• 1985: ADA.
Los lenguajes de programación pueden clasificarse de la siguiente manera:
Según su parecido con el lenguaje natural

• Bajo nivel: lenguajes máquina y ensambladores.
• Alto nivel: todos los demás.
Según la estructura de los programas

• Convencionales o línea a línea: ensambladores, FORTRAN, BASIC, COBOL,
etc.
• Estructurados: Algol, PL/I, Pascal, Ada, COBOL estructurado, etc.
Según la realización de los programas

• Funcionales: Lisp, Prolog, APL, etc.
• Imperativos: la mayoría.
Según el tipo de proceso

• Interactivos o conversacionales: BASIC, Pascal, APL, etc.
• Orientados al proceso por lotes (batch): COBOL, FORTRAN, PL/I, etc.
7
Lenguaje C
En este libro se usará como lenguaje para implementación, C estándar.
Historia y Características
Descripción
ORIGENES DEL LENGUAJE C
El lenguaje C fue inventado e implementado por primera vez por Dennis Ritchie, usando UNIX
como sistema operativo. Debido a que se busco unificar implementaciones del lenguaje, para la
compatibilidad el los compiladores del lenguaje; la descripción del lenguaje se realiza siguiendo las
normas del ANSI C, (Instituto de Estándares Americanos para C);. Para lo cual Turbo C se clasifica
como un compilador rápido y eficiente que proporciona muchas características en este entorno,
satisfaciendo así las necesidades de una amplia variedad de programadores.
UN LENGUAJE DE NIVEL MEDIO

El lenguaje de programación C está caracterizado por ser de uso general, con una sintaxis
sumamente compacta y de alta portabilidad.
C se clasifica como un lenguaje de “nivel medio” debido a que combina elementos de lenguajes de
alto nivel con la funcionalidad del lenguaje ensamblador.
Aunque C tiene cinco tipos de datos básicos incorporados, no se trata de un lenguaje fuertemente
tipificado, pues C permite casi cualquier conversión de tipos; además C no lleva a cabo
comprobaciones de errores en tiempo de ejecución. Es el programador el único responsable de
llevar a cabo esas comprobaciones.
Permite además la manipulación directa de bits, bytes, palabras, direcciones y punteros; lo que lo
hace particularmente adecuado para la programación. Sin olvidar que C tan solo utiliza 32 palabras
claves que constituyen las órdenes que conforman este lenguaje.
UN LENGUAJE ESTRUCTURADO
Lenguaje estructurado en bloques: permite declarar procedimientos o funciones dentro de otros
procedimientos o funciones. De esta forma se aplican los conceptos de “globalidad” y “localidad”
mediante el uso de reglas de alcance.
permite la compartimentalización de código y datos. Se trata de la capacidad de un lenguaje de

seccionar y esconder del resto del programa toda la información y las instrucciones necesarias
para llevar a cabo una determinada tarea. (Subrutinas: emplean variables locales “temporales”).
El componente estructural principal de C es la función - una subrutina independiente. En C las
funciones son los bloques constitutivos en los que se desarrolla toda la actividad de los programas.
Permite definir las tareas de un programa y codificarlas por separado, haciendo que los programas
sean modulares.
UN LENGUAJE PARA PROGRAMADORES

Gracias al orden de código que presenta C, portabilidad, eficiencia y estructuración, entre otros;
hicieron que el C creciera en popularidad frente a los programadores. Donde en principio se utilizo
para la programación de sistemas (Sistemas operativos, compiladores, editores, interpretes, etc.);
pero que más adelante gracias a todos sus características permitió a los programadores trabajar en
grandes proyectos, minimizando la duplicidad de sus esfuerzos.
BIBLIOTECA Y ENLACE
Biblioteca: archivo donde se encuentran las funciones estándar y se pueden usar en un programa.
Enlace: combina código escrito con el código objeto que ya se encuentra en la biblioteca.
8
4.3. Ejercicios Resueltos
Para el desarrollo de los ejemplos se diseño una plantilla (Figura 3) que permitirá
seguir cada uno de los elementos del diseño de algoritmos establecidos
anteriormente.
La formulación del Problema tiene tres campos: El código es una numeración

personal del programa que se esta elaborando, el Nombre es una cadena de
caracteres que define en pocas palabras el objetivo del programa, y el enunciado
es el problema a resolver.
La sección de Resolución del problema, plantea los campos de los cuales ya se

conoce su significado y fueron aclarados en los párrafos anteriores.
En los ejemplos que se presentarán en el transcurso del Libro dejaran partes de la

plantilla en blanco (en ocasiones no la usarán), con el fin de exponer lo que
importa en el tema o sección que se este tratando, cuando se entre en la fase de
programación pura se omitirán los pasos anteriores y se presentaran los
resultados de pseudocódigo o codificación directamente, para dar una mayor
efectividad en el objetivo de los ejemplos. Para los programadores que inician es
recomendable que elaboren todos los pasos de la plantilla, hasta que logren una
destreza suficiente que les permita pasar directamente al pseudocódigo, diagrama
de flujo o codificación en lenguaje C directamente.
Código: Nombre
Formulación del
Problema Enunciado
Etapas de Resolución del Problema

Descripción:
Datos de Entrada
Datos de Salida
Fase de Datos Auxiliares
Resolución Diseño y Verificación del Algoritmo
Formalización(Diagramas de Flujo, pseudocódigo)
Comprobación del Algoritmo (traza)
Codificación y programa Autodocumentado

Fase de
Implementación
Ejecución
Figura 3: Plantilla para la Solución de Problemas con Algoritmos
9
Es importante aclarar que aunque se logre una buena destreza en el
entendimiento de los problemas a resolver con programas, nunca debe olvidarse
realizar los pasos de diseño previo del algoritmo, esto le dará la efectividad y
eficacia deseadas en la solución obtenida.
A continuación se van a presentar tres ejemplos que muestran como se debe usar
la plantilla propuesta, y a su vez como se solucionan problemas de diversos tipos.
Por motivos de practicidad la autodocumentación del código fuente no se aplicará

de una forma estricta en todos los ejemplos, a medida que estos lo permitan se
presentarán de acuerdo a la formalización de documentación del Anexo A
Para el primer ejemplo se hará explícito el análisis del sistema (como se explicó en
4.2.2), estos elementos son los que se incorporan a la plantilla, posteriormente en
lo demás ejercicios se asume que el estudiante realiza el análisis previo y coloca
en la plantilla directamente los resultados del mismo.
4.3.1. Ejemplo 1: Lanzar dados hasta obtener par. A continuación se presentan

los pasos:
Formulación del problema

Realizar un algoritmo que permita establecer como lanzar un par de dados hasta
conseguir un par.
ENTRADAS PROCESOS SALIDAS

*Revolver los Dados; ¿Cuántas salidas hay?: 2
*Tirar los Dados; ¿Cuáles son salidas?: Valor Dado 1
¿Cuántos Datos?:2 *Verificar el valor del Dado 1
ó Valor Dado 2 .
¿Qué Datos?: Dado 1, Dado 2 y del Dado 2;
*Si valor Dado 1 = valor
¿Cuál es la Precisión de los
¿Cuáles son Válidos?: Dado de
Dado 2 son pares y salir, sino resultados?: números enteros entre 2
mal ubicado.
volver a iniciar; y6
Pares: 2 ,3,4,5 y 6
REALIMENTACIO
Probar el algoritmo si funciona
Figura1: Análisis del problema de lanzar dados hasta obtener par
Resolución del problema – análisis
10
Descripción
Las entradas básicas son los dos dados, estos deben cumplir las características
de no estar cargados y ser ambos similares, para que halla la misma probabilidad
de caer cualquier número. Si un dado queda mal ubicado es decir, cuando por la
superficie en que cae el dado no queda una de sus caras totalmente horizontal, se
debe volver a repetir el tiro porque no se puede decidir cual valor obtuvo.
Se debe tirar los dados una vez se hallan revuelto por algún medio, ya sea en las
manos o utilizando un vaso dónde se depositan y de baten para luego lanzarlos a
la superficie.
Posteriormente se deben revisar los valores de los dados y se verifica si son

iguales, es decir si el dado 1 es su valor es dos y el dado 2 su valor es dos
entonces se dice que son pares, lo mismo con tres, cuatro, cinco y seis.
Una restricción que se debe tener en cuenta es que los dados sus valores fluctúan
entre 2 y 6, cualquier otro valor es inválido.
Finalmente la salida es cualquiera de valores de los dados, porque el algoritmo

terminará cuando se cumpla la condición que los valores de los dados son
exactamente iguales.
Utilizando la plantilla adoptada para el análisis, diseño y codificación de los

algoritmos tenemos el Ejemplo 1, Ejemplo 2, Ejemplo 3 y el Ejemplo 4.
Como se puede observar en el Ejemplo 4, el diagrama de flujo denotaba tareas

generales, con respecto a la codificación en C hay que incluir otros pasos
adicionales para que funcione el programa, por esto se ve la necesidad de
entender los conceptos de datos (variables, constantes, estructuras),
estandarizar los diagramas de flujo , el pseudocódigo y hasta la forma de
escribir los programas en el lenguaje de programación elegido.
Por lo anterior es recomendado que un diagrama de flujo o pseudocódigo este

detallado lo más posible, dó nde se pueda obtener las variables y datos necesarios
para cumplir la tarea.
En el siguiente capítulo se presentarán conceptos básicos de estructura de datos,

se irá presentando ejemplos de cómo se realiza en lenguaje C, posteriormente se
definirán los estándares a utilizar para la creación de algoritmos y pseudocódigo.
Algunas instrucciones usadas en los ejemplos pueden no ser comprensibles al

principio, pero a medida que se avance en los temas los iremos documentando
debidamente.
Algunas partes de la plantilla en los ejemplos no se realizan por ser tópicos a

desarrollar en capítulos posteriores.
11
Código: 1 Nombre Tirar los dados hasta obtener par
Formulación del
Problema Enunciado
Realizar un algoritmo que permita establecer como lanzar un par de dados
hasta conseguir un par.
Fase de Análisis del Problema
Resolución Las entradas básicas son los dos dados. Se debe tirar
los dados una vez se hallan revuelto por algún medio.
Posteriormente se deben revisar los valores de los

dados y se verifica si son iguales, es decir si el dado 1
es su valor es dos y el dado 2 su valor es dos entonces
se dice que son pares, lo mismo con tres, cuatro, cinco
y seis.
Una restricción que se debe tener en cuenta es que los

dados sus valores fluctúan entre 2 y 6, cualquier otro
Descripción: valor es inválido.
Finalmente la salida es cualquiera de valores de los

dados, porque el algoritmo terminará cuando se
cumpla la condición que los valores de los dados son
exactamente iguales. Para poder simular el tiro de los
dados se debe utilizar la función random(), la cual
devuelve un valor entero aleatorio entre 0 y el número
que se le pase en el argumento. También se usa la
función randomizar(), la cual establece números
aleatorios diferentes cada vez que se ejecute el
programa.
Datos de Entrada Dado 1, Dado 2
Datos de Salida Valor Dado 1 ó Valor Dado 2 en caso de ser pares
Datos Auxiliares Par es cuando Valor Dado 1 = Valor del Dado 2
Diseño y Verificación del Algoritmo
//INICIANDO EL PROGRAMA
var
entero: Dado1, Dado2;
inicio
//Revolver los dados
randomizar();
repetir
Dado1=random(4) + 2;
Dado2=random(4) + 2;
hasta (Dado1= Dado2);
Escribir(“Los dados fueron pares en”, Dado1 )
fin
12
Prueba 1 Prueba 2
Paso Dado 1 Dado2 Paso Dado 1 Dado2
1-7 ? ? 1-7 ? ?
8 3 ? 8 4 ?
9 3 2 9 4 4
10 Falso; Devuelve a 6 10 Verdadero ; Continua en 11
11 Los dados fueron pares en 4.
12 Termina.
// ___________________________________________________________
// Nombre: Lanzar Dados
// Descripción: El programa simula el lanzamiento de dos dados
// si los valores de los dos son pares, entonces el
// algoritmo presenta en pantalla el valor de uno de
// los dados.
// Destino: Programa de Ingeniería de Sistemas
// Datos Responsable: Miguel Angel Niño Zambrano UNICAUCA - FIET.
// Excep. / Errores: Ninguno implementado.
// Limitaciones: No hace validación de datos de entrada.
// ___________________________________________________________
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
void main(void)
{
int intDado1, intDado2;
Fase de //Revolver los dados

Implementación randomize();
//Repetir hasta que los dados sean par

do
{
//Obtiene numeros aleatorios entre 0 y 6
intDado1=random(4)+2;
intDado2=random(4)+2;
//Verificar si son pares

}
while(intDado1!=intDado2);
printf("Los dados fueron par en %d",intDado1);
getch();
}
Ejecución 1:
Los dados fueron par en 4
Ejecución 2:
Ejecución
Ejecución 3:
Ejemplo 1: Tirar los dados hasta obtener par
13
4.3.2. Ejemplo 2: Conve rsión de temperaturas
Código: 2 Nombre Conversión de Temperaturas
Formulación del Enunciado
Problema Elaborar un Programa que lea grados Celsius y los convierte en grados
Kelvin.
Se Busca hacer una conversión de Celsius a Kelvin,
para esto debo:
Descripción: 1. Pedir el dato de grados Celsius.
2. Con la formula calcular los grados Kelvin
3. Finalmente retornar la respuesta (Kelvin).
Datos de Entrada Celsius
Datos de Salida Kelvin
Datos Auxiliares Fórmula: kelvin = Celsius + 273.15
Fase de Diseño y Verificación del Algoritmo
Resolución Formalización(Diagramas de Flujo, pseudocódigo)
//INICIANDO EL PROGRAMA
inicio
leer(Celsius)
kelvin = Celsius + 273.15
escribir(Kelvin)
fin
Celsius Kelvin
15 288.15
El programa imprime: 288.15
// ___________________________________________________________
// Nombre: Funciones
// Descripción: Conversión de Celsius a Kelvin
// Limitaciones: No hace validación de datos de entrada (negativos)
// ___________________________________________________________
Fase de #include <stdio.h>
Implementación viod main(void)
{
float floCelsius, floKelvin; //Variables que guardan el dato de los grados
scanf(“%f”, &floCelsius);
floKelvin = floCelsius + 273.15;
Printf(“Los %1.2f Celsius son equivalentes a %1.2f Kelvin”, floCelsius,
floKelvin);
}
15
Ejecución
Los 15.00 Celsius son equivalentes a 288.15 Kelvin
Ejemplo 2: Conversión de Temperaturas
14
4.3.3. Ejemplo 3: Ir al cine
Código: 3 Nombre Ir al Cine
Problema Desarrollar un algoritmo que especifique los pasos que se hacen cuan una
persona decide ir a ver una película de cine. La película la selecciona de un
periódico.
Para solucionar el problema, se debe seleccionar una
película de la cartelera del periódico, ir a la sala y
Descripción:
comprar la entrada para, finalmente, poder ver la
película.
Nombre de la Película, Dirección de la Sala y Hora de
Datos de Entrada
Proyección.
Datos de Salida Ver la Película.
Datos Auxiliares Entrada y Número de Asiento
inicio
//Seleccionar la Película
tomar el periódico
mientras no lleguemos a la cartelera
pasar la hoja
mientras no se acabe la cartelera
leer película
Fase de si nos gusta, recordar el título
Resolución elegir una de las películas seleccionadas
leer la dirección de la sala y la hora de proyección
//Comprar la Entrada
trasladarse a la sala
si no hay entradas, ir a fin
si hay cola
ponerse en el último
mientras no lleguemos a la taquilla
avanzar
si no hay entradas ir a fin
comprar la entrada
//Ver la película
leer el número de asiento de la entrada
buscar el asiento
sentarse
ver la película
fin
Funciona
Fase de Codificación y programa Autodocumentado
Implementación No hay que Hacerla.
Ejemplo 3: Ir al Cine
15
4.3.4. Ejemplo 4: Palíndromo
Código: 4 Nombre Palíndromo
Problema Averiguar si una palabra es un palíndromo. Nota: un palíndromo es una
palabra que se lee igual de izquierda a derecha que de derecha a izquierda.
Ej. radar
Para comprobar si una palabra es un palíndromo, se
puede ir formando una palabra con los caracteres
invertidos con respecto al original y comprobar si la
Descripción: palabra al revés es igual a la original. Para obtener esa
palabra al revés se leerán en sentido inverso los
caracteres de la palabra inicial y se irán juntando
sucesivamente hasta llegar al primer carácter.
Datos de Entrada palabra.
Datos de Salida un mensaje que no dice si es o no palíndromo.
Datos Auxiliares cada carácter de la palabra, palabra al revés.
INICIO
Leer palabra
Leer ultimo
carácter
Fase de
Resolución
Juntar el Carácter
a los anteriores
Leer carácter
anterior
¿Más caracteres?
¿Palabras
Iguales?
“No es Palíndromo” “Es Palíndromo”
FIN
16
No se hace.
// ___________________________________________________________
// Nombre: Funciones
// Descripción: Este programa recibe una cadena de 20 caracteres
// máximo y evalúa si la palabra es palíndroma o no:
// Ej. ala es palíndroma. Se lee igual de adelante
// hacia atrás y lo contrario.
// ___________________________________________________________
#include<stdio.h>
#include<conio.h>
#include<string.h>
void main(void)
{
char chaPalabra[20]; //Vector para almacenar la palabra digitada
char chaPalindroma[20]; //Vector para almacenar la palabra digitada
//al revés
int intLongitud; //Longitud de la palabra digitada
int intConti, intContj; //Contadores de bucles FOR.
Fase de
Implementación clrscr();
//leer la palabra a revisar
gets(chaPalabra);
longitud=strlen(chaPalabra);
//Obtener los caracteres al revés en otra cadena

for(intConti =longitud-1, intContj =0; intConti >=0; intConti --, intContj ++)
chaPalindroma [intContj]= chaPalabra [intConti];
//Comparar las cadenas

if(!strcmp(chaPalabra, chaPalindroma))
printf("Palíndroma");
else
printf("No Palíndroma");
getch();
}
Ejecución 1:
hola
No Palíndroma
Ejecución 2:
Ejecución ala
Palíndroma
Ejecución 3:
aaaaa
Palíndroma
Ejemplo 4: Palíndromo
17
4.4. Ejercicios Propuestos
4.4.1. Sección Teórica

1. Establezca en un cuadro sinóptico las etapas de análisis de la resolución de
problemas.
2. Liste y defina las características de un Algoritmo.
3. Describa en que consiste la comprobación de un Algoritmo.
4. Establezca los Tipos de Datos que se manejan en la implementación de algoritmos.
5. Elabore un Cuadro Sinóptico de los Tipos de Datos soportados por Turbo C.
6. Elabore un cuadro sinóptico de las formas de representar los datos en los lenguajes
de programación.
7. Ordene secuencialmente cada una de las reglas para definir identificadores.
4.4.2. Sección Práctica

1. Elabora r los algoritmos de los siguientes problemas, utilizando la estructura de
análisis recomendada en la teoría:
Problema Puntos a tener en Cuenta

a) Ir al baño. Solamente a bañarse.
b) Ir al fútbol. Al estadio, con Posible Cola, y buscar la silla
c ) Poner la mesa para la No. de Invitados, Colocar los Platos y Sillas
comida. correspondientes.
d) Hacer una taza de té
e) Limpiar platos. Platos, Pocillos, Cucharas y Ollas.
f) Hacer una Llamada Tiene el teléfono al frente.
Telefónica
g) Algoritmo que lea tres Los números son enteros.
números, y a continuación
escriba el mayor de los
tres.
Sugerencia: Antes de comenzar a elaborar el algoritmo identifique las entradas y las

salidas, elabore esquemas o gráficos propios que le permitan concebir el problema y
luego siga los paso para la solución de algoritmos.
18
INTRODUCCIÓN A LAS ESTRUCTURAS DE DATOS
Introducción:
Este capitulo presenta la forma como se almacena y se representan los datos que
manipulan en los programas. Las estructuras de datos manejadas en este
documento son los estáticos, puesto que son los tipos de datos en los que se
fundamentan los demás tipos de datos
El capitulo presenta de manera resumida las funcionalidades de manipulación de

datos en C, así como las funciones y operaciones que se aplican sobre e stos.
En el transcurso del capitulo se presentan ejemplos prácticos que muestran el uso

de las estructuras de datos en los programas.
19
4.5. CONCEPTOS BÁSICOS DE ESTRUCTURAS DE DATOS
4.5.1. Tipos de datos. Un dato es toda información que utiliza el ordenador.

Según sea la información que guardemos en los datos, los clasificaremos como se
muestra en la Figura 4.
Los datos estáticos son datos que se crean y definen en tiempo de diseño,
poseen una cantidad de memoria fija durante todo el programa, y no puede ser
agrandada o achicada en tiempo de ejecución.
Los datos dinámicos son los que se crean y se definen en tiempo de ejecución. A
su ve z los datos los podemos clasificar con respecto a su complejidad, en datos
simples y estructurados.
Los datos predefinidos son los que se encuentran como datos base de todos los
lenguajes de programación, a partir de ellos se pueden crear los demás tipos de
datos, con algunas operaciones especiales.
Los datos predefinidos por el usuario son los datos que define el mismo usuario
del lenguaje de programación, a partir de la combinación estructurada de los datos
predefinidos por el sistema.
En el transcurso de este documento se irán definiendo y desarrollando cada uno

de los datos que se presentan en la Figura 4.
4.5.2. Clasificación de los Datos. Los datos los podemos clasificar como se
muestra en la Figura 4. La clasificación más genérica que se le pueden dar los
datos en un principio son las siguientes:
NUMERICOS
Almacenan números y con ellos podremos realizar operaciones aritméticas. A su
vez pueden ser:
Enteros
Es un subconjunto finito de los números enteros, están definidos en un rango. Son
todos los números positivos o negativos.
Ejemplo: 734, -123, 0, -1
Reales
Es un subconjunto de los números reales, se encuentran limitados por el tamaño y
20
la precisión. Son todos los números decimales.
Ejemplo: -0.123, 67.8, 32.02
Enteros
Numéricos Reales
Predefinidos
Simples Alfanuméricos Carácter
Booléanos (lógicos)
Estáticos Predefinidos Subrango

por el usuario Enumerado
Tipos de
Datos
Array (vector, matriz, poliedro)
Registro
Estructurados Archivo (dinámico)
Conjunto
Cadena
Lista (pila, cola)

lista enlazada
Dinámicos Arbol
Grafo
Figura 4: Tipos de Datos
ALFANUMERICOS
Almacena caracteres alfanuméricos. Pueden ser:
Letras
Desde la A hasta la Z.
Caracteres especiales
Guiones, paréntesis, signos de puntuación, etc.
Números
Con ellos no se pueden realizar operaciones aritméticas.
BOOLEANOS
Sólo pueden tener dos valores: verdad o falso. Estos datos no pueden leerse
como datos, pero pueden imprimirse. Se forman a partir de los operadores
relacionales y lógicos.
21
4.5.3. Tipos de Datos en C
Tipos de Datos Simples

Descripción Existen cinco tipos de datos atómicos en C: carácter, entero, coma flotante,
coma flotante de doble precisión y sin valor. Los valores de tipo char se usan
normalmente para guardar valores definidos en el juego de caracteres ASCII, así
como cualquier cantidad de 8 bits. Las variables de tipo int se usan para guardar
cantidades enteras. Las variables de tipo float o double se usan para guardar
números reales. El tipo void se usa para: primero declarar explícitamente una
función como que no devuelve valor alguno; segundo para declarar
explícitamente una función sin parámetros; tercero para crear punteros
genéricos.
Clasificación Definición y Ejemplos:
Entero y Booléanos Definición:
Int <variable>
Ejemplos:
Int gintContador;
Int gintVar, intConti , intContj;
int true=1;
int false=0;
Reales Definición:
float <variable>
Ejemplos:
float gfloContador;
float gfloVar, gfloConti , gfloContj;
Alfanuméricos Definición:
(carácter) char <variable>
Ejemplos:
char gchaContador;
char gchaVar, gchaConti , gchaContj;
Tamaño y TIPO TAMAÑO EN BITS RANGO Los calificadores de tipo,
Calificadores Char
Int
8
16
0 a 255
-32768 a 32767
modifican el rango de
variables de un tipo de
de tipo Float 32 3.4E-38 a 3.4E+38 dato:
Double 64 1.7E-308 a 1.7E+308 unsigned (sin signo).
Void 0 sin valor signed (con signo)
short (corto)
Unsigned char 8 0 a 255
long (largo)
Signed char 8 -128 a 127
Se aplican a cualquier
long int 32 -2.147.483,648 a 2.147.483,648 tipo de datos.
Ejemplos:
Por defecto se C usa
long a; //define una variable a del rango long int
short y signed.
unsigned int //define una variable a de rango positivo int.
long float //define una variable reales 10 bytes.
22
4.5.4. Operadores. Todos los símbolos que representan enlaces entre cada uno
de los argumentos que intervienen en una operación se llaman operadores, y se
utilizan para construir expresiones. Los operadores pueden ser:
RELACIONALES O CONDICIONALES
Se utilizan para formar expresiones booleanas, es decir, expresiones que al ser
evaluadas producen un valor lógico: verdad o falso.
• < Menor que

• = Igual
• > Mayor que
• <= Menor o igual que
• >= Mayor o igual que
• <> Distinto de
Cuando se comparan caracteres alfanuméricos, se hace uno a uno, de izquierda a

derecha. Si las variables son de diferente longitud, pero exactamente iguales
hasta el último carácter del más corto, entonces se considera que el más corto es
el menor. Sólo son iguales dos datos alfanuméricos si son iguales su longitud y
sus componentes. Las letras minúsculas tienen mayor valor que las mayúsculas.
ARITMETICOS
Para tratar los números se utilizan los operadores aritméticos, que junto con las
variables numéricas forman expresiones aritméticas.
• + Suma
• - Resta
• * Multiplicación
• ^ Potenciación
• / División real
• DIV División entera
• MOD Resto de la división entera
Los operadores DIV y MOD son los de menor prioridad.
ALFANUMERICOS
Se utiliza para unir datos alfanuméricos.
• + Concatenación
La concatenación es unir expresiones alfanuméricas como si fueran eslabones de

una cadena.
23
LOGICOS O BOOLEANOS
Combinan sus operandos de acuerdo con las reglas del Álgebra de Boole con el
fin de producir un nuevo valor que se convierta en el valor de la expresión.
• OR Suma lógica
• AND Producto lógico
• NOT Negación
OR u O
Es un operador binario, es decir, afecta a dos operadores. La expresión que
forma es cierta cuando al menos uno de sus operandos es cierto. Es el operador
lógico de disyunción.
Ejemplo: estudiamos informática o nos vamos al cine.
AND o Y
Es un operador binario. La expresión formada es cierta cuando ambos operandos
son ciertos al mismo tiempo. Es el operador lógico de conjunción.
Ejemplo: es de día y hace sol.
NOT o NO
Es un operador unario, es decir, sólo afecta a un operando. Afecta a la expresión
cambiando su estado lógico: si era verdad lo transforma en falso, y viceversa.
PARENTESIS
Los paréntesis se utilizan para anidar expresiones.
• ( ) Anidar expresiones
ORDEN DE EVALUACION
La prioridad a la hora de evaluar los operadores en cualquier expresión es:
• Paréntesis (empezando por los más internos)

• Potencias
• Productos y divisiones
• Sumas y restas
• Concatenación
• Relaciónales
• Lógicos
24
4.5.5. Operadores en Lenguaje C
Operadores
Descripción Un operador es un símbolo que indica al compilador que lleve a cabo ciertas
manipulaciones matemáticas o lógicas. En C hay tres clases de operadores:
aritméticos, relacionales, lógicos y a nivel de bits.
Clasificación
Operadores aritméticos. Operadores lógicos

OPERADORES ACCION OPERADOR ACCION
- Resta, tambien && Y
menos monario || O
+ Suma ! NO
* Multiplicación
/ División Operadores a nivel de bits
% División en módulo Las operaciones a nivel de bits se refieren a la
-- Decremento comprobación, asignación o desplazamiento de
+ Incremento los bits reales que componen un byte o una
palabra, que corresponden a los tipos estándar
de C char e int con sus variantes.
Incremento y decremento:
El operador ++ añade uno a su operando y el OPERADOR ACCION
operador - - le resta uno. Por lo tanto, las & Y
siguientes operaciones son equivalentes: | O
^ O exclusiva
x= x+1; es lo mismo que ++x; también ~ Complemento a uno
x= x-1; es lo mismo que - -x; >> Desplazamiento a la derecha
<< Desplazamiento a la izquierda
Pero: x = 10;
y = ++x; Los operadores a nivel de bits Y, O , O exclusiva
en este caso pone a y = 11. Sin embargo si se aplican sus operaciones directamente a cada bit
escribe el código como: individual de la variable. Recuerde los
x = 10; operadores relacionales y lógicos siempre
y = x++; producen un resultado cero o uno, mientras que
y toma el valor de l0 y en ambos casos x queda las operaciones a nivel de bits producen
como 11 cualquier valor arbitrario de acuerdo a la
operación específica. Ejemplo:
Operadores relacionales y lógicos:
Nos muestra una relación de unos valores con 10000000 128 en binario
otros, que por medio de la lógica nos dan un 00000011 3 en binario
resultado falso o verdadero. Cierto es cualquier ------------------ O a nivel de bits
valor distinto de cero y falso es cero. Estos 10000011
operadores tienen menos precedencia que los
aritméticos. Los operadores de desplazamiento >> y <<
mueven los bits de una variable a derecha o la
Operadores relacionales izquierda, los espacios se llenan con ceros.
OPERADOR ACCION Cuando se corre a la derecha se divide entre dos
> Mayor y cuando se corre a la izquierda se multiplica por
>= Mayor o igual dos. El complemento a uno cambia los bits de
< Menor uno a cero y de cero a uno. Esto se utiliza para
<= Menor o igual codificar o restringir la lectura de un archivo.
== Igual
!= No igual
25
Clasificación
El operador ?: Ejemplo:
Se utiliza para sustituir ciertas sentencias de la Sea la variable cont = 100 con una posición de
forma if, then, else. El operador ternario? memoria = 2000
m = &cont coloca a m en la posición de
Exp1 ? Exp2: Exp3; memoria de cont, o sea que m = 2000
donde exp1, exp2 y exp3 representan
expresiones. q=*m coloca a q con el valor de cont , o
sea q = 100
Evalúa Exp1. Si es cierta, evalúa Exp2 y toma
ese valor para la expresión. Si Exp1 es falsa, Operador de tiempo de compilación sizeof:
evalúa Exp3 tomando su valor para la Es un operador monario que devuelve la longitud
expresión. en bytes, de la variable o del especificador de
Ejemplo: tipo entre paréntesis al que precede, sizeof
x = 10; ayuda a generar código portable que dependa
y = x>9 ? 100 : 200; del tamaño de los tipos de datos incorporado en
Este mismo código escrito con la sentencia if / C. Por ejemplo, imagine un programa de base
else sería: de datos que necesite guardar 6 valores enteros
x = 10; por registro. Si se quiere transportar el programa
if ( x>9) y = 100; de base de datos a una gran variedad de
else y = 200; computadoras, no se debe asumir que un entero
ocupe dos bytes; se debe determinar la longitud
Los operadores de puntero & y *: real de los enteros usando sizeof.
El puntero es la dirección de memoria de una
variable, una variable de puntero es una La coma como operador:
variable específicamente declarada. Los En cadena varias expresiones “y” produce una
punteros tienen dos funciones principales: secuencia de operaciones, por ejemplo:
referencian en forma rápida los elementos de un x = ( y = 3 , y + 1 );
array y modifican los parámetros de llamadas de primero asigna el valor 3 a y y luego el valor 4 a
las funciones. x
Los operadores para manejar punteros son: [ ] y ( )

& su función es dar la dirección de memoria del En C, los paréntesis son operadores que
operando. aumentan la precedencia de las operaciones que
contienen.
* su función es dar el valor de la variable
ubicada en la dirección que nos da &. Los corchetes sirven para indexación de arrays.
4.5.6. Representación de los datos, constantes, variables y tipos definidos. Los

datos se pueden representar en el computador utilizando:
ü Constantes
ü Variables
ü Expresiones
ü Funciones
CONSTANTES
Se llama constante a toda posición de memoria, referenciada por un nombre de
constante, donde se almacena un valor que no puede cambiarse o permanece
invariable a lo largo del proceso. Las constantes pueden ser:
26
Constantes Numéricas Enteras
Números con valor entero, ya sea positivo o negativo.
Ejemplo: an_recto = 90
Constantes Numéricas Reales

Números con punto decimal.
Ejemplo: pi = 3.14159
Constantes Lógicas
Contienen uno de dos posibles valores:
Ejemplo: Salir = true.
Constantes De caracteres o alfanuméricas

Contienen una serie de caracteres tales como letras mayúsculas, minúsculas,
dígitos, signos de puntuación y otros símbolos especiales.
Ejemplo: ciudad = "29400 - Ronda"
VARIABLES
Se considera variable a una zona de memoria referencia por un nombre de
variable, donde se puede almacenar el valor de un dato, que puede cambiarse
cuando lo deseemos. El nombre de la variable es elegido por el usuario. Para
que estén perfectamente definidas las variables, hay que especificar:
• Su nombre.
• El tipo de dato: numérico, alfanumérico o booleano.
• El valor que va a tomar en un principio: inicialización.
El nombre sólo debe tener preferiblemente una longitud máxima de ocho

caracteres, empezando obligatoriamente por una letra y sin contener espacios en
blanco, pero pueden contener dígitos y algunos caracteres especiales como el
subrayado. Las palabras reservadas 2 no se pueden utilizar para nombrar a las
variables. Según los tipos de datos que almacenan, las variables pueden ser:
Variables Numéricas
Se escriben:
• nombre -variable = numero
2
Una palabra reservada es una palabra que utiliza el mismo lenguaje en el que se esta codificando
el programa, y es de uso exclusivo del mismo para poder interpretara las instrucciones
adecuadamente. Ej. Printf en lenguaje c.
27
Ejemplo: contador = 35
Variables Alfanuméricas
Se escriben de dos formas:
• nombre -variable = "comentario"
• nombre -variable = espacios( numero )
Ejemplo: nombre = "Domingo" o apellido = espacios( 30 )
Variables Booleanas
Se escriben:
• nombre -variable = Valor-Booleano
Ejemplo: fin = FALSO
La asignación (=), introduce en una variable un valor o el contenido de otra

variable. Tanto estos valores como la variable a la que se asigna deben ser del
mismo tipo. Se escriben:
• nombre -variable = valor-inicial
• nombre -variable-1 = nombre-variable-2
Ejemplo: ape = "Rodríguez" ; apellido = ape
EXPRESIONES
Es una combinación de Operadores y operandos. Los operandos son constantes,
variables o expresiones. Los operadores son de diferentes tipos: cadena,
aritméticos y lógicos como se vio anteriormente, según sus resultados se clasifican
en numéricas, alfanuméricas y booleanas.
Ejemplo: x = 10; y = x * x + 2
Expresiones
Descripción Los operadores, las constantes y las variables son la expresiones y es una
combinación válida de estos elementos.
Conversiones de tipos en las expresiones:
Se utilizan cuando en una expresión se mezclan constantes y variables de distintos tipos, se
convierten todos los operandos al tipo de mayor operando. Por ejemplo, short int lo convierte en
int.
Moldes:
Se puede forzar a que una expresión sea de un tipo determinado utilizando una construcción
denominada molde. A menudo los moldes son considerados como operadores. Como operador es
monario y tiene la tiene la misma precedencia que cualquier otro operador monario. Por ejemplo: Si
se quiere asegurar que la expresión x/2 se evalúe como tipo float, se puede escribir (float) x/2.
28
Espaciado y paréntesis:
Para dar mayor legibilidad se pueden añadir tabulaciones y espaciados. Ejemplo:
x=y/3-34*temp&127;
x = (y/3) - (34 * (temp & 127) );
el uso de espacios y paréntesis no reduce la velocidad del programa y conviene usarlos para hacer
más clara la lectura de los mismos.
Abreviaturas en C:
Las abreviaturas simplifican la escritura de ciertos tipos de sentencias de asignación. Ejemplo:
x = x+10 abreviado queda x+ = 10
El operador + = asigna a x el valor de x +10.
Así x = x - 100 abreviado queda x - = 100
FUNCIONES
Son predefinidas por el lenguaje de programación escogido para la
implementación de los algoritmos, de les envían parámetros y retornan valores.
Cuadro 1: Algunas Funciones predefinidas en los lenguajes

Función Descripción Argumento Resultado Ejemplo
abs(x) valor absoluto de x entero o real igual que argumento abs(-15) = 15
arctan(x) arco tangente de x entero o real real arctan(0.5) = 114,58
cos(x) coseno de x entero o real real cos(0.5) = 1
exp(x) exponencial de x entero o real real exp(5) = 5e,0
ln(x) logaritmo neperiano de x entero o real real ln(0.5) = -0.693
log10(x) logaritmo decimal de x entero o real real log10(0.5) = -0.301
redondeo(x) redondeo de x real entero redondeo(6.6) = 7
sen(x) seno de x entero o real real sen(0.5) = 0
cuadrado(x) cuadrado de x entero o real igual que el argumento cuadrado(5) = 25
raiz2(x) raiz cuadrada de x entero o real real raiz2(25) = 5
trunc(x) truncamiento de x real entero trunc(3.7) = 3
Random(x) Devuelve un numero entero real A=random(5)
aleatorio entre 0 y x
TIPOS PREDEFINIDOS
Tipos predefinidos del lenguaje
Una de las ventajas fundamentales de los lenguajes de alto nivel es la posibilidad
que ofrecen al programador de definir sus propios tipos de datos. Mediante la
definición de tipos de datos se consigue que cada información que maneja el
computador tenga su sentido específico. El tipo establece los posibles valores que
puede tomar ese dato. Supone crear un nuevo nivel de abstracción dentro del
programa. Los tipos predefinidos más utilizados son:
• BOOLEAN: tipo lógico

• CHAR: tipo carácter
• FALSE: valor lógico falso
• INTEGER: tipo entero normal
29
• NIL: valor nulo
• REAL: tipo decimal normal
• TRUE: valor lógico verdadero
Ejemplo: TipoEdad = INTEGER (tipo definido) ; edad : TipoEdad (variable
declarada)
Tipos enumerado
Una manera sencilla de definir un nuevo tipo de dato es enumerar todos los
posibles valores que puede tomar. Se realiza mediante una lista con los valores
separados por comas y encerrados entre paréntesis. Cada posible valor se
describe mediante un identificador, y éstos a su vez quedan declarados como
valores constantes. El primer elemento de la lista ocupa la posición 0 y el último
N-1, siendo N el número de elementos enumerados, formando parte los tipos
ordinales.
• Tipo = ( elem1, elem2, ... , elemN )
Ejemplo: TipoDia = ( lunes, martes, miércoles, jueves, viernes, sábado, domingo )
Tipos Subrango
Un tipo Subrango se define a partir de otro tipo ordinal3 ya definido, que se toma
como tipo base. La forma de realizar esto es declarar un identificador diferente
para el nuevo tipo y establecer los límites mínimo (primero) y máximo (último) del
Subrango de variación. Estos límites se escriben separados por dos puntos
seguidos y se encierran entre corchetes.
• Tipo = [ primero .. último ]
Ejemplo: DiaMes = [ 1 .. 31 ]
Tipos conjunto
La definición de un tipo conjunto se realiza tomando como base o conjunto
referencial el conjunto de todos los valores posibles de un tipo ordinal definido
previamente. Por analogía con el vocabulario de conjuntos, llamaremos tipo
referencial a este tipo base. Una forma de expresar un conjunto es indicar
claramente cuáles son sus elementos. Esto se hace mediante un expresión en la
que se enumeran encerrados entre llaves los elementos a incluir y separados por
comas, y precedidos por el identificador del tipo referencial.
• Tipo = TipoReferencial{ elem1, elem2, ... , elemN }
Ejemplo: dígito = RangoDigitos{ 0,1,2,3,4,5,6,7,8,9 }

3
Un tipo ordinal es un tipo de datos que posee un sucesor y un predecesor en la lista de posibles
valores a tomar. Ej. Entero 15 entonces: sucesor = 16, predecesor = 14. El real 14.56 no es
posible por la propiedad infinita que poseen.
30
REGLAS PARA LA CONTRUCCION DE IDENTIFICADORES
Es este punto hemos definido los diferentes tipos de datos que se pueden usar
para codificar la información, y la manera como se codifica en un lenguaje de
computadora. Todos los datos y estructuras de los algoritmos y programas se
manejan y manipulan mediante identificadores, es decir mediante asignaciones de
nombres, los cuales posteriormente son referenciados en distintas partes del
algoritmo o programa.
Concepto de identificador
Nombres que se le dan a las constantes simbólicas, variables, funciones y
procedimientos u otros objetos que manipulan el algoritmo.
Reglas de construcción
1. Ser significativo: El nombre debe sugerir los datos que representan o
manipulan.
2. No usar palabras reservadas: Hay un conjunto de identificadores que
pertenecen al lenguaje de programación en el cual se programa, debe evitarse
tomar estos mismos nombre puesto que entraría en conflictos de
interpretación.
3. Máximo de caracteres: Depende del lenguaje de programación en Pascal es
de 63, en C es de aproximadamente 32.
4. Comenzar por carácter alfabético o el subrayado: Los siguientes pueden
ser letras símbolos o el mismo subrayado.
5. Uso en el programa: Depende del lenguaje: en Pascal y Basic se puede usar
indistintamente en mayúsculas o minúsculas, por el contrario C exige que se
use exactamente como se definió.
Ejemplos:
Son identificadores válidos: Son identificadores no validos:

ü Xrayo • 45X
ü R2D2 • 34
ü ZZZZ • #XRayo
ü X_Rayo
ü X
ü N!4
31
1. Elabore un cuadro que relacione los tipos de datos con las constantes y las
variables, mediante un ejemplo.
Constantes Variables
36
450.35 A
Numéricos
0.58 Nom
'A' Edad
'Juan' Ciudad
Cadena
'La Paz' Estatura
Falso
Lógicos Verdadero
2. Resuelva las siguientes operaciones:
a. 7+3 = 10 e. 7*3 = 21
b. 10 Div 4 = 2 f. 5 Mod 7 = 5
c. 7- 3 = 4 g. 10/4= 2.5
d. 20 Mod 3 = 2 h. 4 ^ 2 = 16
3. Resuelva las siguientes operaciones
Expresión Resultado Expresión Resultado
10.5/3.0 3.5 10 Div 3 3
1/4 0.25 18 Div 2 9
2.0/4.0 0.5 30 Div 30 1
30/30 1.0 10 Mod 3 1
32
6/8 0.75 10 Mod 2 0
4. Resuelva las siguientes expresiones:

a. Si A=4 y B=3, entonces:
• A>B Es Verdadero
• (A-2) < (B- 4) Es Falso
b. Responda verdadero o falso según sea el caso

• ‘A’ < ‘K’ Es Ve rdadero
• ‘A’ > ‘a’ Es Falso
• ‘MARIA’ < ‘JUAN’ Es Falso (se considera la primera letra)
• ‘JAIME’ > ‘JORGE’ Es Falso (se considera la segunda letra)
5. Obtener los resultados de las siguientes expresiones:

• -4 *7 + 2 ^ ¾
Resulta:
-4 * 7+ 8/4 -5
-28 + 8/4 -5
-28 + 2 - 5
-26 - 5
-31
• A * (B+3)
La constante 3 se suma primero al valor de B, después este resultado
se multiplica por el valor de A.
• (A*B) +3
Se multiplican primero y a continuación se suma 3.
• A + (B/C) + D
Esta expres ión equivale a A+ B/C + D
• Not 4 > 6
Produce un error, ya que el operador Not se aplica a 4.
• Not (4 > 14)

Produce un valor verdadero.
• (1.0<x) And (x<z +7.0)

Si x vale 7 y z vale 4, se obtiene un valor falso.
33
4.7.1. Sección Teórica

1. Establezca en un cuadro sinóptico los tipos de datos que se manejan en la mayoría
de los lenguajes de programación.
2. Presente dos ejemplos de cada uno de los principales tipos de datos (Numéricos,
Alfanuméricos, Boléanos y Lógicos).
3. Presente dos ejemplos del usos de los operadores en las siguientes clases
(Relaciónales o condicionales, Aritméticos, Alfanuméricos y Lógicos).
4. Establezca el orden de evaluación de los operadores que utiliza el lenguaje C.
5. Establezca cual es la diferencia entre las constantes, las variables y las
expresiones.
4.7.2. Sección Práctica

1. Transforme las siguientes expresiones matemáticas a la notación algorítmica:
a2 + b−c
a. x=
2* a
b. a = ( a + b) 2 + c * (c − b) 3
( 2 +c )*b
(c − d ) +5
c. b =
(a − d ) b
3
2. Obtener los resultados de las siguientes expresiones:

• -14 Mod 7 + 2 ^ ¾
• A * (B+3) / (C+4)
• (A*B) +3 (A DIV B )
• A + (B/C) + A^ ¾
• (1.0<x) And (x<z +7.0)

Si x vale 7 y z vale 10, se obtiene un valor ?.
34
HERRAMIENTAS DE PROGRAMACIÓN
Introducción:
Las herramientas de programación de las que dispone un programador son

básicamente dos: pseudocodificación y diagramas de flujo. Ambas
metodologías plantean una serie ordenada de pasos con un formato establecido y
definido, que permiten formalizar los problemas a solucionar algorítmicamente en
programas listos para su implementación en un lenguaje de programación
cualquiera.
En este sentido el capitulo propone dos plantillas específicas y bien formalizadas,

que se usaron en los cursos de Introducción a la Informática del Programa de
Ingenierías de Sistemas de la Universidad del Cauca: Plantilla de Diagramas de
Flujo, Plantilla de Pseudocódigo. Estas plantillas serán los lineamientos a seguir
para la implementación de los algoritmos.
Un apartado interesante en el capitulo 7 es la comparación lineal que se establece

entre los diagramas de flujo, el pseudocódigo y el lenguaje C.
Este capítulo presentará ejercicios básicos de programación, auque se presentan

las principales estructuras tanto en diagrama de flujo como pseudocódigo y
lenguaje C, sólo en el capitulo 7 se presentarán los ejemplos más avanzados.
35
4.8. HERRAMIENTAS DE PROGRAMACIÓN
En los capítulos anteriores se definieron conceptos básicos sobre los algoritmos,

como la secuencia para su desarrollo, los tipos de datos que se pueden manejar, y
algunas funciones predefinidas en los lenguajes de programación. En este
capitulo se trabajará con las herramientas que poseemos para diseñar e
implementar los algoritmos. Para esto se presentarán a continuación los
estándares por los que se codificaran los algoritmos en este libro:
4.8.1. Tipos de Herramientas de programación. Se poseen tres:

ü Diagramas de flujo (Simple o de Nassi – Schneiderman)
ü pseudocódigo
ü Codificación en el Lenguaje de programación (Lenguaje C)
DIAGRAMA DE FLUJO
Se utilizan para la representación gráfica de las operaciones ejecutadas sobre los
datos a través de todas las partes de un sistema de procesamiento de
información, diagrama de flujo del sistema , como para la representación de la
secuencia de pasos necesarios para describir un procedimiento particular,
diagrama de flujo de detalle.
Estos diagramas permiten independizar la solución del problema del lenguaje de

programación que se utilice. La convención utilizada se presenta en la figura.
El diagrama de flujo seleccionado es el de detalle. El diagrama de flujo Nassi –

Schneiderman permite la reunión de elementos para la programación estructurada
con características gráficas propias de diagramas de flujo y lingüísticas propias de
los pseudocódigos. Constan de una serie de cajas contiguas que se leerán
siempre de arriba hacía abajo y se documentarán de la forma adecuada.
Por cuestiones prácticas se no utilizará el diagrama N–S, sino el simple. Para una
referencia detallada del mismo se puede referir al libro de Fundamentos de
programación primera edición[5].
A continuación en la Figura 6 se establece los estándares a seguir para la

elaboración de los diagramas de flujo de los problemas.
36
Símbolos Principales
Inicio / fin Escritura Indicador de
Var = Valor Asignación Var
Dirección
Llamada a Lectura Conector Línea

Var
Subrutina Conectora
-- Anterior
Programación Estructurada
-- Anterior -- -- Anterior --
Condición
Si No Si
Condición Condición
No (LV1) (LV2) (LV3)

--------------- --------------- ---------------
-------- -------- --------
-- Siguiente -- -- Siguiente -- -- Siguiente
Decisión Simple Decisión Doble Según sea
-- Anterior --
No Var = VI, VF
Condición ---------------
Si ---------------
---------------
---------------
---------------
No
--------------- Condición
Si
-- Siguiente
-- Siguiente -- -- Siguiente --
Mientras Repetir Desde
Figura 5: Estandarización de los Diagramas de Flujo

Símbolos Principales
Inicio / fin Escritura Indicador de
Var = Valor Asignación Var
Dirección
Llamada a Lectura Conector Línea

Var Conectora
Subrutina
- - Anterior - -
Programación Estructurada
-- Anterior -- - - Anterior - -
Condición
Si No Si
Condición Condición
No (LV1) (LV2) (LV3) (LV4) Otros

--------------- --------------- ---------------
-------- -------- -------- -------- --------
-- Siguiente - - -- Siguiente -- -- Siguiente --
Decisión Simple Decisión Doble Según sea
-- Anterior --
No Var = VI, VF Inc

Condición ---------------
Si ---------------
---------------
---------------
---------------
No
--------------- Condición
Si
-- Siguiente - -
- - Siguiente -- - - Siguiente --
Mientras Repetir Desde
Figura 6: Estandarización de los Diagramas de Flujo
38
Existen unos símbolos que se explicarán en detalle en el módulo de programación
estructurada más adelante. Un Ejemplo sencillo usando estos estándares lo tenemos a
continuación:
Código: 5 Nombre Hallar el área de un triángulo

Problema Diseñar un algoritmo que halle el área de un triángulo dados su base y
altura.
Datos de Entrada base, altura
Datos de Salida área
Datos Auxiliares fórmula de área del triángulo: area=base*altura/2
ü Pedimos el área y la altura
Descripción: ü aplicamos la fórmula
ü presentamos el resultado
inicio
base, altura
Fase de
Resolución
área =
base*altura/2
área
Fin

base altura área
4.5 7.2 16.2
Fase de
Implementación No se presenta
Ejecución sin ejecución.
Ejemplo 5: Hallar el Área de un Triángulo
39
Código: 6 Nombre Calculo del mayor de tres números
F.P. Enunciado
Elaborar un programa que pida tres números enteros y calcule cual de ellos es el mayor.
Datos de Entrada Numero 1, Numero 2, Numero 3
Datos de Salida El mayor
Datos Auxiliares No hay
ü Pedimos cada uno de los números
ü Se comparan sucesivamente cada uno de los números
Descripción: entre si hasta encontrar el mayor.
ü presentamos el resultado del mayor.
INICIO
Num1, Num2, Num3
NO Num1 > SI
Num2
NO Num2 > SI NO Num1 > SI

Num3 Num3
F.R.
Mayor = Num3 Mayor = Num2 Mayor = Num3 Mayor = Num1
Mayor
FIN

Traza 1
Num1 Num2 Num3 Mayor
4 7 16 ? Num1 > Num2; Num2 > Num3
4 7 16 16
Traza 2
10 6 11 ? Num1 > Num2; Num1 > Num3
10 6 11 11
Traza 3
2 8 5 ? Num1 > Num2; Num2 > Num3
2 8 5 8
F.I. No se presenta
Ejemplo 6: Calcular el mayor de tres números
40
Código: 7 Nombre Imprimir un menú de opciones
F.P. Enunciado
Diseñar un programa que permita imprimir un menú de cuatro opciones. En cada opción
seleccionada debe presentar un mensaje indicando cual fue la opción seleccionada.
Datos de Entrada La opción seleccionada (1..4)
Datos de Salida Un mensaje con la opción seleccionada.
ü Desplegamos el menú en la pantalla
ü Esperamos a que el usuario digite una de las
Descripción: opciones.
ü Desplegamos un mensaje con la opción
seleccionada.
INICIO
1. Opción Uno
2. Opción dos
3. Opción tres
4. Salir
F.R. Opciòn
Opción =
(1) (2) (3) (4) Otros

Escogió 1 Escogió 2 Escogió 3 Escogió 4 Incorrecta
NO Opción = 4
SI
FIN

No hay variables a excepción de opción, la cual sigue presentando el menú hasta que su valor se 4.
41
F.I. No se presenta
Ejemplo 7: Imprimir un menú de opciones
n
Código: 8 Nombre Potencia de x
F.P. Enunciado
Elaborar un diagrama de flujo que calcule la potencia n de x, siendo x y n números enteros.
Datos de Entrada X, n
n
Datos de Salida Valor de la potencia x
ü Pedimos cada uno de los números
ü Se multiplica el valor de X n veces por si misma, se
suma cada una de las multiplicaciones.
Descripción: ü presentamos el resultado de la potencia. Por razones de
demostración se prendarán tres formas diferentes de
elaborar el ejercicio, siendo el más apropiado la primera.
INICIO INICIO INICIO
F.R. X, n X, n X, n
NO
Cont = 1, n+1 Inc 1 n>0 Pot = Pot + X * X
SI
Pot = Pot + X * X n=n- 1
Pot = Pot + X * X
n = n -1
NO
n=0
Pot SI
Pot
Pot
FIN
FIN FIN
No se hace, Se Supone que los números digitados son positivos y enteros. Se supone que al inicio Pot = 0
F.I. No se presenta
n
Ejemplo 8: Calculo de la Potencia x
42
PSEUDOCODIGO
Es un lenguaje de Especificación de algoritmos, que utiliza palabras reservadas, y
exige la identación, ósea la sangría en el margen izquierdo de algunas líneas. A
continuación se presenta la plantilla de estandarización del pseudocódigo utilizado
en este libro.
Conjunto de Palabras Reservadas y Estructuras de Pseudocódigo

1. Primero el nombre del algoritmo se coloca después de la palabra Algoritmo.
2. Después se declaran las variables globales y constantes.
3. El bloque de código siempre se comienza con la palabra reservada inicio
4. Los comentarios se inician con: // para una sola línea. Para mas líneas se usa: { }.
5. Declaración de Tipos de datos:
Tipo
Refiérase a la ¡Error! No se encuentra el origen de la referencia.
6. Declaración de variables:
var
entero:<lista_de_variables_enteras>
lógica:<lista_de_variables_lógicas>
real: <lista_de_variables_reales>
carácter: <lista_de_variables_carácter>
cadena: <lista_de_variables_enteras>
7. Declaración de Constantes:
const
<nombre_variable> =<expresión>
8. Para introducir valores en variables se usa:
Leer ( <lista_de_variables>).
9. Asignar valores a variables:
<nombre_variable>← <expresión>
10. Imprimir Respuestas:
Escribir(<lista_de_expresiones>)
11. Estructuras de Control:
a) Decisión Simple:
si <condición> entonces
<acciones>
fin_si
b) Decisión Doble:
<acciones>
si_no
<acciones>
fin_si
c) Decisión múltiple:
según_sea <expresión_ordinal> hacer
<listado_de_valores_ordinales>:<acciones>
…
[si_no //el corchete indica opcional
<accionesN>]
fin_según
12. Repetitivas:
mientras <condición> hacer
<acciones>
43
fin_mientras
repetir
<acciones>
hasta_que <condición>
desde <variable>←<v_inicial> hasta <v_final> [Incremento | Decremento

<incremento>] hacer
<acciones>
fin_desde
Para ver como se utilizan veamos un ejemplo:
Código: 9 Nombre Hallar el área de un triángulo

Problema Diseñar un algoritmo que halle el área de un triángulo dados su base y
altura.
Datos de Entrada base, altura
Datos de Salida área
ü Pedimos el área y la altura
//Algoritmo que calcula el área de un triángulo
Algoritmo área;
var
Fase de real: base, altura, área;
Resolución
inicio
//Lectura de los datos de entrada
Leer (base);
Leer (altura);
//Calcular el área con la fórmula

área ← base * altura / 2;
//Presentar el resultado
Escribir(área);
fin.
base altura área
4.5 7.2 16.2
Fase de
Implementación No se presenta
Ejemplo 9: Hallar el área de un Triángulo pseudocódigo
44
CODIFICACIÓN EN EL LENGU AJE DE PROGRAMACION (LENGUAJE C)
Una vez se han hechos los análisis de los algoritmos en diagrama de flujo o en
pseudocódigo se puede proceder a codificarlo en el lenguaje de programación
seleccionado. En este caso se ha elegido C, por las características mencionadas
anteriormente.
Estructuras del lenguaje C

Descripción C tiene un conjunto de palabras reservadas, en total 32 que utilizadas
adecuadamente conforman el conjunto de estructuras que le permiten programar.
Estructura general de un programa en C Sentencias condicionales
Todo programa en C consta de dos o más C soporta dos tipos de sentencias condicionales:
funciones, una de ellas es main() el programa if y switch. Además, el operador ? es una
comienza en la función main() desde la cual es alternativa para if en ciertas situacion es.
posible llamar a otras funciones. Cada función
esta compuesta por el nombre de la función, los if()
argumentos (si los hay), la declaración de if (expresión) sentencia;
variables a utilizar y la secuencia de sentencias else sentencia;
a ejecutar:
Cuando se requiere un bloque de sentencias se
Declaraciones globales debe añadir llaves {}.
Main()
{ if (expresión) {
variables locales; secuencia de sentencias
Bloque; }
} else {
void funcion1() secuencia de sentencias
{ }
variables locales;
Bloque; ifs anidados
} Uno de los aspectos más confusos de las
sentencias if de cualquier lenguaje de progra-
Cierto y falso en el lenguaje C mación se encuentra en los ifs anidados. Un if
La mayoría de las sentencias de control de anidado es un if que es el objeto de otro if o
programa de cualquier lenguaje de compu- else . La razón por la que los ifs anidados son
tadora, incluyendo C. se basan en una prueba tan problemáticos es que puede ser difícil saber
condicional que determina la acción que se ha qué else se asocia con cuál if. Por ejemplo:
de ll evar a cabo. Una prueba condicional
produce o bien un valor cierto o falso. A if(x)
diferencia de muchos otros lenguajes de if(y) printf(’1’);
computadora que especifican valores especiales else printf(“2”);
para cierto y falso, en C cualquier valor distinto
de cero es cierto, incluyendo los números La alternativa ?
negativos. El 0 es el único valor falso. Este Se puede usar el operador ? para reemplazar las
enfoque de lo que es cierto y falso permite sentencias if/else con la forma general:
codificar de forma extremadamente eficiente
muchos tipos de rutinas. La restricción clave es que el objetivo del if y del
else deben ser expresiones simples no otra
Sentencias de C sentencia de C.
De acuerdo con la sintaxis de C, una sentencia
puede consistir en una de las siguientes: La ? es un operador ternario, ya que usa tres
una única sentencia, un bloque de sentencias o operandos y tiene la forma general
nada (en el caso de sentencias vacías). condición ? Exp2 : Exp1
45
switch Esta condición puede estar predefinida como en
Aunque la escala if-else-if puede realizar el bucle for o no haber final determinado, como
pruebas multicamino, es poco elegante. El los bucles while y do.
código puede ser bastante difícil de seguir y
puede confundir incluso a su autor algún tiempo for()
después. Por estas razones, C incorpora una El formato general del bucle for de C se
sentencia de decisión de ramificación múltiple encuentra de una forma o de otra en todos los
denominada switch. Esta sentencia compara lenguajes de programación procedimentales. En
sucesivamente una variable con una lista de C, sin embargo, proporciona una potencia y
constantes enteras o de caracteres. Cuando se flexibilidad sorprendentes.
encuentra una correspondencia.
for(inicialización; condición; incremento)
switch (variable) { sentencia;
case constante1:
secuencia de sentencias • La inicialización normalmente es una
break; sentencia de asignación que se utiliza para
case constante2: iniciar la variable de control del bucle.
secuencia de sentencias • La condición es una expresión relacional que
break; determina cuándo finaliza el bucle.
case constante3: • El incremento define cómo cambia la
secuencia de sentencias variable de control cada vez que se repite el
break; bucle.
... while()
El segundo bucle disponible en C es el bucle
default: while. Su forma general es:
secuencia de sentencias
} while(condición) sentencia;
Hay tres cosas importantes que se deben saber donde sentencia es una sentencia vacía una
sobre la sentencia switch: sentencia simple o un bloque de sentencias que
se repiten. La condición puede ser cualquier
1. La sentencia switch se diferencia de la expresión y cualquier valor distinto de O es
sentencia if en que switch sólo puede cierto. El bucle itera mientras la condición es
comprobar la igualdad, mientras que if cierta. Cuando la condición se hace falsa, el
puede evaluar expresiones relacionales control del programa pasa a la línea siguiente al
o lógicas. código del bucle.
2. No puede haber dos constantes case
en el mismo switch que tengan los do while()
mismos valores. Por supuesto, una A diferencia de los bucles for y while, que
sentencia switch contenida en otra analizan la condición del bucle al principio del
sentencia switch puede tener mismo, el bucle do/while analiza la condición al
constantes case que sean iguales. final del bucle. Esto significa que el bucle
3. Si se utilizan constantes de tipo do/while siempre se ejecuta al menos una vez.
carácter en la sentencia switch, se
convierten automáticamente a sus do {
valores enteros. secuencia de sentencias ;
} while(condición);
Sentencias Repetitivas (Bucles)
En C, como en todos los lenguajes de break
programación modernos, las sentencias de La sentencia break tiene dos usos. Se puede
iteración (también denominadas de bucles) usar para finalizar un case en una sentencia
permiten que un conjunto de instrucciones sea switch.
ejecutado hasta que se alcance una cierta
condición.
46
También se puede usar para forzar la continue()
terminación inmediata de un bucle, saltando la La sentencia continue opera de forma similar a
evaluación condicional normal del bucle. break. Sin embargo, en vez de forzar la
terminación, continue fuerza una nueva iteración
exit() del bucle y salta cualquier código que exista
Se puede salir anticipadamente de un programa entre medias.
usando la función exit() de la biblioteca
estándar. Como la función exit() da lugar a la Etiquetas y goto
terminación inmediata del programa, forzando la Aunque el uso del goto ha decaído desde hace
vuelta al sistema operativo, su uso la convierte algunos años, recientemente se ha decidido
específicamente en un dispositivo de control de mejorar un poco su empañada imagen. Se debe
programa y muchos programadores de C se dejar anotar que no existen situaciones de
basan en ella. La forma general de la función programación que necesiten de su uso; más
exit( ) es esta: bien, puede resultar conveniente y beneficioso,
si se usa apropiadamente, en determinadas
void exit(int estado): situaciones de programación. Por ello, el goto
Generalmente se usa un cero como argumento no se utiliza en este libro fuera de esta sección.
de exit() para indicar que se trata de una (En un lenguaje como C, que tiene un rico
terminación normal del programa. Se utilizan conjunto de estructuras de control y permite un
otros argumentos para indicar algún tipo de control adicional usando break y continue, no es
error que pueda ser accedido por un proceso de muy necesario.) La idea principal que los
mayor nivel. programadores tienen sobre el goto es que
tiende a hacer los programas ilegibles. Sin
embargo, hay veces en las que el uso del goto
realmente clarifica el flujo del programa más que
confundirlo.
Código: 10 Nombre Calculo del perímetro

Problema Diseñar un algoritmo que halle el perímetro de una circunferencia dado su
radio.
Resolución Datos de Entrada radio
Datos de Salida perímetro
fórmula del perímetro de la circunferencia: perímetro =
Datos Auxiliares
2 * π * radio.
ü Pedimos el radio de la circunferencia
47
//Algoritmo que calcula el perímetro de una circunferencia
Algoritmo circunferencia;
var
real: radio, perímetro;
Const
Pi=3.1416;
inicio
//Lectura del radio
Leer (radio);
//Calcular el perímetro con la fórmula

perímetro ← 2 * Pi * radio;
//Presentar el resultado
Escribir(perímetro);
fin.
radio perímetro
3 18,8496
// ___________________________________________________________
// Nombre: Perímetro de la Circunferencia
// Descripción: Este programa recibe la información del radio de
// la circunferencia y calcula su perímetro.
// Datos Responsable: Miguel Ángel Niño Zambrano UNICAUCA - FIET.
// ___________________________________________________________
#include <stdio.h>
#define pi 3.1416
Fase de #define escribe printf
Implementación
main()
{
//Definición de variables
int intRadio;
//Lectura del radio

escribe("Introduce el radio: ");
scanf("%d",&intRadio);
//Calculo del perímetro y presentación del mismo

escribe("/n El perímetro es: %f",2 * pi * intRadio);
}
Introduce el radio: 3
Ejecución
El perímetro es: 18,8496
Ejemplo 10: Uso de Constantes (Calculo del Perímetro)
48
Código: 11 Nombre Usos de Variables
Problema Elaborar un programa que permita demostrar el manejo básico de las
variables
Etapas de Resolu ción del Problema
Datos de Entrada Ninguno
Datos de Salida Contenido de las variables
Datos Auxiliares Ninguno
ü Declarar variables locales y Globales
Descripción:
ü Imprimir los contenidos
Diseño y Verificac ión del Algoritmo
//Algoritmo que ilustra el uso de la variables
Algoritmo UsodeVariables;
//Declaración de variables globales

var
entero: ginta;
inicio
//Declaración de variables locales
Fase de var
Resolución entero: intnum1=4, intnum2, intnum3=6, intb=4;
//Imprimir los valores de las variables

Escribir (“El valor de intnum1 es”, intnum1);
Escribir (“El valor de intnum2 es”, intnum2);
//Sumar dos variables

intnum2 ← intnum1 + intnum3;
Escribir (“intnum1 + intnum3 = ”, intnum2);
//Imprimir el ámbito de las variables

Escribir(“intb es local y vale: ”, intb);
ginta=5;
Escribir(“inta es global y vale: ”, inta);
fin.
Intnum1 intnum2 intnum3 inta intb
4 Nil 6 Nil 4
4 10 6 5 4
49
Implementación // ___________________________________________________________
// Nombre: Usos de las Variables
// Descripción: El programa define variables locales y globales
// realiza operaciones básicas y presenta su
// contenido
// ___________________________________________________________
#include <stdio.h>
#include <conio.h>
//Declaración de variables globales

int ginta;
main() /* Suma dos valores */

{
//Declaración de variables Locales
int intnum1=4,intnum2,intnum3= 6,intb=4;
//Imprime los valores de cada variable

printf("El valor de intnum1 es %d",intnum1);
printf("\nEl valor de intnum3 es %d",intnum3);
//Suma dos variables

intnum2=intnum1+intnum3;
printf("\nnum1 + intnum3 = %d",intnum2);
//Imprime el ambito de las variables

printf("\n intb es local y vale %d",intb);
ginta=5;
printf("\n ginta es global y vale %d",ginta);
getch();
}
El valor de intnum1 es 4
El valor de intnum3 es 6
Ejecución num1 + intnum3 = 10
intb es local y vale 4
a es global y vale 5
Ejemplo 11: Uso de Variables
50
Código: 12 Nombre Usos de Operadores
Problema Elaborar un programa que permita demostrar el manejo básico de los
operadores y como se aplican a los diferentes datos.
ü Declarar variables locales y Globales
Descripción:
ü Realizar las operaciones
//Uso de los operadores aritméticos
var
entero: inta←1,intb← 2,intc←3,intr;
entero: intx,inty,intz,intd,inte, intNumero;
inicio
Escribir("Uso de los operadores aritméticos:");
intr← inta+intb;
Escribir(inta,"+”, intb, “=”,intr);
intr← intc-inta;
Escribir(intc,"-”, inta, “=”,intr);
intb=intb+1;
Fase de Escribir(“b + 1 =”,intb);
Resolución
//Uso de los operadores de asignación
inta← 1;intb← 2;intc←3;
inta← inta+5;
Escribir("Uso de los operadores de asignación:");
Escribir("a + 5 = ",inta);
intc← intc-1;
Escribir("c - 1 = ",intc);
intb← intb*3;
Escribir("b * 3 = ",intb);
//Jerarquía de los operadores

inta← 6;intb← 5;intc←4;intd← 2;inte←1;
intx← inta*intb;
Escribir("Jerarquía de los operadores:");
Escribir(inta,”*”,intb,” = “,intx);
inty← intc/intd;
Escribir(intc,”/”,intd,” = “,inty);
intz← intx+inty;
Escribir(intx,”+”,inty,” = “,intz);
intr← intz-inte;
Escribir(intr.," = ",inta*intb+intc/intd-inte);
51
//Uso de los operadores lógicos AND,OR,NOT.
//Compara un número introducido
Escribir("Uso de los operadores logicos AND,OR,NOT");
Escribir("Introduce un numero: ");
Leer (intNumero);
Si (NOT(intNumero>=0)) entonces
Escribir("El numero es negativo");
Sino
Si ((intNumero<=100) AND (intNumero>=25)) entonces
Escribir("El numero esta entre 25 y 100");
Sino
Si ((intNumero<25) OR (intNumero>100)) entonces
Escribir("El numero no esta entre 25 y 100");
Fin_si
Fin_si
Fin_si
Fase de
/* Uso de los operadores relaciónales. */
Resolución
/* Compara dos números entre ellos */
Escribir("Uso de los operadores relacionales");
Escribir("Introduce el valor de A: ");
Leer (inta);
Escribir("Introduce el valor de B: ");
Leer (intb);
Si (inta>intb) entonces
Escribir("A es mayor que B");
Sino
Si (inta<intb) entonces
Escribir("B es mayor que A");
Sino
Escribir("A y B son iguales");
Fin_si
Fin_si
Fin.
(se deja como ejercicio)
// ___________________________________________________________
// Nombre: Uso de Operadores
// Descripción: Este programa presenta el uso de los principales
// usos de los operadores: Se ilustran los aritméticos
// de asignación y relacionales entre otros. Para esto
// se realizan operaciones sencillas.
Fase de // Datos Responsable: Miguel Angel Niño Zambrano UNICAUCA - FIET.
Implementación // Excep. / Errores: Ninguno implementado.
// ___________________________________________________________
//Inclusión de las librerías de programa
#include<stdio.h>
#include<conio.h>
52
main() /* Realiza varias operaciones */
{
/*Uso de los operadores aritméticos*/
int inta=1,intb=2,intc=3,intr;
printf("Uso de los operadores aritmeticos:\n");
intr=inta+intb;
printf("%d + %d = %d\n",inta,intb,intr);
intr=intc-inta;
printf("%d - %d = %d\n",intc,inta,intr);
intb++;
printf("b + 1 = %d\n",intb);
getch();
/* Uso de los operadores de asignación */

inta=1;intb=2;intc=3;
inta+=5;
printf("Uso de los operadores de asignacion:\n");
printf("a + 5 = %d\n",inta);
intc-=1;
printf("c - 1 = %d\n",intc);
intb*=3;
printf("b * 3 = %d\n",intb);
getch();
/* Jerarquía de los operadores */

/* Realiza una operación */
Fase de
int intx,inty,intz,intd,inte;
Implementación
inta=6;intb=5;intc=4;intd=2;inte=1;
intx=inta*intb;
printf("Jerarquia de los operadores:\n");
printf("%d * %d = %d\n",inta,intb,intx);
inty=intc/intd;
printf("%d / %d = %d\n",intc,intd,inty);
intz=intx+inty;
printf("%d + %d = %d\n",intx,inty,intz);
intr=intz-inte;
printf("%d = %d\n",intr,inta*intb+intc/intd-inte);
getch();
/* Uso de los operadores lógicos AND,OR,NOT. */

/* Compara un número introducido */
int intNumero;
printf("Uso de los operadores logicos AND,OR,NOT\n");
printf("Introduce un numero: ");
scanf("%d",&intNumero);
if(!(intNumero>=0))
printf("El numero es negativo");
else if((intNumero<=100)&&(intNumero>=25))
printf("El numero esta entre 25 y 100\ n");
else if((intNumero<25)||(intNumero>100))
printf("El numero no esta entre 25 y 100\n");
getch();
53
/* Uso de los operadores relacionales. */
/* Compara dos números entre ellos */
printf("Uso de los operadores relacionales\n");
printf("Introduce el valor de A: ");
scanf("%d",&inta);
printf("Introduce el valor de B: ");
scanf("%d",&intb);
if(inta>intb)
printf("A es mayor que B\n");
else if(inta<intb)
printf("B es mayor que A\n");
else
printf("A y B son iguales\n");
getch();
}
Uso de los operadores aritmeticos:

Fase de 1+2=3
Implementación 3-1=2
b+1=3
Uso de los operadores de asignacion:
a+5=6
c-1=2
b*3=6
Jerarquia de los operadores:
6 * 5 = 30
4/2=2
Ejecución
30 + 2 = 32
31 = 31
Uso de los operadores logicos AND,OR,NOT
Introduce un numero:
10
El numero no esta entre 25 y 100
Uso de los operadores relacionales
Introduce el valor de A:
5
Introduce el valor de B: 6
B es mayor que A
Ejemplo 12: Uso de Operadores
Código: 13 Nombre Usos de printf

Problema Elaborar un programa que permita demostrar el uso de la sentencia de
escritura printf de C.
Resolución Datos de Entrada Ninguno
54
ü Declarar variables locales y Global es
Descripción:
ü Imprimir los contenidos
// ___________________________________________________________
// Nombre: Uso de printf
// Descripción: El programa demuestra las variedades
// de uso de printf.
// ___________________________________________________________
#include <stdio.h>
#include <conio.h>
/* Uso de la sentencia printf() 1. */
main() /* Saca por pantalla una suma */

Fase de
Implementación {
int intNum1=20,intNum2=10;
printf("El valor de intNum1 es %d\n",intNum1);
printf("Por tanto %d+%d=%d\n",intNum1,intNum2,intNum1+intNum2);

/* Modificadores 1 */
char chrCadena[]="El valor de";
int intNum3=-15;
unsigned int intNum4=3;
float floNum1=932.5;
printf("%s intNum3 es %d\n",chrCadena,intNum3);
printf("%s intNum4 es %u\n",chrCadena,intNum4);
printf("%s floNum1 es %e o %f\n",chrCadena,floNum1,floNum1);

char chrCadena2[ ]="El valor de";
int intNum6=25986;
Fase de long int linNum1=1976524;
Implementación float floNum2=9.57645;
printf("%s intNum6 es %9d\n",chrCadena2,intNum6);
printf("%s linNum1 es %ld\n",chrCadena2,linNum1);
printf("%s floNum2 es %.3f",chrCadena2,floNum2);
getch();
}
55
El valor de intNum1 es 20
Por tanto 20+10=30
El valor de intNum3 es -15
Ejecución El valor de intNum4 es 3
El valor de floNum1 es 9.325000e+02 o 932.500000
El valor de linNum1 es 1976524
El valor de floNum2 es 9.576
Ejemplo.13: Uso de printf
Código: 14 Nombre Calculo del promedio de un estudiante

Problema Elaborar un programa que permita demostrar el uso de las sentencias
condicionales.
Fase de ü Declarar variables locales y Globales
Descripción:
Resolución ü Imprimir los contenidos
56
// ___________________________________________________________
// Nombre: Uso de printf
// Descripción: El programa demuestra las variedades
// de uso de printf.
// ___________________________________________________________
#include <stdio.h>
#include <conio.h>
main() /* Saca por pantalla una suma */

Fase de
{
Implementación
int intNum1=20,intNum2=10;
printf("Por tanto %d+%d=%d\n",intNum1,intNum2,intNum1+intNum2);

char chrCadena[]="El valor de";
int intNum3=-15;
unsigned int intNum4=3;
printf("%s intNum3 es %d\n",chrCadena,intNum3);
printf("%s intNum4 es %u\n",chrCadena,intNum4);
printf("%s floNum1 es %e o %f\n",chrCadena,floNum1,floNum1);

char chrCadena2[ ]="El valor de";
int intNum6=25986;
long int linNum1=1976524;
printf("%s intNum6 es %9d\n",chrCadena2,intNum6);
printf("%s linNum1 es %ld\n",chrCadena2,linNum1);
printf("%s floNum2 es %.3f",chrCadena2,floNum2);
Fase de getch();
Implementación }
Por tanto 20+10=30
El valor de intNum3 es -15
Ejecución El valor de intNum4 es 3
El valor de floNum1 es 9.325000e+02 o 932.500000
El valor de linNum1 es 1976524
El valor de floNum2 es 9.576
Ejemplo 14: Calculo de promedio de un estudiante
57
1. Determinar el Máximo Común Divisor de dos números enteros por el algoritmo de

Euclides.
2. Diseñar un algoritmo que lea e imprima una serie de números distintos de cero. El
algoritmo debe terminar con un valor cero que no se debe imprimir. Finalmente se
desea saber la cantidad de valores leídos distintos de cero.
3. Diseñar un algoritmo que imprima y sume la serie de números 3,6,9,12,...,99.
4. Diseñar un algoritmo para calcular la velocidad (en metros / segundo) de los
corredores de una carrera de 1500 metros. La entrada serán parejas de números
(minutos, segundos) que darán el tiempo de cada corredor. Por cada corredor se
imprimirá el tiempo en minutos y segundos, así como la velocidad media. El Bucle
se ejecutará hasta que demos una entrada de 0,0 que será la marca de fin de
entrada de datos.
5. Diseñar un algoritmo para determinar si un número n es primo (un número primo
sólo es divisible por el mismo y la unidad).
6. Escribir un Algoritmo que calcule la superficie de un triángulo en función de la base
y la altura.
7. Escribir un algoritmo que lea un valor entero, lo doble, se multiplique por 25 y
visualice el resultado.
8. Diseñar un algoritmo que lea cuatro variables y calcule e imprima su producto, su
suma y su media aritmética.
9. Diseñar un Programa que lea el peso de un Hombre en Libras y nos devuelva su
peso en Kilogramos y gramos. Nota: Una libra equivale a 0.453592 Kilogramos.
10. Escribir un algoritmo que calcule y escriba en cuadrado de 821.
11. Realizar un algoritmo que calcule la suma de los enteros entre 1 y 10, es decir,
1+2+3+4+...+10.
12. Realizar un algoritmo que calcule las potencias de 2 entre 0 y 10.
13. Leer un carácter y deducir si está situado antes u después de la <<m>> en orden
alfabético.
14. Leer dos caracteres y deducir si están en orden alfabético.
15. Leer un carácter y deducir si está o no comprendido entre las letras I y M ambas
inclusive.
16. Leer dos cadenas de texto y establecer si una cadena contiene la otra, el algoritmo
debe imprimir la cadena contenedora y la cadena contenida.
17. A partir de una cadena de caracteres establecer el numero de letras <<a>> que
contiene.
18. Leer un número de que puede tomar sólo valores entre 0 y 3, dependiendo del
valor escogido devuelve un mensaje especificando cual fue la opción seleccionada.
19. Leer una cadena y la presente con las vocales en mayúscula y las demás letras en
minúscula.
20. Programa que muestre el abecedario en mayúsculas: (Nota: El ASCII A=65, B=66,
..., Z=90).
58
PROGRAMACIÓN ESTRUCTURADA
Introducción:
La programación estructurada se fundamenta en el uso de estructuras de

manipulación de la información, representadas en conjuntos de instrucciones
organizados de acuerdo al lenguaje de representación de los algoritmos
(diagramas de flujo, pseudocódigo, lenguajes de programación específicos) que se
halla escogido, tal como se presentó en el capitulo anterior.
Las principales estructuras que deben existir en todo lenguaje son: simples
(asignaciones, lecturas, escrituras), Decisión (si simple, si doble, opción múl tiple) y
las repetitivas (Repetir hasta, Mientras hacer, Para un valor inicial hasta uno final
hacer). Estos elementos son primordiales y suficientes para elaborar soluciones
adecuadas a los problemas algorítmicos. Todos los procesos definidos en la
solución de un problema son traducidos a la computadora por medio de estas
estructuras.
59
4.11. PROGRAMACIÓN ESTRUCTURADA
En el capitulo anterior se presento todas las estructuras que se van a utilizar tanto
el los algoritmos como en la codificación en C. La programación estructurada se
refiere a la utilización de un número limitado de estructuras de control, que
simplifican la complejidad de los problemas y por consiguiente permiten
solucionarlo de una forma algoritmica.
La programación estructurada utiliza un conjunto de técnicas que incorporan:
ü Diseño descendente (top–down): Es un proceso mediante el cual un

problema se descompone en una serie de niveles o pasos sucesivos de
refinamiento.
ü Recursos abstractos: Consiste en descomponer una determinada acción

compleja en función de un número de acciones más simples, capaces de ser
ejecutadas por una computadora, y que se convierten en sus instrucciones.
ü Estructuras Básicas (Secuenciales, Selectivas, Repetitivas): En Mayo de

1966 Böhm y Jacopini demostraron que un programa propio puede ser escrito
utilizando solamente tres tipos de estructuras de control: secuenciales,
selectivas y repetitivas. Un programa es propio cuando cumple con:
• Posee un solo punto de entrada y uno de salida o fin para el control de
programa.
• Existen cambios desde la entrada hasta la salida, que se pueden seguir y
que pasan por todas partes del programa.
• Todas las instrucciones son ejecutables, y no existen lazos o bucles
infinitos.
4.11.1. Estructura general de un programa .
INTRODUCCION
Un programa puede considerarse como una secuencia de acciones (instrucciones)
que manipulan un conjunto de objetos (datos). Contendrá por tanto dos bloques
para la descripción de los dos aspectos citados:
• Bloque de declaraciones: en él se especifican todos los objetos que utiliza el

programa (constantes, variables, tablas, registros, archivos, etc.).
• Bloque de instrucciones: constituido por el conjunto de operaciones que se
han de realizar para la obtención de los resultados deseados.
60
Partes principales de un programa
Dentro del bloque de instrucciones de un programa podemos diferenciar tres
partes fundamentales. En algunos casos, estas tres partes están perfectamente
delimitadas, pero en la mayoría sus instrucciones quedan entremezcladas a lo
largo del progra ma, si bien mantienen una cierta localización geométrica impuesta
por la propia naturaleza de las mismas.
• Entrada de datos: la constituyen todas aquellas instrucciones que toman

datos de un dispositivo externo, almacenándolos en la memoria central para
que puedan ser procesados.
• Proceso o algoritmo: está formado por las instrucciones que modifican los
objetos a partir de su estado inicial hasta el estado final, dejando éstos
disponibles en la memoria central.
• Salida de resultados: conjunto de instrucciones que toman los datos finales
de la memoria central y los envían a los dispositivos externos.
Estructura general de Un programa (Algoritmo - Lenguaje C)
Diagrama de Flujo pseudocódigo Programa en C

//Inicio del Algoritmo //Bloque de Declaraciones de
inicio Algoritmo Nombre; //librerías
#include <librería>
//Bloque de Declaraciones ...
Entrada Datos Tipo
... <tipo_dato> <variable>
Var
... //Inicio del Algoritmo
Proceso o
Const main()
Algoritmo ... {
//Bloque de Declaraciones
//Bloque de Instrucciones //variables locales a main
Inicio //ej.
Salida de //Entrada de Datos int i;
Resultados ...
//Proceso o Algoritmo //Entrada de Datos
... ...
Fin //Salida de Datos //Proceso o Algoritmo
fin. ...
//Salida de Datos
//Bloque de Declaraciones de }
//funciones
Función <nombre_función) //Bloque de Declaraciones de
inicio //funciones
... funcion1()
fin. {
}
procedimiento <nombre>
inicio void funcion2()
... {
fin. }
61
CLASIFICACION DE LAS INSTRUCCIONES
Una instrucción se caracteriza por un estado inicial y final del entorno. El estado
final de una instrucción coincide con el inicial de la siguiente. No siempre una
instrucción modifica el entorno, pues su cometido puede limitarse a una mera
observación del mismo o a un cambio en el orden de ejecución de otras. Las
instrucciones pueden ser:
Instrucciones de declaración
Se utilizan en aquellos lenguajes de programación que no tienen declaración
explícita de los objetos. Su misión consiste en indicar al procesador que reserve
espacio en la memoria para un objeto del programa, indicando asimismo su
nombre, tipo y características.
Instrucciones primitivas
Son aquellas que ejecuta el procesador de modo inmediato. Las principales son
asignación, entrada y salida.
• Instrucción de asignación: consiste en calcular el valor de una expresión y

almacenarlo en una variable. En algún lenguaje es preciso calcular
previamente el resultado de la expresión, pues la instrucción de asignación
sólo permite el movimiento de un valor simple.
• Instrucción de entrada: toma un dato de un dispositivo de entrada y lo
almacena en un objeto. En algún lenguaje, los datos de entrada no provienen
de un dispositivo externo, sino que han sido colocados previamente en el
mismo programa.
• Instrucción de salida: toma el valor de una expresión u objeto y lo lleva a un
dispositivo externo.
Instrucciones compuestas
Son aquellas que el procesador no puede ejecutar directamente, sino que realiza
una llamada a un subprograma, subrutina o párrafo.
Instrucciones de control
Son aquellas de controlar la ejecución de otras instrucciones.
• Instrucción alternativa: controla la ejecución de unas u otras instrucciones

según una condición. Puede ser simple o doble (SI y SINO).
• Instrucción de salto incondicional: altera la secuencia normal de ejecución
de un programa, continuando la misma en la línea indicada en la propia
instrucción (IR A).
• Instrucción de salto condicional: altera la secuencia normal de ejecución de
un programa únicamente en el caso de cumplimiento de una condición
asociada a la propia instrucción (SI ... IR A).
62
• Instrucción repetitiva: hace que se repitan una o varias instrucciones un
número determinado o indeterminado de veces (PARA, MIENTRAS, HASTA e
ITERAR).
Un desarrollo más completo de estras instrucciones se hace en el apartado

4.11.2.
Tipos de Instrucciones (Algoritmos – Lenguaje C)

En la ¡Error! No se encuentra el origen de la referencia. se hace un
comparativo de la clasificación de las diferentes instrucciones de programación y
como se representan en las diferentes herramientas de programación.
ELEMENTOS AUXILIARES DE UN PROGRAMA

Son variables que realizan funciones específicas dentro de un programa, y por su
gran utilidad, frecuencia de uso y peculiaridades, conviene hacer un estudio
separado de las mismas. Las más importantes son:
Contadores
Un contador es un campo de memoria cuyo valor se incrementa en una cantidad
fija, positiva o negativa, generalmente asociado a un bucle. Toma un valor inicial
antes de comenzar su función, y cada vez que se realiza
el suceso, incrementa su valor. Se utiliza en los siguientes casos:
• Para contabilizar el número de veces que es necesario repetir una acción
(variable de control de un bucle).
• Para contar un suceso particular solicitado por el enunciado del problema
(asociado a un bucle o independientemente).
Acumuladores
Un acumulador es un campo de memoria cuyo valor se incrementa sucesivas
veces en cantidades variables. Se utiliza en aquellos casos en que se desea
obtener el total acumulado de un conjunto de cantidades, siendo preciso
inicializarlo con el valor 0. También en las situaciones en que hay que obtener un
total como producto de distintas cantidades se utiliza un acumulador, debiéndose
inicializar con el valor 1.
Interruptores (switches)
Un interruptor es un campo de memoria que puede tomar dos valores exclusivos
(0 y 1, -1 y 1, FALSO y CIERTO, etc.). Se utiliza para:
• Recordar en un determinado punto de un programa la ocurrencia o no de un

suceso anterior, para salir de un bucle o para decidir en una instrucción
alternativa qué acción realiza r.
• Para hacer que dos acciones diferentes se ejecuten alternativamente dentro de
un bucle.
63
Instrucciones Primitivas
Diagrama de Flujo Pseudocódigo Lenguaje C
No existen //Declaración de Nuevos Tipos de Datos //Declaración de Librerías
Tipo #include <nombre_archivo.h>
//Declaración de tipos Enumerado //Declaración de Constantes
<nombre_tipo> = ( elem1, elem2, ... , elemN ); #define <nombre_dato> <valor_constante>;
//Declaración de tipo SubRango

<nombre_tipo> = [ primero .. último ]; //Declaración de Nuevos Tipos de Datos
//Declaración de tipos Enumerado
//Declaración de tipo Conjunto enum <nombre_tipo> {elem1, elem2, ... , elemN };
<nombre_tipo>=TipoReferencial{elem1,elem2,..., elemN};
Las declaraciones Subrango y conjunto se pueden
//Declaración de tipo Arreglo equiparar a la enumerado, y con ayuda de los
Array [d1, d2, ..., dn] de <tipo_dato>:<nombre_tipo>; identificadores de rango (Long, unsigned, etc)
//Declaración de Estructuras //Declaración de tipo Arreglo

Estructura: <nombre_estructura> <tipo_dato> <nombre_variable>[d1][d2][...][dn];
inicio
<tipo_dato>:var1, var2,.., varn; //Declaración de Estructuras
... Struct <nombre_estructura>
fin {
<tipo_dato> var1, var2,.., varn;
//Declaración de Constantes ...
Const };
<tipo_dato>:var1 = <valor_constante>;
//Declaración de variables
//Declaración de variables <tipo_dato> var1, var2,.., varn;
Var Las variables en C se pueden declarar en cualquier
<tipo_dato>:var1, var2,.., varn; bloque se código. Del punto dónde se declaren
dependerá el alcance de la variable(Global o Local).
64
Instrucciones de Declaración
//Entrada de Dat os //Entrada de Datos //Entrada de Datos
var1, var2 Leer(var1, var2,..., varn); scanf("especificaciones de formato",APUNTADORES DE
LAS VARIABLES);
//Asignación //Asignación
var1← <Expresión> var1←<Expresión>; //Asignación
var1=<Expresión>;
//Salida de Datos //Salida de Datos
Escribir(var1, var2,..., varn); //Salida de Datos
var1, var2 Escribir(“Texto de Salida”,var1, var2,..., varn); printf("mensajes y <especificaciones de
campo>",<LISTA DE VARIABLES>);
Instrucciones Compuestas
//Iguales al abs(x) //funciones para m anejo de caracteres más log(x): Logaritmo natural de x
pseudocódigo arctan(x) comunes del lenguaje c: log10(x): Logaritmo base 10 de x
cos(x) Strlen(v): Proporciona el número de caracteres pow(x,n): Eleva x al exponente n
Nombre función o exp(x) que componen el valor alfanumérico sin(x): Seno de x (en radianes)
procedimiento ln(x) almacenado en la variables V cos(x): Coseno de x (en radianes)
log10(x) Strlwr(v): Convierte los caracteres alfabéticos sqrt(x): Raiz cuadrada de x
redondeo(x) de la cadena en minúsculas randomize(x): Indica la semilla para generar
sen(x) Strupr(v): Convierte los caracteres alfabéticos números pseudoaleatorios.
cuadrado(x) de la cadena en mayúsculas tan(x): Tangente de x (en radianes)
raiz2(x) Strcmp(v,w): Compara la cadena v con la random(x): Genera un número pseudoaleatorio
trunc(x) cadena w, regresa un 0 si las cadenas son entre cero y (x-1).
Estas funciones iguales
ya han sido Strcpy(v,w): Copia la cadena W en la cadena v NOTA:Al momento de realizar los programas se
explicadas en la Strcat(v,w): Agrega la cadena w al final de la debe tener en cuenta que si no agrega las
Cuadro 1 cadena v directivas de preprocesamiento adecuadas,
Otras funciones: //funcion es aritméticas de biblioteca más algunas de las funciones no pueden ser
Borrar_Pantalla() usuales reconocidas por el compilador y se generara un
IrA(x,y) abs(x): Valor absoluto de x (argumento entero) error, en tal caso hay que verificar que la sintaxis
atan(x): Arcotangente de x (con resultados co sea correcta, que efectivamente se agregó las
valores de -1.57 a 1.57 en radianes) directivas correctas o en algunos casos activarlas
exp(x): Función exponencial. en OPTIONS/LINKER/LIBRARIES.
65
Instrucciones de Control
//Instrucciones Selectivas //Instrucciones Selectivas //Instrucciones Selectivas
//Decisión Simple //Decisión Doble //Decisión Simple //Decisión Simple
si <condición> entonces if (expresión) sentencia;
<acciones> else sentencia;
Si No Si fin_si
No --
//Decisión Doble
//Decisión Doble if (expresión) {
si <condición> entonces secuencia de sentencias
<acciones> }
//Decisión Múltiple si_no else {
<acciones> secuencia de sentencias
fin_si }
//Decisión múltiple //Decisión múltiple

según_sea <expresión_ordinal> hacer switch (variable) {
<listado_de_valores_ordinales>:<acciones> case constante1:
… secuencia de sentencias
[si_no //el corchete indica opcional break;
<accionesN>] ...
// Instrucciones Repetitivas fin_según
default:
Repetir //Instrucciones Repetitivas secuencia de sentencias }
mientras <condición> hacer //Instrucciones Repetitivas
<acciones> while(condición) sentencia
fin_mientras
do {
repetir secuencia de sentencias;
<acciones> } while(condición);
Mientras
desde <variable> ← <v_inicial> hasta <v_final> for(inicialización ; condición; incremento)

[Incremento | Decremento <incremento>] hacer sentencia;
Desde <acciones>
fin_desde
66
4.11.2. Estructuras Básicas de Control de Programa
Alternativas
Los programas, para un mejor funcionamiento y poder realizar un número mayor
de tareas, deben permitir emplear acciones alternativas para poder elegir una de
ellas cuando la situación lo requiera. Las instrucciones condicionales o tomas de
decisión permiten realizar acciones alternativas. Por tanto, la ejecución de una
línea o grupos de líneas del programa depende de si cumplen o no una o varias
condiciones.
TOMAS DE DECISION
Para preguntar se utiliza la instrucción o sentencia SI (IF). La contestación sólo
puede ser verdadero o falso, es decir, sí o no.
Ejemplo: Si llueve, coge el paraguas
La realización de la acción está supeditada a que se cumpla la condición. El

formato de las tomas de decisión es:
Instrucción SI
< instrucciones >
fin_si
El ordenador primero examina la condición. Pueden suceder dos cosas:
• La cumple: realiza todas las instrucciones que hay dentro del SI, luego
continua ejecutando las que están fuera del SI.
• No la cumple: no entra en el SI. Sólo realiza las instrucciones siguientes al SI.
Es decir, las instrucciones del SI sólo las realiza cuando cumple la condición. Las
instrucciones que están fuera las realiza siempre, se cumpla o no la condición. Se
puede poner más de una condición, siempre y cuando estén unidas por los
operadores lógicos (AND, NOT, OR).
Código: 15 Nombre Establecer si un número es negativo

Problema Elaborar un algoritmo que permita Introducir un número por teclado. Que nos
diga si es negativo.
68
Resolución Datos de Entrada Numero
Datos de Salida “Es negativo”
ü Pedimos el número
ü Preguntamos si es menor de cero
ü Si es menor de cero, entonces el número es
Descripción:
negativo.
ü Si es negativo presentar el mensaje.
ü Si no, no presentar nada.
//Algoritmo que verifica si el número leído es negativo
Algoritmo negativo;
var
real: Número;
inicio
//Limpia la pantalla
Borrar_Pantalla();
Número ← 0;
Escribir (“Introduce un Número”);
Leer (Número);
//Verificar si es negativo
si Número < 0 entonces
Escribr (“Es Negativo”);
Fin_si
fin.
Comprobación del Algoritmo (t raza)
Traza 1
Número Respuesta
3 Nada
Traza 2
Número Respuesta
-4 “Es Negativo”
69
Implementación // ___________________________________________________________
// Nombre: Uso de if
// Descripción: El programa demuestra el uso de la sentencia IF.
// Excep. / Errore s: Ninguno implementado.
// ___________________________________________________________
#include <stdio.h>
#include <conio.h>
/* Uso de la sentencia if. */
main() /* Establece si un número dado es negativo */

{
//Definición de variables locales
float floNumero;
//Borrar la pantalla
clrscr();
//Pedir el número
floNumero=0;
printf("Introduce el Número: ");
scanf("%f",&floNumero);
//verificar si es negativo
if (floNumero < 0)
{
printf("\nEs Negativo");
}
getch();
}
Ejecución 1:
Introduce el Número: 5
Ejecución
Ejecución 2:
Introduce el Número: -5
Es Negativo
Ejemplo 15: Establecer si un número es negativo
Instrucción SI -SINO
A menudo necesitamos realizar dos procesos completamente distintos,
dependiendo de si cumple o no la(s) condición(es) de entrada del SI.
< instrucciones_1 >
si_no
< instrucciones_2>
fin_si
Ejemplo: si hace frío, ponte el abrigo; en caso contrario, ven en camisa
• Cumple la(s) condición(es): realiza las instrucciones que hay entre el SI y el

SINO (instrucciones_1).
70
• No las cumple: ejecuta las instrucciones que hay entre el SINO y el FINSI
(instrucciones_2).
Todo lo que se encuentre fuera del SI siempre lo va a realizar. SINO significa "en
caso contrario".
Código: 16 Nombre Establecer si un número es par o impar

Problema Elaborar un algoritmo que permita Introducir un número por teclado. Que nos
diga si es par o impar.
Datos de Entrada Numero
Datos de Salida “Es par”, “Es impar”
Para saber si es par se usa la siguiente fórmula:
Datos Auxiliares
num = int(num / 2) * 2
Fase de ü Pedimos el número
Resolución ü Preguntamos si es par usando la fórmula
Descripción: ü Si es igual, entonces el numero es par.
ü Si es par , entonces presentar el mensaje
ü Si no, entonces presentar el mensaje que no es
par.
//Algoritmo que verifica si el número leído es par o impar
Algoritmo ParImpar;
var
real: Número;
inicio
Borrar_Pantalla();
Fase de Número ← 0;
Resolución Escribir (“Introduce un Número”);
Leer (Número);
//Verificar si es par
si Número = int(Número / 2) * 2 entonces
Escribr (“Es Par”);
Sino
Escribr (“Es Impar”);
Fin_si
fin.
Fase de Comprobación del Algoritmo (traza)
71
Resolución Traza 1
Número Respuesta
20 “Es impar”
Traza 2
Número Respuesta
21 “Es par”
Traza 3
Número Respuesta
22 “Es par”

// ___________________________________________________________
// Nombre: Uso de if else
// Descripción: El programa demuestra el uso de la sentencia IF.
// ___________________________________________________________
#include <stdio.h>
#include <conio.h>
/* Uso de la sentencia if. */
main() /* Establece si un número dado es par o impar */
{
Fase de int intNumero;
Implementación //Borrar la pantalla
clrscr();
//Pedir el número
floNumero=0;
printf("Introduce el Número: ");
scanf("%d",& intNumero);
//verificar si es negativo
if (intNumero < 0)
{
printf("\nEs par");
else
{
printf("\nEs Impar");
}
getch();
}
Ejecución 1: Ejecución 2:
Ejecución Introduce el Número: 5 Introduce el Número: 4
“Es impar” “Es par”
Ejemplo 16: Establecer si un número es par o impar
72
Instrucciones SI - SINO anidadas
El anidamiento es una técnica utilizada para relacionar estructuras de
programación contenidas en otras estructuras, de tal forma que una estructura
puede contener otra estructura dentro de sus bloque de código y a su vez esa
estructura puede contener otra estructura y asi sucesivamente. Cuando anidamos
sólo estructuras SI – SINO es lo que se conoce como SI – ANIDADOS, éstos
permiten elaboar jerarquías de condiciones. Los anidamientos permitidos y no
permitidos lo podemos observar en la Figura 2. En los anidamientos también se
pueden utilizar repetitivos anidados o una combinación de anidamiento de
diferentes estructuras. La estructura de un SI – SINO anidado es como la
siguiente:
A B C
Figura 2: A,B Anidamientos correctos, C Anidamiento incorrecto
si condición_1 entonces
< instrucciones _1>
< instrucciones _2>
si_no
< instrucciones _3>
fin_si
si_no
< instrucciones _4>
< instrucciones _5>
si_no
< instrucciones _6>
fin_si
fin_si
En el formato general para la sentencia SI, las acciones 1 y 2 no están limitadas a

ser instrucciones imperativas; pueden ser expresiones condicionales y surge la
posibilidad de usar instrucciones SI anidadas. Para su ilustración refiérase al
Ejemplo 17.
73
Código: 17 Nombre Determinar Bebe, Niño o Adulto
F.P. Enunciado
Elaborar un algoritmo que una vez dado la edad pueda determinar si el usuario es un Bebe (1..3
años), Niño (3..13 años) o Adulto (13 o más años)
Datos de Entrada Edad
Datos de Salida “Estas Equivocado”“Eres un Bebé”, “Eres un Niño”, “Eres un Adulto”
Equivocado (menor de 1 año), Bebe (1..3 años) o Niño (3..13 años),
Datos Auxiliares
Adulto (13 o más años).
ü Pedimos la edad
Descripción:
ü Preguntamos si es menor de 1, si es así entonces el imprimimos “Estas equivocado”.

ü Si no preguntamos si es menor de 3, si es así entonces el imprimimos “Eres un Bebe”.
ü Si no preguntamos si es menor de 13, si es así entonces el imprimimos “Eres un Niño”.
ü Si no entonces el imprimimos “Eres un Adulto”.
//Algoritmo que verifica si el usuario es un bebe, un niño o un adulto
Algoritmo QuienEres;
var
entero: Edad;
inicio
Borrar_Pantalla();
Edad ← 0;
Escribir (“Introduce tu Edad”);
Leer (Edad);
F.R.
//Verificar si es negativo
si Edad < 1 entonces
Escribr (“Estas equivocado”)
si_no
Escribr (“Eres un Bebe”)
si_no
Escribr (“Eres un Niño”)
si_no
Escribr (“Eres un Adulto”)
fin_si
fin_si
fin_si
fin.
Traza 1 Traza 2
Edad Respuesta Edad Respuesta
-5 “Estas equivocado” 2 “Eres un Bebe”
Traza 3 Traza 4
Edad Respuesta Edad Respuesta
10 “Eres un Niño” 20 “Eres un Adulto”
74
Implementación // ___________________________________________________________
// Nombre: Uso de if anidados
// Descripción: Se demuestra el uso de la sentencia else if.
// ___________________________________________________________
#include <stdio.h>
#include <conio.h>
/* Uso de la sentencia else if. */
main() /* Escribe bebe,niño o adulto */

{
int intEdad;
//Borrar la pantalla
clrscr();
//Pedir el número
printf("Introduce tu edad: ");
scanf("%d",& intEdad);
if (intEdad <1)
printf("Te has equivocado.");
else if (intEdad <3) printf("Eres un beb‚");
else if (intEdad <13) printf("Eres un ni¤o");
else printf("Eres adulto");
getch();
}
Traza 1
Introduce tu edad: -5
Lo siento, te has equivocado.
Traza 2
Introduce tu edad: 2
Ejecución
Eres un bebe
Traza 3
Eres un ni±o
Traza 4
Eres adulto
Ejemplo.17: Determinar si es Bebe, Niño o Adulto
75
Instrucción condicional múltiple SEGÚN_SEA
según_sea <expresión_ordinal> hacer

<valor_ordinal_1>:<instrucciones_1>
<valor_ordinal_1>:<instrucciones_1>
...
<valor_ordinal_N>:<instrucciones_N>
[si_no //el corchete indica opcional
<instrucciones_N+1>]
fin_según
Esta estructura permite elegir un conjunto de instrucciónes de varias posibilidades,

por ello es usada comunmente para la elaboración de menúes de opción.
(Refiérase al Ejemplo 18).
Un menú consiste en presentar en pantalla una ventana con una serie de

operaciones u opciones a realizar, cada una de las cuales realiza una función
determinada. Cuando termine de ejecutar cada una de ellas, mediante
subprogramas, el programa vuelve de nuevo al menú del que había partido. A
veces los menús se presentan anidados, es decir, alguna de las opciones del
menú, al ser seleccionada, hace que aparezca otro menú, dando lugar a nuevas
posibilidades de elección. Los menús permiten ejecutar más de un programa, sin
necesidad de tener que escribir su nombre, cada vez que se desea ejecutarlo.
Simplemente, le indicaremos mediante una variable la opción deseada. La
selección del programa a realizar se puede hacer mediante la instrucción SI. Pero
hay una más rápida y más fácil de manejar: es la instrucción condicional múltiple
SEGÚN_SEA.
Funciona bifurcando la ejecución del programa a las instrucciones que siguen a la

evaluación verdadera (igualdad del valor ordinal con la variable del SEGÚN_SEA).
La ejecución del programa continua hasta encontrarse el próximo valor ordinal. Si
ninguna de los valores ordina les es verdadera, el siguiente conjunto de
instrucciones que se ejecutan son las que le siguen al si_no, si existe, se ejecuta
hasta la próxima orden fin_segun.
Bucles
En informática, la mayoría de las veces la tarea que debe realizar el ordenador es

la misma: lo único que varía son los valores de los datos con los que está
operando. Llamamos bucle o ciclo a todo proceso que se repite un número de
veces dentro de un programa.
76
Instruccion MIENTRAS
mientras <condición> hacer
<instrucciones_1>
fin_mientras
<instrucciones_2>
Lo primero que hace el ordenador es examinar la condición. Da como resultado

dos posibilidades:
• Se cumple: va a realizar todas las instrucciones que están dentro del ciclo,
instruccion_1. Las estará repitiendo hasta que deje de cumplirse la condición.
Entonces sale del ciclo y continúa ejecutando las instrucciones que hay fuera
de él, instruccion_2.
• No se cumple: no entrará en el ciclo. Ejecuta las instrucciones que están
fuera de él, instruccion_2.
La condición del bucle no tiene por qué ser única: puede haber más de una,
siempre y cuando estén unidas por los operadores lógicos (AND, NOT, OR).
(Refiérase al Ejemplo 18). Lo expresamos:
mientras < condicion_1> operador_logico <condicion_2> hacer...
Instruccion REPETIR
repetir
<instrucciones_1>
<instrucciones_2>
El bloque de <instrucciones_1> se realiza por lo menos una vez. La condición se

examina después de la siguiente forma:
• No se cumple: va a realizar todas las instrucciones que están dentro del ciclo,
instruccion_1. Las estará repitiendo hasta que se cumpla la condición.
Entonces sale del ciclo y continúa ejecutando las instrucciones que hay fuera
de él, instruccion_2.
• Se cumple: Saldrá del ciclo. Ejecuta las instrucciones que están fuera de él,
instruccion_2.
La condición del bucle no tiene por qué ser única: puede haber más de una,
siempre y cuando estén unidas por los operadores lógicos (AND, NOT, OR).
(Refiérase al Ejemplo 18). Lo expresamos:
Hasta_que < condicion_1> operador_logico <condicion_2>
77
Código: 18 Nombre Operaciones matemáticas simples
F.P. Enunciado
Introducir dos números por teclado y mediante un menú calcular su suma, su resta, su
multiplicación y su división. Validar que los números no sean negativos y la división por cero.
Datos de Entrada Numero1, Numero2
Datos de Salida La suma, resta. Multiplicación y división de los numeros
ü Pedimos los números, si alguno de ellos es negativo entonces se vuelve a pedir el
número hasta que sea positivo.
Descripción :
ü Presentamos un menu de opción, que despliegue las opciones de la operación a

realizar. “1. Suma”, “2. Resta”, “3 Multiplicación”, “4. División”, “5. Salir”. Este menu se
presenta una vez realizada cada operación hasta que se escoja “Salir”.
ü Cuando se realicen las instrucciones de la división se debe validar que el número dos
no sea cero, en este caso se debe avisar que se intenta realizar un dividion por cero.
//Algoritmo que realiza operaciones aritmeticas básicas.

Algoritmo aritmetica;
var
real: Numero1, Numero2;
entero: Opcion;
Inicio
Opcion ← 0;
F.R. Borrar_pantalla();
//Leer los números hasta que sean positivos

repetir
IrA(10,20); Escribir("1er. Número: ");
IrA(10,29); Leer(Numero1);
IrA (12,20); Escribir( "2do. Número: ");
IrA (12,29); Leer(Numero2);
hasta ((Numero1 < 0) AND (Numero2 < 0))
//Repetir el menu hasta que se dijite Salir

mientras Opcion <> 5 hacer
Opcion ← 0;
Borrar_pantalla( );
IrA (6,20); Escribir("Menú de opciones");
IrA (10,25); Escribir("1.- Suma");
IrA (12,25); Escribir("2.- Resta");
IrA (14,25); Escribir("3.- Multiplicación");
IrA (16,25); Escribir("4.- División");
IrA (18,25); Escribir("5.- Salir del programa");
IrA (22,25); Escribir("Elige opción: ");
IrA (22,39); Leer(Opcion);
Borrar_pantalla( );
78
//Realizar el proceso según el valor de la opción digitada
según_sea Opcion hacer
1:IrA (10,20); Escribir("Su suma es: ");
IrA (10,33); Escribir(Numero1 + Numero2);
2:IrA (10,20); Escribir("Su resta es: ");
IrA (10,33); Escribir(Numero1 - Numero2);
3:IrA (10,20); Escribir("Su multiplicación es: ");
IrA (10,33); Escribir(Numero1 * Numero2);
4://validar la división por cero
si Numero2 <> 0 entonces
IrA (10,20); Escribir("Su división es: ");
F.R. IrA (10,33); Escribir(Numero1 / Numero2);
si_no
IrA (10,20); Escribir("División no válida, División por cero ");
fin_si
si_no
IrA (10,20); Escribir(“Opción incorrecta”);
fin_según
fin_mientras
fin.
Se deja como ejercicio
// ___________________________________________________________
// Nombre: Operaciones Matemáticas
// Descripción: Se demuestra el uso de Do, While y Switch
// Excep. / Errores: No se valida la entrada numérica.
// Limitaciones: Los Numeros deben ser Positivos. División por cero
// ___________________________________________________________
#include <stdio.h>
#include <conio.h>
/* Uso de las sentencias while, Do, Switch. */
main() /* Operaciones matemáticas*/

F.I. {
//Definición de variables
float floNumero1, floNumero2;
int intOpcion = 0;
clrscr();
//Leer los números hasta que sean positivos
do
{
gotoxy(10,20); printf("1er. Número: ");
gotoxy(10,29); scanf(&floNumero1);
gotoxy(12,20); printf( "2do. Número: ");
gotoxy(12,29); scanf("%f", &floNumero2);
}
while ((floNumero1 < 0) || (floNumero2 < 0));
79
//Repetir el menu hasta que se dijite Salir
while (intOpcion != 5)
{
intOpcion = 0;
clrscr();
gotoxy(6,20); printf("Menú de opciones");
gotoxy(10,25); printf("1.- Suma");
gotoxy(12,25); printf("2.- Resta");
gotoxy(14,25); printf("3.- Multiplicación");
gotoxy(16,25); printf("4.- División");
gotoxy(18,25); printf("5.- Salir del programa");
gotoxy(22,25); printf("Elige opción: ");
gotoxy(22,39); scanf("%d", &intOpcion);
clrscr();
//Realizar el proceso según el valor de la opción digitada

switch (intOpcion)
{
case 1:gotoxy(10,20); printf("Su suma es: ");
gotoxy(10,33); printf("%.2f", floNumero1 + floNumero2);
break;
F.I.
case 2:gotoxy(10,20); printf("Su resta es: ");
gotoxy(10,33); printf("%.2f",floNumero1 - floNumero2);
break;
case 3:gotoxy(10,20); printf("Su multiplicación es: ");
gotoxy(10,33); printf("%.2f",floNumero1 * floNumero2);
break;
case 4://validar la división por cero
if (floNumero2 != 0)
{
gotoxy (10,20); printf("Su división es: ");
gotoxy (10,33); printf("%.2f",floNumero1 / floNumero2);
}
else
{
gotoxy (10,20); printf("División no válida, División por cero ");
}
default:
gotoxy(10,20); printf(“Opción incorrecta”);
}
}
}
Ejecución Se deja de ejercicio.
Ejemplo 18: Menu de Operaciones Matemáticas
Instruccion DESDE
desde <variable> ← <v_inicial> hasta <v_final> [ Incremento | Decremento <incremento>] hacer

<instrucciones_1>
fin_desde
<instrucciones_2>
Cuando se sabe exactamente el número de ciclos a realizar, ésta es la mejor

instrucción. Permite definir un contador que se incrementará o decrementará en
cada ciclo realizado por la misma estructura de programación.
80
El bloque de <instrucciones_1> se realiza n veces, dónde n = |v_final – v_inicial |.
Una vez el v_final = v_inicial se deti ene el ciclo y se ejecuta el bloque de
<instruccion_2.>.
Para el caso del lenguaje C se utiliza la instrucción FOR(), la cual tiene formas
más elaboradas de control de ciclo y de definición de varios contadores. El FOR
de C es diferente en su implementación con respecto al pseudocódigo, porque
este se debe manejar como un MIENTRAS con contadores.
Código: 19 Nombre Imprimir los números del 1 al 100

Problema Diseñar un algoritmo imprima en la pantalla los números del 1 al 100,
execpto el número 25.
Datos de Entrada No hay
Datos de Salida Numeros 1..24 y 26..100
ü Realizamoos un contador, el cual se incrementa en
uno.
Descripción:
ü Se imprime el contador. Cando sea 25 no se
imprime.
//Algoritmo que imprime los numeros de 1..100 menos el 25
Algoritmo imprimir1_100;
Fase de var
Resolución entero: Contador;
inicio
//Usar un desde para la impresión
desde Contador ← 1 hasta 101 Inc 1 hacer
//Si el contador es 25 Continuar_For es un instrucción que salta la ejecución
//al sigiçuiente ciclo del desde
si Contador = 25 entonces
Continuar_For;
fin_si
Escribir(Contador);
fin_desde
fin.
No se hace
81
Implementación // _________________ __________________________________________
// Nombre: Contador de Números
// Descripción: Se demuestra el uso de for, Continue;
// ___________________________________________________________
#include <stdio.h>
#include <conio.h>
/* Uso de la sentencia CONTINUE. */
main() /* Escribe del 1 al 100 menos el 25 */

{
int intNumero;
for(intNumero =1; intNumero < 100; intNumero++)

{
if (intNumero ==25) continue;
printf("%d\n", intNumero);
}
}
Ejemplo 19: Presentar los números del 1 al 100 menos el 25
BUCLES ANIDADOS
Un ciclo puede estar formado por otro u otros ciclos. Al igual que sucedía con la
instrucción SI, que dentro de un SI podíamos tener todos los SI que fueran
necesarios, dentro de un bucle MIENTRAS pueden ir otro u otros bucles
MIENTRAS, de tal forma que el último de todos, el situado más interiormente, es
el primero en cerrarlo, en acabar. El primero de todos, situado más fuera, es el
último en termi nar.
mientras <condicion_1> hacer

...
mientras condicion_2 hacer
...
mientras condicion_3 hacer
...
...
fin_mientras
...
fin_mientras
...
fin_mientras
Los puntos suspensivos serán las distintas instrucciones a realizar. De la misma
82
forma se puede hacer con las demás estructuras repetitivas.
Código: 20 Nombre Tablas de Multiplicar

Problema Diseñar un algoritmo imprima en la pantalla las tablas de multiplicar del 1 al
10 de los primeros 10 números.
Datos de Entrada No hay
Datos de Salida Numeros 1..24 y 26..100
ü Realizamoos un contador, el cual se incrementa en
uno.
Descripción: ü Se imprime el contador. Cando sea 25 no se
imprime.
//Algoritmo que imprime los numeros de 1..100 menos el 25
Algoritmo imprimir1_100;
var
entero: Tabla, Contador, Resultado;
Inicio
//Usar un desde para la impresión
Fase de desde Tabla ← 1 hasta 11 Inc 1 hacer
Resolución desde Contador ← 1 hasta 11 Inc 1 hacer
Resultado ← Tabla * Contador;
Escribir(Tabla, “ por”, Contador, “ = “, Resultado);
fin_desde
fin_desde
fin.
Tabla Contador Resultado
1 1 1
1 2 2
1 3 3
1 4 4
1 5 5
1 6 6
1 7 7
1 8 8
1 9 9
1 10 10
2 1 2
...
83
Implementación // ___________________________________________________________
// Nombre: Tablas de Multiplicar
// Descripción: Se demuestra el uso de for anidado
// ___________________________________________________________
#include <conio.h>
#include <stdio.h>
/* Uso de la sentencia FOR anidada. */
main() /* Escribe la tabla de multiplicar */

{
int intContador,intTabla,intResultado;
for (intTabla=1;intTabla<=10; intTabla++)

{
for (intContador=1;intContador<=10;intContador++)
{
intResultado=intTabla*intContador;
printf("\n%d por %d = _
%d\n",intTabla,intContador,intResultado);
}
getch();
}
}
1 por 1 = 1
1 por 2 = 2
1 por 3 = 3
1 por 4 = 4
1 por 5 = 5
Ejecución
1 por 6 = 6
1 por 7 = 7
1 por 8 = 8
1 por 9 = 9
1 por 10 = 10
<enter>
...
Ejemplo 20: Tablas de Multiplicar
84
1. Elabore un algoritmo que sume dos números enteros positivos, el algoritmo debe
controlar que la entrada de datos cumpla con la condición establecida.
2. Elabore un algoritmo que lea dos números y establezca si uno es múltiplo del otro.
3. Elabore un algoritmo que lea tres coordenadas cartesianas (X, Y) y determine si
con ellas se puede formar un triángulo rectángulo.
4. Elabore un algoritmo que determine si un punto del plano cartesiano (X, Y) se
encuentra dentro, fuera o sobre un circulo de radio R que tiene su centro en (0,0).
5. Elabore un algoritmo que muestre el valor de la coordenada Y de punto X solicitado
al usuario, el cual se encuentra en la trayectoria de una recta. De dicha recta
previamente se solicitan 2 puntos con sus respectivas coordenadas (X, Y).
6. Elabore un algoritmo que lea n y r y muestre el siguiente resultado: n! / ( r! * (n
- r)! ).
7. Elabore un algoritmo que muestre la suma de los N primeros términos de la serie
1, 3, 5, 7, 9 , ...
8. Elabore un algoritmo que lea un número entero y como resultado muestre el
numero digitado en forma invertida, por ejemplo si se teclea el número 853 debe
mostrar el número 358.
9. Elabore un algoritmo que muestre la tabla de multiplicar de los primeros N
números enteros positivos.
10. Elabore un algoritmo que muestre los N primeros términos de la serie de
Fibonnaci, sabiendo que dicha serie inicia con T0 = 0, T1 = 1 y Tn = Tn-1 + Tn-2.
11. Elabore un algoritmo que muestre el N- nésimo término de la siguiente serie: 1, 3,
8, 30, 144, 840, ...
12. Elabore un algoritmo que calcule X y , teniendo en cuenta que los dos valores son
entrados por el usuario, y el lenguaje de programación no cuenta con ningún tipo
de función predefinida que permitan hacer la operación (Se deben utilizar
instrucciones repetitivas).
13. Elabore un algoritmo que calcule la sumatoria de los N primeros términos de la
serie 1!, 2!, 3!, 4!, 5!, ...
14. Elabore un algoritmo que liste los número perfectos entre 1 y 200. Tenga en cuenta
que un número perfecto es aquel cuya suma de sus múltiplos es igual al mismo
número. Por ejemplo 28 es un número perfecto ya que 1 + 2 + 4 + 7 + 14 = 28.
15. Elabore un algoritmo que lea dos variables X, N y en un solo ciclo repetitivo
DESDE calcule los siguientes valores 2N y XN .
16. Elabore un algoritmo que lea números enteros hasta que se digite 99999. El
algoritmo debe escribir los siguientes resultados:
• La sumatoria de los número leídos
• La cantidad de números leídos
• El menor número leído
• El mayor número leído
• El número leído que haya estado más cerca de 1000.
17. Elabore un algoritmo que imprima los números de tres dígitos (100<= X<1000)
que sean iguales a las sumas de los cubos de sus dígitos. Estrategia aconsejada:
DESDE ANINADOS.
18. Elabore un algoritmo que determine el máximo común divisor de dos números
enteros positivos, sabiendo que el MCD es el menor número que puede dividir a los
dos primeros sin dejar residuo.
85
19. Elabore un algoritmo que determine el mínimo común múltiplo de dos números
enteros positivos, sabiendo que el MCM es el menor número que dividido por los
dos primeros no deja residuo.
20. Elabore un algoritmo que lea de un salón de clase el nombre de un estudiante y sus
tres notas parciales (Equivalentes en porcentaje) hasta que el nombre sea ‘0’. El
algoritmo debe decir:
• El nombre del estudiante, las tres notas parciales y la nota definitiva.
• Cuantos estudiantes fueron digitados.
• La nota promedio definitiva del salón.
86
PROGRAMACIÓN MODULAR
Introducción:
No todos los problemas que se resuelven a través de algoritmos son sencillos.

Muchos problemas implican que se reutilice código ya escrito, es más, que permita
dar un mayor entendimiento de su codificación a través de la organización
adecuada del algoritmo.
Cuando un problema algorítmico requiere de la solución de diversos problemas a

su vez, entonces la mejor opción es hacer uso de las subrutinas, procedimientos y
funciones. Los cuales se convierten en estrategias eficaces para la reutilización y
la organización del programa, a este tipo de implementación de programas es lo
que se le denomina programación modular
Un concepto importante en la programación modular es la recursividad, esta

permite hacer fácil la solución de diversos problemas, auque su solución interna
no sea tan trivial.
87
4.13. Programación Modular
4.13.1. Subprogramas. Los programas realizados hasta ahora están todos ellos
descritos en un único programa, llamado programa principal. Cuando se habla de
modularidad, consiste en estructurar el programa principal en módulos más
pequeños llamados subprogramas o subrutinas. Un subprograma es un conjunto
de sentencias de un programa que realizan una determinada tarea y que pueden
ser ejecutadas desde más de un punto del programa principal. Cuando termine de
ejecutarse el subprograma continúan procesándose las instrucciones siguientes
del programa.
Una subrutina es como un boomerang: va, realiza lo que tenga que hacer y
regresa al punto de partida. Su estructura básicamente es la de cualquier
programa, con las diferencias lógicas en la parte inicial y final. A su vez, un
subprograma puede estar compuesto por varios subprogramas. Están descritos
fuera del programa principal.
Ejemplos de llamadas a subprogramas en distintos lenguajes:
• DO
• GOSUB
• PERFORM
• CALL
Los nombres de los subprogramas los escribiremos en minúsculas con la inicial en

mayúsculas, para una mayor legibilidad del programa. A la hora de nombrarlos,
deben cumplir la normativa de las variables, es decir, deben empezar con una
letra y el resto de los caracteres, puede ser una combinación de números, letras y
el guión, pero no puede contener espacios en blanco. El número de
subprogramas que habrá dentro de cada programa será elección nuestra en
función de la complejidad del ejercicio. La función que deben cumplir los
subprogramas es la de conseguir la estructuración del programa y facilitar la tarea
en su construcción y simplificar al máximo las posibles modificaciones posteriores
en el programa. Otras de las misiones de los subprogramas es la de evitar la
repetición de instrucciones dentro de un programa, estas instrucciones se escriben
en un subprograma. Este subprograma es llamado, ejecutado, las veces que
haga falta. Así, las instrucciones que lo componen sólo están escritas una vez,
necesitando menos cantidad de memoria para almacenar el programa.
88
4.13.2. Tipos de Subprogramas.
Subrutinas
Las subrutinas son bloques de instrucciones que son llamadas bajo una etiqueta
de llamada (LABEL) y retornan al punto dónde fueron llamadas por una instrucción
de retorno (RETURN). Normalmente la estructura de este tipo de subprogramas
es como sigue:
Algoritmo Principal();
var
...
Inicio
...
Llamar ETIQUETA_SUBRUTINA;
...
fin.
ETIQUETA_SUBRUTINA:
<instrucción_1>
<instrucción_2>
...
<instrucción_N>
devolver;
Nótese que el llamado se hace con la palabra reservada Llamar la cual llama la
etiqueta definida en la cabecera del subprograma después del fin del programa
principal. Nótese también que la subrutina termina con la etiqueta devolver, la
cual permite establecer el fin del subprograma y continuar con la siguiente línea de
código de dónde fue llamada la subrutina.
Aunque los lenguajes de programación aún permiten implementar las llamadas a

subrutinas 4, en este texto no se tendrá en cuenta sino sólo para aspectos teóricos,
puesto que el lenguaje C escogido para la implementación de los programas en el
libro aunque permite implementarlas, posee un manejo de funciones
suficientemente poderoso como para no atreverse a realizar un llamado a
subrutina.
Funciones y Procedimientos
Una función es una parte de código independiente del programa principal y de
otras funciones, que puede ser llamada enviándole unos datos (o sin enviarle
4
Algunos autores consideran los llamados a subrutinas (GO TO) como una falta de habilidad del
programador para resolver el problema con las herramientas de la programación estructurada y
modular.
89
nada), para que realice una determinada tarea y/o proporcione unos resultados.
Los procedimientos en su definición son similares a las funciones, pero se
diferencian en que éstos no devuelven información por si mismos. Aunque más
adelante se vera que los procedimientos y las funciones pueden afectar variables
del programa principal por medio de una técnica llamada parámetros por
referencia.
Utilidad de las funciones

Parte esencial del correcto diseño de un programa de ordenador es su
modularidad, esto es su división en partes más pequeñas de finalidad muy
concreta. Las funciones facilitan el desarrollo y mantenimiento de los programas,
evitan errores, y ahorran memoria y trabajo innecesario. Una misma función puede
ser utilizada por diferentes programas, y por tanto no es necesario rescribirla.
Además, una función es una parte de código independiente del programa principal
y de otras funciones, manteniendo una gran independencia entre las variables
respectivas, y evitando errores y otros efectos colaterales de las modificaciones
que se introduzcan.
Mediante el uso de funciones se consigue un código limpio, claro y elegante. La

adecuada división de un programa en funciones constituye un aspecto
fundamental en el desarrollo de programas de cualquier tipo. Las funciones, ya
compiladas, pueden guardarse en librerías. Las librerías son conjuntos de
funciones compiladas, normalmente con una finalidad análoga o relacionada, que
se guardan bajo un determinado nombre listas para ser utilizadas por cualquier
usuario.
Ejemplo de un Diseño de un Programa Modular

Se desea construir una aplicación que permita realizar las operaciones
matemáticas básicas dado dos números enteros. Además se desea tener una
muy buena presentación de la aplicación, en la cual se definan ventanas de
impresión, animaciones de espera. Los pasos a seguir para el análisis del
problema son los siguientes:
1. Subdividir el problema en pequeños problemas.

2. Agrupar los subproblemas en conjuntos según su afinidad.
3. Determinar el esquema de implementación y llamado de las funciones y
procedimientos.
Siguiendo los paso anteriores tenemos:

1. Se deben realizar operaciones de Suma(ent1, ent2), Resta(ent1,ent2),
Multiplicar(ent1,ent2) y Dividir(ent1,ent2), por otro lado se requiere buena
presentación y esto incluye operaciones como: Ventana(x,y,x1,y1) y
Animar().
90
2. Los problemas anteriores se pueden agrupar a su vez en un grupo de
funciones matemáticas y otro de funciones de presentación.
3. Finalmente el esquema de solución podría ser el siguiente:
Incluir Matemática;
Incluir Presentación;
Programa Principal
Var
entero: a,b,Op;
Inicio
Librería Matemática Ventana(5,510,10); Librería de Presentación
Funcion Suma(a,b) Entrar a,b; Entrar Op Procedimiento Ventana (x,y,x1,y1)
Inicio En caso (Op) Inicio
Retornar(a+b); 0: Sumar(a,b) ....
Fin 1: Restar(a,b) Fin
Funcion Resta(a,b) 2: Multiplicar(a,b) Procedimiento Animar (x,y,x1,y1)
Inicio 3: Dividir(a,b) Inicio
Retornar(a-b); ....
Fin Fin
Funcion Multiplicar(a,b) Funcion TipoLetra (...)
Inicio Inicio
Retornar(a*b); ....
Fin Fin
Funcion Dividir(a,b)
Retornar(a/b);
nicio
La solución al problema anterior se podía haber planteado también con las

funciones sobre el mismo programa principal y realizando un llamado a las
funciones y procedimientos desde el mismo archivo. La estructuración anterior
permite independizar las funciones del programa principal y permitir que éstas
puedan ser utilizadas por otros programas. Por otro lado permite ocultar detalles
de implementación de las funciones a los usuarios de las librerías.
Definición de funciones y procedimientos

La definición de una función consiste en la definición del código necesario para
que ésta realice las tareas para las que ha sido prevista. La definición de una
función se puede realizar en el mismo archivo después de la terminación del
programa principal, una práctica adecuada para la modularidad es definir las
funciones en alguno de los archivos que forman parte del programa. La forma
general de la definición de una función es la siguiente:
funcion nombre_funcion(lista de argumentos con tipos):Tipov_retorno

var declaración de variables y/o de otras funciones
codigo ejecutable
devolver (expresión);
fin_funcion
91
La definición de un procedimiento es de la siguiente forma:
Procedimiento nombre_proceminiento(lista de argumentos con tipos)

var declaración de variables y/o de otras funciones
codigo ejecutable
fin_procedimiento
La primera línea recibe el nombre de encabezamiento (header) y el resto de la

definición –encerrado entre llaves– es el cuerpo (body) de la función5. Cada
función puede disponer de sus propias variables, declaradas al comienzo de su
código. Estas variables, por defecto, son de tipo local, es decir, sólo son visibles
dentro del bloque en el que han sido definidas, se crean cada vez que se ejecuta
la función y permanecen ocultas para el resto del programa. Si estas variables de
definen como estaticas, conservan su valor entre distintas llamadas a la función.
También pueden hacerse visibles a la función variables globales definidas en
antes de iniciar el programa principal o de otros ficheros si se han definido como
externas.
El código ejecutable es el conjunto de instrucciones que deben ejecutarse cada

vez que la función es llamada. La lista de argumentos con tipos, también llamados
argumentos formales, es una lista de declaraciones de variables, precedidas por
su tipo correspondiente separadas por comas (,). Los argumentos formales son la
forma más natural y directa para que la función reciba valores desde el programa
que la llama, correspondiéndose en número y tipo con otra lista de argumentos -
los argumentos actuales- en el programa que realiza la llamada a la función. Los
argumentos formales son declarados en el encabezamiento de la función, pero no
pueden ser inicializados en él.
Los parámetros formales a su vez pueden ser de dos tipos: pará metros por valor
o parámetros por referencia , esto significa que los primeros crean una copia de
los datos de los parámetros actuales y son variables locales a la función y los
segundos se apuntan a la variable que hizo el llamado actual desde el programa
principal, permitiendo así que cualquier modificación que se realice a estas
variables sea visto en las variables del programa principal, Esta característica de
los parámetros por referencia envía información en las variables de la función a las
variables del programa principal al modificar su valor en cuerpo de la función. En
pseudocódigo se antepone la palabra reservada var antes de la definición del
parámetro para indicar que este parámetro es por referencia, si se omite se asume
que el llamado es por valor.
Cuando una función es ejecutada, puede devolver al programa que la ha llamado

un valor (el valor de retorno) (excepto los procedimientos), cuyo tipo debe ser
especificado en el encabezamiento de la función (si no se especifica, se supone
5
En adelante se hablará de función para hacer referencia a funciones y procedimientos, a menos
que se nombre el procedimiento explícitamente.
92
por defecto el tipo entero). En C si no se desea que la función devuelva ningún
valor, el tipo del valor de retorno deberá ser void, para el caso se convertirá en
procedimiento.
La sentencia volver (return en C) permite devolver el control al programa que

llama. Puede haber varias sentencias return en una misma función. Si no hay
ningún return, el control se devuelve cuando se llega al final del cuerpo de la
función. La palabra clave return puede ir seguida de una expresión, en cuyo caso
ésta es evaluada y el valor resultante devuelto al programa que llama como valor
de retorno (si hace falta, con una conversión previa al tipo declarado en el
encabezamiento). Los paréntesis que engloban a la expresión que sigue a return
son optativos.
El valor de retorno es un valor único: no puede ser un vector o una matriz, aunque
sí un puntero a un vector o a una matriz. Sin embargo, el valor de retorno sí puede
ser una estructura, que a su vez puede contener vectores y matrices como
elementos miembros.
Funciones en Lenguaje C
Funciones
Descripción En este apartado se presentarán todas las modalidades y posibilidades que se
pueden presentar en la implementación de funciones utilizando el lenguaje C.
La programación modular también se puede ver como una programación Top –Down. De esta
forma el programador, sólo se las tendrá que ver con diminutas piezas de programa, de pocas
líneas, cuya escritura y corrección posterior es una tarea simple. Tal es el criterio con que está
estructurado el lenguaje C, donde una de sus herramientas fundamentales son las funciones.
Todo compilador comercial trae una gran cantidad de Librerías de toda índole, matemáticas, de
entrada - salida, de manejo de textos, de manejo de gráficos, etc, que solucionan la mayor parte de
los problemas básicos de programación.
Sin embargo será inevitable que en algún momento tenga que crear mis propias funciones, las
reglas para ello son las que desarrollaremos en este capítulo.
Comencemos con algunos conceptos básicos: para hacer que las instrucciones contenidas en una
función, se ejecuten en determinado momento, es necesario escribir su nombre como una línea de
sentencia en mi programa.
Convencionalmente en C los nombres de las funciones se escriben en minúscula y siguen las

reglas dadas anteriormente para los de las variables, pero deben ser seguidos, para diferenciarlas
de aquellas por un par de paréntesis. Dentro de estos paréntesis estarán ubicados los datos que
se les pasan a las funciones. Está permitido pasarles uno, ninguno ó una lista de ellos separados
por comas, por ejemplo: pow10( a ), getch(), strcmp( s1, s2 ) .
93
Un concepto sumamente importante es que los argumentos que se les envían a las funciones son
los VALORES de las variables y NO las variables mismas. En otras palabras, cuando se invoca
una función de la forma pow10( a ) en realidad se está copiando en el "stack" de la memoria el
valor que tiene en ese momento la variable a, la función podrá usar este valor para sus cálculos,
pero está garantizado que los mismos no afectan en absoluto a la variable en sí misma.
Como veremos más adelante, es posible que una función modifique a una variable, pero para ello,
será necesario comunicarle la DIRECCION EN MEMORIA de dicha variable.
Las funciones pueden ó no devolver valores al programa invocante. Hay funciones que tan sólo
realizan acciones, como por ejemplo clrscr(), que borra la pantalla de video, y por lo tanto no
retornan ningún dato de interés; en cambio otras efectúan cálculos, devolviendo los resultados de
los mismos.
La invocación a estos dos tipos de funciones difiere algo, por ejemplo escribiremos:
clrscr() ;
c = getch() ;
donde en el segundo caso el valor retornado por la función se asigna a la variable c. Obviamente
ésta deberá tener el tipo correcto para alojarla.
Declaración De Funciones
Antes de escribir una función es necesario informarle al Compilador los tamaños de los valores que
se le enviarán en el stack y el tamaño de los valores que ella retornará al programa invocante.
Estas informaciones están contenidas en la DECLARACION del PROTOTIPO DE LA FUNCION.
Formalmente dicha declaración queda dada por :

tipo del valor de retorno nombre_de_la_función(lista de tipos de parámetros)
Pongamos algunos ejemplos:

float mi_funcion(int i, double j ) ;
double otra_funcion(v oid) ;
otra_mas(long p) ;
void la_ultima(long double z, char y, int x, unsigned long w) ;
El primer término del prototipo da como hemos visto el tipo del dato retornado por la función; en
caso de obviarse el mismo se toma, por omisión, el tipo int. Sin embargo, aunque la función
devuelva este tipo de dato, para evitar malas interpretaciones es conveniente explicitarlo.
Como que el "default" del tipo de retorno es el int, debemos indicar cuando la función NO retorna
nada, esto se realiza por medio de la palabra VOID ( sin valor). De la misma manera se actúa,
cuando no se le enviarán argumentos.
Más adelante se profundizará sobre el tema de los argumentos y sus características. La

declaración debe anteceder en el programa a la definición de la función. Es normal, por razones
de legibilidad de la documentación, encontrar todas las declaraciones de las funciones usadas en
el programa, en el HEADER del mismo, junto con los include de los archivos *.h que tienen los
prototipos de las funciones de Librería. Si una ó más de nuestras funciones es usada
habitualmente, podemos disponer su prototipo en un archivo de texto, e incluirlo las veces que
necesitemos.
94
Definición de las Funciones
La definición de una función puede ubicarse en cualquier lugar del programa, con sólo dos
restricciones: debe hallarse luego de dar su prototipo, y no puede estar dentro de la definición de
otra función (incluida main()). Es decir que a diferencia de Pascal, en C las definiciones no pueden
anidarse.
NOTA: no confundir definición con llamada; una función puede llamar a tantas otras como desee .
La definición debe comenzar con un encabezamiento, que debe coincidir totalmente con el
prototipo declarado para la misma, y a continuación del mismo, encerradas por llaves se escribirán
las sentencias que la componen; por ejemplo:
include <stdio.h>
float mi_funcion(int i, double j ); /* DECLARACION observe que termina en ";" */
main()
{
float k ;
int p ;
double z ;
...........
k = mi_funcion( p, z ); /* LLAMADA a la función */
...........
} /* fin de la función main() */
float mi_funcion(int i, double j ) /* DEFINICION observe que NO lleva ";" */

{
float n
...................
printf("%d", i ); /* LLAMADA a otra función */
...................
return ( 2 * n ); /* RETORNO devolviendo un valor float */
}
Modalidades de Funciones
1) Funciones que no retornan valor y reciben parámetros:
#include <stdio.h>
void pausa(void) ;
main()
{
int contador = 1;
printf("VALOR DEL CONTADOR DENTRO DEL while \n");
while (contador <= 10)
{
if(contador == 5 )
pausa();
printf("%d\n", contador++);
}
pausa() ;
printf("VALOR DEL CONTADOR LUEGO DE SALIR DEL while: %d", contador) ;
return 0;
}
95
void pausa(void)
{
char c ;
printf("\nAPRIETE ENTER PARA CONTINUAR ") ;
while( (c = getchar()) != '\n') ;
}
Analicemos lo hecho, en la segunda línea hemos declarado la función pausa, sin valor de retorno
ni parámetros.
Luego esta es llamada dos veces por el programa principal, una cuando contador adquiere el valor
de 5 (antes de imprimirlo) y otra luego de finalizar el ciclo.
Posteriormente la función es definida. El bloque de sentencias de la misma está compuesto, en

este caso particular, por la definición de una variable c, la impresión de un mensaje de aviso y
finalmente un while que no hace nada, solo espera recibir un carácter igual a <ENTER>.
En cada llamada, el programa principal transfiere el comando a la función, ejecutándose hasta que
ésta finalice su propia secuencia de instrucciones. Al finalizar la función esta retorna el comando al
programa principal, continuándose la ejecución por la instrucción que sucede al llamado.
Si bien las funciones aceptan cualquier nombre, es una buena técnica de programación nombrarlas
con términos que representen, aunque sea vagamente, su operatoria.
Se puede salir prematuramente de una función void mediante el uso de RETURN, sin que este sea
seguido de ningún parámetro ó valor.
2) Funciones que retornan valor:

#include <stdio.h> while ((c != 'n') && (c != 's'));
#include <conio.h> return (c == 'n');
#define FALSO 0 }
#define CIERTO 1 int lea_char(void)
int finalizar(void); {
int lea_char(void) ; int j ;
main() if( (j = getch()) >>= 'A' && j <<= 'Z' )
{ return( j + ( 'a' - 'A') ) ;
int i = 0; else
int fin = FALSO; return j ;
printf("Ejemp lo de Funciones que retornan valor\n"); }
while (fin == FALSO) {
i++;
printf("i == %d\n", i);
fin = finalizar();
}
printf("\n\nFIN DEL PROGRAMA........");
return 0;
}
int finalizar(void)
{
int c;
printf("Otro número ? (s/n) ");
do {
c = lea_char() ;
}
96
Analicemos paso a paso el programa anterior; las dos primeras líneas incluirán en el programa los
prototipos de las funciones de librería usadas, ( en este caso printf() y getch() ). En las dos
siguientes damos nom bres simbólicos a dos constantes que usaremos en las condiciones lógicas y
posteriormente damos los prototipos de dos funciones que hemos creado. Podrían haberse
obviado, en este caso particular, estas dos últimas declaraciones, ya que ambas retornan un int
(default), sin embargo el hecho de incluirlas hará que el programa sea más fácilmente
comprensible en el futuro.
Comienza luego la función main(), inicializando dos variables, i y fin, donde la primera nos servirá
de contador y la segunda de indicador lógico. Luego de imprimir el rótulo del programa, entramos
en un loop en el que permaneceremos todo el tiempo en que fin sea FALSO. Dentro de este loop,
incrementamos el contador, lo imprimimos, y asignamos a fin un valor que es el retorno de la
función finalizar(). Esta asignación realiza la llamada a la función, la que toma el control del flujo
del programa, ejecutando sus propias instrucciones.
Saltemos entonces a analizar a finalizar(). Esta define su variable propia, c, (de cuyas propiedades
nos ocuparemos más adelante) y luego entra en un do-while, que efectúa una llamada a otra
función, lea_char(), y asigna su retorno a c iterando esta operativa si c no es 'n' ó 's', note que: c !=
'n' && c != 's' es equivalente a: !( c == 'n' || c == 's' ).
La función lea_char() tiene como misión leer un carácter enviado por el teclado, ( lo realiza dentro
de la expresión relacional del IF ) y salvar la ambigüedad del uso de mayúsculas ó minúsculas en
las respuestas, convirtiendo las primeras en las segundas. Es fácil de ver que, si un carácter esta
comprendido entre A y Z, se le suma la diferencia entre los ASCII de las minúsculas y las
mayúsculas ( 97 - 65 = 32 ) para convertirlo, y luego retornarlo al invocante. Esta conversión fué
incluida a modo de ejemplo solamente, ya que existe una de Librería, tolower() declarada en
ctype.h, que realiza la misma tarea.
Cuando lea_char() devuelva un carácter n ó s, se saldrá del do-while en la función finalizar() y se

retornará al programa principal, el valor de la comparación lógica entre el contenido de c y el ASCII
del carácter n. Si ambos son iguales, el valor retornado será 1 (CIERTO) y en caso contrario 0 (
FALSO ) .
Mientras el valor retornado al programa principal sea FALSO, este permanecerá dentro de su while
imprimiendo valores sucesivos del contador, y llamadas a las funciones, hasta que finalmente un
retorno de CIERTO ( el operador presionó la tecla n) hace terminar el loop e imprimir el mensaje de
despedida.
Nota: preste atención a que en la función finalizar() se ha usado un do -while .¿Cómo modificaría el
programa para usar un while?. En la función lea_char se han usado dos returns, de tal forma que
ella sale por uno u otro. De esta manera si luego de finalizado el else se hubiera agregado otra
sentencia, esta jamás sería ejecutada.
En el siguiente ejemplo veremos funciones que retornan datos de tipo distinto al int.
Debemos presentar antes, otra función muy común de entrada de datos: scanf(), que nos permitirá
leer datos completos (no solo caracteres) enviados desde el teclado, su expresión formal es algo
similar a la del printf() ,
scanf("secuencia de control", dirección de la variable ) ;
Donde en la secuencia de control se indicará que tipo de variable se espera leer, por ejemplo:
%d si se desea leer un entero decimal (int); %o octal; %x hexadecimal; %c carácter; %f leerá
un float; %ld leerá un long int; %lf leerá un double; %Lf leerá un long double.
97
Por "dirección de la variable" deberá entenderse que se debe indicar, en vez del nombre de la
variable en la que se cargará el valor leído, la dirección de su ubicación en la memoria de la
máquina. Esto suena sumamente apabullante, pero por ahora solo diremos, (más adelante
abundaremos en detalles ) que para ello es necesario simplemente anteponer el signo & al nombre
de la misma.
Así, si deseo leer un entero y guardarlo en la variable "valor_leido" escribiré:

scanf("%d",&valor_leido); en cambio si deseara leer un entero y un valor de punto flotante será:
scanf("%d %f", &valor_entero, &valor_punto_flotante);.
El tipo de las variables deberá coincidir EXACTAMENTE con los expresados en la secuencia de
control, ya que de no ser así, los resultados son impredecibles.
Por supuesto esta función tiene muchísimas más opciones, ( consulte el Manual de Librerías de su
Compilador, si tiene curiosidad ) sin embargo, por simplicidad, por ahora nos conformaremos con
las antedichas.
El prototipo de scanf() esta declarado en stdio.h .
Usaremos también otra función, ya citada, clrscr(). Recordemos que esta es solo válida para
máquinas tipo PC compatibles y no corre bajo Windows.
Encaremos ahora un programa que nos presente primero, un menú para seleccionar la conversión
de ºC a Fahrenheit ó de centímetros a pulgadas, hecha nuestra elección, nos pregunte el valor a
convertir y posteriormente nos de el resultado.
Si suponemos que las funciones que usaremos en el programa serán frecuentemente usadas,
podemos poner las declaraciones de las mismas, así como todas las constantes que usen, en un
archivo texto, por ejemplo convers.h. Este podrá ser guardado en el subdirectorio donde están
todos los demás (INCLUDE) ó dejado en el directorio activo, en el cual se compila el programa
fuente de nuestro problema. Para variar, supongamos que esto último es nuestro caso.
CONV ERS.H
-----------------------------------------------------------------------------------------------------------------------------------
#include <conio.h>
#define FALSO 0
#define CIERTO 1
#define CENT_POR_INCH 25.4
void pausa(void);
void mostrar_menu(void);
int seleccion(void);
void cm_a_pulgadas(void);
void grados_a_fahrenheit(void);
double leer_valor(void);
---------------------------------------------------------------------------------------------------------------------------------
Vemos que un Header puede incluir llamadas a otros (en este caso conio.h). Hemos puesto
también la definición de todas las constantes que usaran las funciones abajo declaradas. De
dichas declaraciones vemos que usaremos funciones que no retornan nada, otra que retorna un
entero y otra que devuelve un double.
Veamos ahora el desarrollo del programa en sí. Observe que la invocación a convers.h se hace
con comillas, por haber decidido dejarlo en el directorio activo.
98
#include <stdio.h>
#include "convers.h"
void main() {
int fin = FALSO;
while (!fin) {
mostrar_menu();
switch(seleccion()) {
case 1: cm_a_pulgadas();
break;
case 2: grados_a_fahrenheit();
break;
case 3: fin = CIERTO;
break;
default: printf("\n¡Error en la Seleccion!\a\a\n");
pausa() ;
}
}
}
/* Funciones */
void pausa(void)
{
char c = 0;
printf("\n\n\nPRESIONE ENTER PARA CONTINUAR ") ;
while( (c = getch()) != '\r') ;
}
void mostrar_menu (void)
{
clrscr();
printf("\n Menu\n");
printf("---------------------------\n");
printf("1: Centimetros a pulgadas\n");
printf("2: Celsius a Fahrenheit\n");
printf("3: Terminar\n");
}
int seleccion(void)
{
printf("\nEscriba el número de su Selección: ");
return (getche() - '0');
}
void cm_a_pulgadas (void)
{
double centimetros; /* Guardará el valor pasado por leer_valor() */
double pulgadas ; /* Guardará el valor calculado */
printf("\nEscriba los Centimetros a convertir: ");
centimetros = leer_valor();
pulgadas = centimetros * CENT_POR_INCH;
printf("%.3f Centimetros = %.3f Pulgadas\n", centimetros, pulgadas);
pausa() ;
}
void grados_a_fahrenheit(void)
{
double grados; /* Guardará el valor pasado por leer_valor() */
double fahrenheit ; /* Guardará el valor calculado */
printf("\nEscriba los Grados a convertir: ");
grados = leer_valor();
fahrenheit = (((grados * 9.0)/5.0) + 32.0) ;
printf("%.3f Grados = %.3f Fahrenheit", grados, fahrenheit);
pausa();
}
double leer_valor(void)
{
double valor; /* Variable para guardar lo leido del teclado */
scanf("%lf", &valor);
return valor;
}
99
Veamos que hemos hecho: primero incluimos todas las definiciones presentes en el archivo
convers.h que habíamos previamente creado. Luego main() entra en un loop, que finalizará
cuando la variable fin tome un valor CIERTO, y dentro del cual lo primero que se hace es llamar a
mostrar_menú(), que pone los rótulos de opciones.
Luego se entra en un SWITCH que tiene como variable el retorno de la función selección()
(recuerde que tiene que ser un entero), según sea éste se saldrá por alguno de los tres CASE.
Observe que selección() lee el teclado mediante un getche(), (similar a getch() antes descripta,
pero con la diferencia que aquella hace eco del caracter en la pantalla) y finalmente devuelve la
diferencia entre el ASCII del número escrito menos el ASCII del número cero, es decir, un entero
igual numéricamente al valor que el operador quiso introducir.
Si este fue 1, el SWITCH invoca a la función cm_a_pulgadas() y en caso de ser 2 a

grados_a_fahrenheit().
Estas dos últimas proceden de igual manera: Indican que se escriba el dato y pasan el control a
leer_valor(), la que mediante scanf() lo hace, retornando en la variable valor, un double, que luego
es procesado por aquellas convenientemente. Como hasta ahora la variable fin del programa
principal no ha sido tocada, y por lo tanto continua con FALSO ,la iteración del while sigue
realizándose, luego que se ejecuta el BREAK de finalización del CASE en cuestión. En cambio, si
la selección() hubiera dado un resultado de tres, el tercer case, la convierte en CIERTO, con lo que
se finaliza el WHILE y el programa termina.
3) Ámbito de las Variables
VARIABLES GLOBALES
Hasta ahora hem os diferenciado a las variable según su "tipo" (int, char double, etc), el cual se
refería, en última instancia, a la cantidad de bytes que la conformaban. Veremos ahora que hay
otra diferenciación de las mismas, de acuerdo a la clase de memoria en la que residen.
Si definimos una variable AFUERA de cualquier función (incluyendo esto a main()), estaremos
frente a lo denominado VARIABLE GLOBAL. Este tipo de variable será ubicada en el segmento de
datos de la memoria utilizada por el programa, y existirá todo el tiempo que esté ejecutándose
este.
Este tipo de variables son automáticamente inicializadas a CERO cuando el programa comienza a
ejecutarse.
Son accesibles a todas las funciones que estén declaradas en el mismo, por lo que cualquiera de
ellas podrá actuar sobre el valor de las mismas. Por ejemplo:
#include <stdio.h>
double una_funcion(void);
double variable_global ;
main() {
double i ;
printf("%f", variable_global ); /* se imprimirá 0 */
i = una_funcion() ;
printf("%f", i ); /* se imprimirá 1 */
variable_global += 1 ;
return 0 ;
}
double una_funcion(void)
{
return( variable_global += 1) ;
}
100
Observemos que la variable_global está definida afuera de las funciones del programa, incluyendo
al main(), por lo que pertenece a TODAS ellas. En el primer printf() del programa principal se la
imprime, demostrándose que está automáticamente inicializada a cero.
Luego es incrementada por una_funcion() que devuelve además una copia de su valor, el cual es
asignado a i ,la que, si es impresa mostrará un valor de uno, pero también la variable_global ha
quedado modificada, como lo demuestra la ejecución de la sentencia siguiente. Luego main()
también modifica su valor , lo cual es demostrado por el printf() siguiente.
Esto nos permite deducir que dicha variable es de uso público, sin que haga falta que ninguna
función la declare, para actuar sobre ella.
Puede resultar muy difícil evaluar su estado en programas algo complejos, con múltiples llamados
condicionales a funciones que las afectan, dando comúnmente origen a errores muy engorrosos de
corregir, por ello se debe tener restringido su uso sólo a casos en lo que es explícitamente
necesario.
VARIABLES LOCALES
A diferencia de las anteriores, las variables definidas DENTRO de una función, son denominadas
VARIABLES LOCALES a la misma, a veces se las denomina también como AUTOMATICAS, ya
que son creadas y destruidas automáticamente por la llamada y el retorno de una función,
respectivamente.
Estas variables se ubican en la pila dinámica (stack) de memoria, destinándosele un espacio en la

misma cuando se las define dentro de una función, y borrándose cuando la misma devuelve el
control del programa, a quien la haya invocado.
Este método permite que, aunque se haya definido un gran número de variables en un programa,
estas no ocupen memoria simultáneamente en el tiempo, y solo vayan incrementando el stack
cuando se las necesita, para luego, una vez usadas desaparecer, dejando al stack en su estado
original.
El identificador ó nombre que se la haya dado a una variable es sólo relevante entonces, para la
función que la haya definido, pudiendo existir entonces variables que tengan el mismo nombre,
pero definidas en funciones distintas, sin que haya peligro alguno de confusión.
La ubicación de estas variables locales, se crea en el momento de correr el programa, por lo que
no poseen una dirección prefijada, esto impide que el compilador las pueda inicializar previamente.
Recuérdese entonces que, si no se las inicializa expresamente en el momento de su definición, su
valor será indeterminado (basura).
VARIABLES LOCALES ESTATICAS

Las variables locales vistas hasta ahora, nacen y mueren con cada llamada y finalización de una
función, sin embargo muchas veces sería útil que mantuvieran su valor, entre una y otra llamada a
la función sin por ello perder su ámbito de existencia, es decir seguir siendo locales sólo a la
función que las defina. En el siguiente ejemplo veremos que esto se consigue definiendo a la
variable con el prefacio static.
VARIABLES DE REGISTRO
Otra posibilidad de almacenamiento de las variables locales es, que en vez de ser mantenidas en
posiciones de la memoria de la computadora, se las guarde en registros internos del
Microprocesador que conforma la CPU de la misma.
101
De esta manera el acceso a ellas es mucho más directo y rápido, aumentando la velocidad de
ejecución del programa. Se suelen usar registros para almacenar a los contadores de los FOR,
WHILE, etc.
Lamentablemente, en este caso no se puede imponer al compilador, este tipo de variable, ya que
no tenemos control sobre los registros libres en un momento dado del programa, por lo tanto se
SUGIERE, que de ser posible, ubique la variable del modo registro. El prefacio en éste caso será:
register int var_reg ;
Hay que recalcar que esto es sólo válido para variables LOCALES, siendo imposible definir en un
registro a una global. Por otra parte las variables de registro no son accesibles por dirección, como
se verá más adelante
VARIABLES EXTERNAS
Al DEFINIR una variable, como lo hemos estado haciendo hasta ahora, indicamos al compilador
que reserve para la misma una determinada cantidad de memoria, (sea en el segmento de
memoria de datos, si es global ó en el stack, si es local), pero debido a que en C es normal la
compilación por separado de pequeños módulos, que componen el programa completo, puede
darse el caso que una función escrita en un archivo dado, deba usar una variable global definida
en otro archivo. Bastará para poder hacerlo, que se la DECLARE especificando que es EXTERNA
a dicho módulo, lo que implica que está definida en otro lado.
Supongamos que nuestro programa está compuesto por sólo dos módulos: mod_prin.c y
mod_sec.c los cuales se compilarán y enlazarán juntos, por medio del compilador y el linker, por
ejemplo corriendo: bcc mod_prin.c mod_sec.c si usaramos el compilador de Borland.
Si en el primer módulo (mod_prin.c) aparece una variable global, definida como: double var1 = 5 ;
El segundo módulo, ubicado en un archivo distinto de aquel, podrá reverenciarla mediante la
declaración de la misma : extern double var1 ;
Nótese que la inialización de la variable sólo puede realizarse en su DEFINICION y no en la

declaración. Esta última, no reserva memoria para la variable sino que sólo hace mención que la
misma ha sido definida en otro lado.
Será finalmente el Linker el que resuelva los problemas de direccionamiento de la variable al

encadenar los dos módulos compilados.
4) Argumentos y Parámetros de las Funciones

Supongamos que en un determinado programa debemos calcular repetidamente el valor medio de
dos variables, una solución razonable sería crear una función que realice dicho cálculo, y llamarla
cada vez que se necesite. Para ello será necesario, en cada llamada, pasarle los valores de las
variables para que calcule su valor medio. Esto se define en la declaración de la función
especificando, no solo su valor de retorno sino también el tipo de argumentos que recibe:
double valor_medio(double x, double y) ;
De esta declaración vemos que la función valor_medio recibe dos argumentos ( x e y ) del tipo
double y devuelve un resultado de ese mismo tipo.
Cuando definamos a la función en sí, deberemos incluir parámetros para que alberguen los valores
recibidos, así escribiremos:
102
double valor_medio(double x, double y )
{
return ( (x + y) / 2.0 )
}
NOTA: No es necesario que los NOMBRES de los parámetros coincidan con los declarados
previamente, es decir que hubiera sido equivalente escribir: double valor_medio(double a, double
b) etc, sin embargo es una buena costumbre mantenerlos igual. En realidad en la declaración de
la función, no es necesario incluir el nombre de los parámetros, bastaría con poner solo el tipo, sin
embargo es práctica generalizada, explicitarlos a fin de hacer más legible al programa.
Aquí estamos utilizando la sintaxis moderna del lenguaje C, pudiéndose encontrar en versiones
arcaicas, definiciones equivalentes como :
double valor_medio() ó double valor_medio(double, double)

double x; double x ;
double y; double y ;
{ {
............ ..............
Sin embargo es preferible utilizar la nomenclatura moderna, ya que esta facilita la rápida
comprensión del programa.
Veamos un ejemplo, para determinar el comportamiento de los parámetros, Supongamos desear

un programa que calcule el valor medio de dos variables incrementadas en un valor fijo, es decir:
( ( x + incremento ) + ( y + incremento ) ) / 2.0
Lo podríamos resolver de la siguiente forma :

#include <stdio.h>
/* Declaración de la función y el tipo de sus parámetros */
double valor_medio(double p_valor, double s_valor, double inc) ;
main()
{
double x, y, z, resultado ;
printf("Ingrese el primer valor: ") ;
scanf("%lf", &x ) ;
printf("\nIngrese el segundo valor: ");
scanf("%lf", &y ) ;
printf("\nIngrese el incremento : ");
scanf("%lf", &z) ;
resultado = valor_medio( x, y, z ); /* llamada a la función y
pasaje de argumentos */
printf("\n\nResultado de la operación: %lf", resultado) ;
printf("\n\nValor con que quedaron las variables: ") ;
printf("\n Primer valor : %lf ", x ) ;
printf("\n Segundo valor: %lf ", y ) ;
printf("\n Incremento : %lf ", z ) ;
}
/* Definición de la función y sus parámetros */
double valor_medio( double p_valor, double s_valor, double inc )
{
p_valor += inc ;
s_valor += inc ;
return ( (p_valor + s_valor ) / 2.0 ) ;
}
103
Veamos primero cual seria la salida de pantalla de este programa:
Ingrese el primer valor: [SUPONGAMOS ESCRIBIR: 10.0]

Ingrese el segundo valor: [ " " : 8.0]
Ingrese el incremento: [ " " : 2.0]
Resultado de la operación: 11.000000
Valor con que quedaron las variables:
Primer valor : 10.000000
Segundo valor: 8.000000
Incremento : 2.000000
Vemos que luego de obtenidos, mediante scanf(), los tres datos x, y, z, los mismos son pasados a
la función de calculo en la sentencia de asignación de la variable resultado. La función inicializa
sus parámetros ( p_valor, s_valor e inc ) con los valores de los argumentos enviados ( x, y, z ) y
luego los procesa. La única diferencia entre un argumento y una variable local, es que ésta no es
inicializada automáticamente, mientras que aquellos lo son, a los valores de los argumentos
colocados en la expresión de llamada.
Acá debemos remarcar un importante concepto: éste pasaje de datos a las funciones, se realiza
COPIANDO el valor de las variables en el stack y No pasándoles las variables en sí. Esto se
denomina: PASAJE POR VALOR y garantiza que dichas variables no sean afectadas de ninguna
manera por la función invocada. Una clara prueba de ello es que, en la función valor_medio() se
incrementa p_valor y s_valor, sumándoseles el contenido del parámetro inc. Sin embargo cuando,
luego de retornar al programa principal, imprimimos las variables cuyos valores fueron enviados
como parámetros, vemos que conservan sus valores iniciales. Veremos más adelante que otras
estructuras de datos pueden ser pasadas a las funciones por direcciones en vez de por valor,
pudiendo aquellas modificarlas a gusto.
Debe aclararse que, el pasaje de argumentos, es también una OPERACION, por lo que las
variables pasadas quedan afectadas por las reglas de Conversión Automática de Tipo. Como
ejemplo, si x hubiera sido definida en la función main() como int, al ser pasada como argumento a
valor_medio() sería promovida a double. Especial cuidado debe tenerse entonces con los errores
que pueden producirse por redondeo ó truncamiento, siendo una buena técnica de programación
hacer coincidir los tipos de los argumentos con los de los parámetros.
Ejemplos Formales de Funciones y Procedimientos

Para una demostración sencilla de la implementación de los subprogramas, nos
concentraremos en desarrollar las funciones y procedimientos solos como tal y
posteriormente se presentará un ejemplo completo que permite hacer el llamado
de estas funciones y procedimientos. Note que la plantilla tiene un pequeño
cambio: Los datos de entrada equivalen a los parámetros formales y datos de
salida equivalen a los datos que retorna la función o el procedimiento, ya sea
en el nombre de la función o en los parámetros que se cambian. Para mayor
facilidad en la presentación de los ejemplos no se llenará la plantilla de manera
rigurosa. En algunos casos se presentará completa en otros el sólo pseudocódigo
o en ocasiones solamente la implementación en lenguaje C sin realizar las
pruebas. Estos elementos quedan como ejercicio al estudiante siguiendo los
lineamientos ya planteados en capítulos anteriores.
104
Código: 21 Nombre Función Valor Absoluto
Problema Como ejemplo supóngase que se va a calcular en contadas ocasiones el
valor absoluto de variables de tipo real.
Parámetros floNumero: Número Flotante al cual se le calculará el
Formales valor absoluto
Retorno Valor_Abs: Valor flotante en valor absoluto
Datos Auxiliares
ü Se recibe el valor a cambiar en floNumero.
ü Si es negativo el número se devuelve su valor
Descripción:
cambiándole el signo. Si no se devuelve el mismo
numero.
Fase de
Resolución
//Función que retorna el valor absoluto de un número real.
funcion Valor_Abs(real floNumero):real

si floNumero < 0 entonces
devolver ((-1)*floNumero);
sino
devolver (floNumero);
finsi
fin_funcion

// ___________________________________________________________
// Nombre: Valor_Abs
// Descripción: Devuelve el valor absoluto de un número Double.
Fase de // ___________________________________________________________
Implementación
double valor_abs(double x)
{
if (x < 0.0)
return -x;
else
return x;
}
Ejecución No se Realizo...
Ejemplo 21: Función Valor Absoluto
105
Código: 22 Nombre Función Factorial
Problema Desarrollar un programa que lea un número entero y calcule su factorial
mediante el llamado a una función recursiva.
Datos Entrada intDato: Número al cual se le calculará el factorial.
Datos de Salida dblFactorial: Valor flotante del factorial calculado.
Datos Auxiliares Se sabe que Factorial(n) = Factorial (n-1) * n
ü
Se pide el número entero a calcular el factorial.
Fase de ü
Se hace el llamado a la fu nción que calcula el
Descripción:
Resolución factorial.
ü Se imprime el resultado de la función.
No se realizó ...
No se realizo ...
106
Implementación // ___________________________________________________________
// Nombre: Factorial
// Descripción: Devuelve el Factorial de un número.
// ___________________________________________________________
#include <stdio.h>
#include <conio.h>
//Declaración adelantada de la función

long double Factorial(int intNumero);
void main(void)
{
int intDato;
long double dblFactorial;
//Limpiamos la pantalla
clrscr();
//Leemos el dato del numero a calcular el factorial

scanf(“%d”,intDato);
//Llamamos la función que calucula el factorial

dblFactorial = Factorial(intDato);
//Finalmente Imprimimos el resultado

printf(“\n %lg”,dblFactorial);
//Espera un caracter para permitir visializar

//el resultado en la consola.
getch();
}
//Declaración de la función. Note que la cabecera no

//tiene el punto y coma
long double Factorial(int intNumero)
{
if (intNumero == 1) return 1;
else return (n * Factorial(n-1));
}
Ejemplo 22: Función Factorial
107
Código: 23 Nombre Programa Matemático
Enunciado
Formulación Desarrollar un programa que realice las operaciones matemáticas básicas: Suma,
del Problema Resta, Multiplicación, División a través de programación modular. El programa
debe desplegar un menú con las operaciones. Las operaciones se deben realizar
utilizando números reales.
Los datos de entrada dependen del menú inicial y de las
funciones:
1) Sumar dos Números
2) Restar de Números
3) Multiplicar dos Números
Datos Entrada
4) Dividir dos Números.
5) Salir
Genéricamente todas las funciones recibirán dos números
flotantes los cuales serán operados entre si. La función de
División controla el error de división por cero.
suma: Si selecciona este elemento la salida será la suma
de los dos números presentados en un formato adecuado.
resta: Si selecciona este elemento la salida será la resta
de los dos números presentados en un formato adecuado.
multiplicación: Si selecciona este elemento la salida será
la multiplicación de los dos números presentados en un
Fase de Datos de Salida
formato adecuado.
Resolución división: Si selecciona este elemento la salida será la
división de los dos números presentados en un formato
adecuado. Si el usuario digita el segundo número igual a
cero se desplegará un mensaje diciendo que la división es
por cero.
Datos Auxiliares No hay.
ü Se presenta el menú de opciones.
ü Se realiza la operación que seleccione del menú.
Descripción: ü En todos los casos primero se piden los dos número
reales a operar.
ü Se imprime el resultado de la función utilizando un
formato adecuado.
No se realizó ...
No se realizo ...
108
Implementación El programa esta desarrollado utilizando el concepto de proyecto. Para esto existe un
archivo de proyecto el cual reúne los módulos en los que se divide la aplicación. A
continuación de presenta el módulo que contiene la lógica matemática.
MATEMATICA.H
#ifndef __MAT__H
#define __MAT__H
//Suma dos números reales
float suma(float floNum1, float floNum2,char * chaOper);
//Resta dos números reales
float resta(float floNum1, float floNum2,char * chaOper);
//Multiplica dos números reales
float multiplica(float floNum1, float floNum2,char * chaOper);
//Divide dos números reales
float divide(float floNum1, float floNum2,char * chaOper);
#endif
MATEMATICA.C
//---------------------------------------------------------------------------
#pragma hdrstop
//---------------------------------------------------------------------------
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include "matematica.h"
#pragma argsused
//Definiicion de los prototipos de Funciones
void pausa(void);
int seleccion(void);
float LeerNumeroFlo(void);
void LeerNumeros(float *floNumerUno, float *floNumeroDos);
void ImprimirResultado(const float,const float ,const float,const char *);
//Inicio del Programa Principal

int main(void)
{
int intfin = 0; //Definir el fin del menú
char *charOper=""; //Variable para la salida de información
float floNum1,floNum2; //Almacena los numeros operados
while (!intfin) {
mostrar_menu();
switch(seleccion()) {
case 1:
LeerNumeros (&floNum1, &floNum2);
ImprimirResultado(floNum1, floNum2,suma(floNum1, floNum2, charOper), charOper);
break;
case 2:
LeerNumeros(&floNum1, &floNum2);
ImprimirResultado(floNum1, floNum2,resta(floNum1,floNum2,charOper),charOper);
break;
case 3:
ImprimirResultado(floNum1, floNum2,multiplica(floNum1,floNum2,charOper),charOper);
break;
109
case 4:
ImprimirResultado(floNum1, floNum2,divide(floNum1,floNum2,charOper),charOper);
break;
case 5:
intfin = 1;
break;
default:
printf("\n¡Error en la Seleccion!\a\a\n");
pausa() ;
}
}
return 0;
}
//FUNCIONES INSERTADAS EN EL MISMO ARCHIVO PRINCIPAL

void pausa(void)
{
char c = 0;
printf("\n\n\nAPRIETE ENTER PARA CONTINUAR ") ;
while ( (c = getch()) != ' \r') ;
};
void mostrar_menu(void)
{
clrscr();
printf("\n Menu\n");
printf("---------------------------\n");
printf("1: Sumar dos Numeros \n");
printf("2: Restar dos Números \n");
printf("3: Multiplicar dos Números\n");
printf("4: Dividir dos Números \n");
printf("5: Salir\n");
};
int seleccion(void)
{
printf("\nEscriba el número de su Selección: ");
return (getche() - '0');
};
float LeerNumeroFlo(void)
{
float floNum;
printf("\nEscriba un Numero: ");
scanf("%f",&floNum);
return (floNum);
};
void LeerNumeros(float *floNumeroUno, float * floNumeroDos)
{
*floNumeroUno = LeerNumeroFlo();
*floNumeroDos = LeerNumeroFlo();
};
void ImprimirResultado(const float floNum1,const float floNum2,const float

floResult,const char * charOper)
{
printf("\n%.2f %s %.2f es = %.2f", floNum1,charOper,floNum2,floResult);
getch();
};
110
MAT.C
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include "matematica.h"
//---------------------------------------------------------------------
//Nombre: Suma
//Descripción Esta función calcula la suma de dos números reales. No valida.
//Destino: Programa de Ingeniería de Sistemas
//Datos Responsable: MIGUEL ANGEL NIÑO ZAMBRANO -UCAUCA - FIET
//Excepciones /Errores: Ninguno Implementado.
//Limitaciones: Sólo recibe números float.
//---------------------------------------------------------------------
float suma(float floNum1, float floNum2,char * chaOper)
{
strcpy(chaOper,"sumado");
return (floNum1 + floNum2);
};
//---------------------------------------------------------------------
//Nombre: Resta
//Descripción Esta función calcula la resta de dos números
// flotantes. No hace ningún tipo de validación
//---------------------------------------------------------------------
float resta(float floNum1, float floNum2,char * chaOper)
{
strcpy (chaOper,"restado");
return (floNum1 - floNum2);
};
//---------------------------------------------------------------------
//Nombre: Multiplica
//Descripción Esta función calcula la multiplicación de dos números
// flotantes. No hace ningún tipo de validación
//---------------------------------------------------------------------
float multiplica(float floNum1, float floNum2,char * chaOper)
{
strcpy (chaOper,"multiplicado");
return (floNum1 * floNum2);
};
//---------------------------------------------------------------------
//Nombre: Divide
//Descripción Esta función calcula la división de dos números
// flotantes. Valida que floNum2<> 0
//Excepciones /Errores: División por cero.
//---------------------------------------------------------------------
float divide(float floNum1, float floNum2,char * chaOper)
{
if (floNum2!= 0)
{
strcpy (chaOper,"dividido");
return (floNum1 + floNum2);
}
else
{
printf("División por cero.");
return 0;
}
};
111
Ejecución 1:
Menu
---------------------------
1: Sumar dos Numeros
2: Restar dos N·meros
3: Multiplicar dos N·meros
4: Dividir dos N·meros
5: Salir
Escriba el n·mero de su Selecci¾n: 1

Escriba un Numero: 2.5
Escriba un Numero: 6
2.50 sumado 6.00 es = 8.50
Ejecución 2:
Menu
---------------------------
5: Salir

3.40 restado 5.50 es = -2.10

Ejecución Ejecución 3:
Menu
---------------------------
5: Salir

2.00 multiplicado 3.00 es = 6.00
Ejecución 4:
Menu
---------------------------
5: Salir

Divisi¾n por cero.
4.00 dividido 0.00 es = 0.00
Ejemplo 23: Programa Completo de Funciones
112
El ejemplo anterior presenta la mayoría de las características del manejo de
procedimientos y funciones en C. A continuación se explicara cada uno de sus
detalles para que sean teni dos en cuenta:
1. El módulo principal es “matemática.c”, en este archivo se encuentra el

programa principal el cual hace el llamado al módulo “matemática.h” que
contiene los prototipos de las funciones matemáticas, a su vez, matemática.h
desarrolla las funciones en el archivo “mat.c”.
2. Se presenta la definición de funciones de dos formas:

a. Llamadas y Definidas en otros módulos o archivos como suma. Resta
multiplica y divide.
b. Llamadas y definidas en el mismo módulo del programa principal como
pausa, mostrar_menu, selección, LeerNumeroFlo, LeerNumeros y
ImprimirResultado.
Para la primera los prototipos se definieron en “matemática.h” y su desarrollo

en “mat.c” de esta forma el programa principal conoce las funciones
matemáticas al llamar #include “matemática.h”. Para la segunda como las
funciones se definieron inmediatamente después de la función main() se
debieron colocar los prototipos de las mismas antes de esta función.
3. En la definición de prototipos de las funciones encontramos dos tipos:

a. Declaración con variables: En esta se declaran los prototipos
exactamente igual como se definen en las funciones, colocando las
variables de parámetros formales. Ejemplo:
b. Declaración sin variables : En esta declaración se define la cabecera

de la función con sólo los tipos de datos que recibe, independiente del
nombre de los parámetros formales utilizados en el desarrollo de la
función: Ejemplo:
4. Los tipos de variables utilizadas en las funciones son las siguientes:

a. Variables constantes: Este tipo de definición permite pasar las
variables al procedimiento asegurándose que estos valos res son sólo
para la lectura de su información y en ningún momento se podrá
modificar la misma en la función. Esto se logra anteponiendo la palabra
reservada const antes del tipo de datos de la variable. Ejemplo:
b. Variables por Valor: Estas variables son las que se definen por defecto
cuando sólo se define el tipo de datos y la variable, las variables de la
función tomas copia de los valores actuales enviados. Ejemplo:
float suma(float floNum1, float floNum2,char * chaOper); Cuando es llamada en
113
el programa principal se rremplazan los valores de floNum1 y flo çNum2.
c. Variables por referencia : En este caso se pasa la dirección de la
variable en el prototipo de la función y cuando se realiza el llamado de la
función esta puede cambiar el valor de la variable. El ejemplo de esto
esta en todas las funciones matemáticas que reciben la variable
charOper por referencia y la devuelven con el texto adecuado de la
operación realizada. Otro ejemplo se presenta con la función
LeerNumeros la cual define dos números flotantes que se envían por
referencia Ejemplo:
La definición del prototipo debe ser asi:
El * define que esta variable recibe la dirección de sus variables actuales cuando
sea llamada.
El llamado es:
El & es el operador que envía la dirección de la variables a las variable de la
función.
5. Se presenta en el ejemplo el caso de funciones que realmente son

procedimientos al no retornar información. Ejemplos:
void pausa(void);
6. Se presenta el ejemplo del llamado de funciones en el llamado de otras

funciones. Ejemplo:
ImprimirResultado(floNum1, floNum2,suma(floNum1, floNum2, charOper), charOper);
4.13.3. Recursividad
Definición.
La recursividad es una técnica de programación importante. Se utiliza para realizar
una llamada a una función desde la misma función. Otra forma de hacer la
definición es cuando una función se define en términos de si misma, es decir,
cuando en el cuerpo de la función hace llamados a subprogramas que para el
caso es la misma función que se esta definiendo. Como ejemplo útil se puede
presentar el cálculo de números factoriales. Los factoriales de 0 y 1 son, por
definición, 1. Los factoriales de números mayores se calculan multiplicando 1 * 2 *
..., incrementando el número de 1 en 1 hasta llegar al número para el que se está
calculando el factorial. El siguiente párrafo muestra una función, definida en
palabras, que calcula un factorial.
"Si el número es menor que cero, recházalo. Si no es un entero, redondéalo al

siguiente entero. Si el número es cero o uno, su factorial es uno. Si el número es
mayor que uno, multiplícalo por el factorial del número menor inmediato."
Para calcular el factorial de cualquier número mayor que 1 hay que calcular como
mínimo el factorial de otro número. La función que se utiliza para hacerlo es la
función en la que se encuentra en estos momentos, esta función debe llamarse a
114
sí misma para el número menor inmediato, antes de poder ejecutarse en el
número actual. Esto es un ejemplo de recursividad.
Recursividad Directa e Indirecta

La recursividad directa se refiere al llamado de una función en la cual se hace un
llamado a si misma en el cuerpo de la función llamada. A contrario la Indirecta se
refiere a que el llamado recursivo se hace después de haberse llamado
previamente otra función dentro de la función llamada.
Cuadro 2: Estructura de los Tipos de Recursividad
Directa Indirecta
Procedure Directa ( ... ); Procedure Indirecta ( ... );
begin begin
. .
. .
. .
Directa ( ... ); A ( ... );
. .
. .
. .
end; end;
Procedure A ( ... );
begin
.
.
.
Indirecta ( ... );
.
.
.
end;
Funcionamiento Interno.
Para entender el funcionamiento de las funciones recursivas refiérase a la Figura
3. La llamada recursiva puede surgir en un procedimiento o en una función (ver la
primera flecha vertical de izquierda a derecha). En algún punto del programa,
dónde se hace La llamada recursiva, la secuencia de comandos se bifurcan (ver
flecha oblicua Hacia la derecha) , haciendo un llamado a la misma función o
procedimiento inicial, inmediatamente en el computador se genera una copia de la
función original, con sus variables y sentencias para iniciar nuevamente la función
llamada. Este proceso sigue ocurriendo indefinidamente hasta que alguna de las
funciones o procedimientos llamados, validen una condición de parada (no
llamarse nuevamente), y esta comienza a devolver la ejecución a la función o
115
procedimiento que la llamó desde el punto dónde se inicio la secuencia de
comandos de cada función después del llamado recursivo se termina y devuelve a
la función que la llamo, así continúa sucesivamente hasta que se llega a la primera
función o procedimiento y termina el programa.
Figura 3: Explicación de la Recursividad
Características Importantes de la Funciones Recursivas

q Condición de parada: Es importante establecer cual es la condición que
va a detener el llamado recursivo, por lo general si la condición es
verdadera no se debe llamar nuevamente la función o procedimiento, por el
contrario si es falsa, se continúa con el llamado recursivo.
q Parámetros que se pasan en cada llamada: Los parámetros que se
pasan deben se r identificados de tal manera que sean importantes en la
ejecución exitosa del llamado recursivo. Es decir cada vez que se hace un
llamado recursivo, se crean nuevas variables en la memoria del
computador, además estos parámetros sirven por lo general para el control
de la condición de parada de la función recursiva.
q Marcha atrás (backtracking): La marcha atrás es el momento en que
terminan las funciones recursivas y devuelven el control del programa a las
funciones o procedimientos que la llamaron. En este proceso es dónde
generalmente se establecen los elementos funcionales que permiten dar
resultados importantes de las funciones recursivas, porque o bien se
devuelven sumas, decisiones o información acumulativa, esto dependiendo
del objetivo de la función recursiva.
116
q Consumo de memoria: Hay que tener en cuenta el manejo de memoria
que tendrá la función, en términos algorítmicos se refiere a la complejidad
de la función recursiva, esta complejidad mide el tiempo que gasta la
función en realizar su objetivo, pero esta complejidad también se puede
medir en términos de los recursos de memoria que consume la función. Si
esta función recursiva tiene que llamarse un número N veces muy grande,
podría ocuparse la memoria del computador y provocar un error de
memoria. En este sentido hay que evaluar teóricamente las funciones
diseñadas antes de implementarlas. También juega en esto un papel
importante una correcta condición de parada.
Un ejemplo de funciones recursivas se presentó en el ejemplo de este capitulo de l
calculo factorial. Otro Ejemplo se presenta a continuación:
Código: 24 Nombre Búsqueda Binaria

Enunciado
Formulación del Realizar un programa que permita realizar la búsqueda binaria en un vector.
Problema Esta función debe ser recursiva. El vector es un arreglo de casillas del
mismo tipo de datos, en este caso número enteros y se encuentra ordenado
de manera ascendente.
*a Puntero al vector;
*intento Puntero a la variable de
Intentos;
Parámetros li Limite inferior del vector
Formales
ls Limite superior del vector
numero Numero Buscado en el vector*/
Posición en dónde se encuentra el número buscado en

Retorno
el vector.
Fase de El vector es de números enteros
Datos Auxiliares
Resolución El vector se encuentra ordenado
ü Busca la mitad del vector y compara el número buscado.
ü Se crean dos partes que se pueden considerar dos
vectores, al comparar uno de ellos es el que contiene el
Descripción:
número y se vuelve a realizar la misma búsqueda hasta
que el vector sea la misma casilla con el numero
buscado.
Se omite...
117
Implementación // ___________________________________________________________
// Nombre: Búsqueda Binaria
// Descripción: Realiza búsqueda binaria sobre el vector.
// ___________________________________________________________
/*Este programa realiza la búsqueda binaria en un vector de

manera recursiva*/
#include<stdio.h>
#include<conio.h>
/*Esta función hace la búsqueda binaria en el vector a,

devuelve la posición dónde se encuentra el vector buscado y
en el parámetro intento se devuelve el número de intento en que
vuelve a dividir el vector para leer
*a Puntero al vector;
*intento Puntero a la variable de Intentos;
li Limite inferior del vector
ls Limite superior del vector
numero Numero Buscado en el vector*/
int buscarbin(int *a, int *intento,int li,int ls,int numero)
{
int mitad;
mitad=(ls+li)/2;
/*comprobar en que mitad esta*/
if(a[mitad]<numero)
{ /*Esta en la mitad superior*/
*intento=*intento+1;
mitad=buscarbin(a,intento,mitad+1,ls,numero);
}
else if(a[mitad]>numero)
{ /*Esta en la mitad inferior*/
*intento=*intento+1;
mitad=buscarbin(a,intento,li,mitad,numero);
}
else
/*Se encontr¢ el numero*/
return mitad;
}
void main(void)
{
int a[20],i,num,intento,pos;
clrscr();
for(i=0;i<20;i++)
a[i]=i*2;
num=24;intento=1;
pos=buscarbin(a,&intento,0,20,num);
printf("El numero %d se encuentra en la posici¢n %d, en el
intento %d:",num,pos,intento);
getch();
}
Ejemplo 24: Función Valor Absoluto
118
Para los siguientes ejercicios se debe utilizar programación modular:

1. Elabore un algoritmo que lea n y r y muestre el siguiente resultado: n! / ( r! * (n
- r)! ).
2. Elabore un algoritmo que muestre los N primeros términos de la serie de
Fibonnaci, sabiendo que dicha serie inicia con T0 = 0, T1 = 1 y Tn = Tn-1 + Tn-2.
3. Elabore un algoritmo que muestre el N- nésimo término de la siguiente serie: 1, 3,
8, 30, 144, 840, ...
4. Elabore un algoritmo que calcule la sumatoria de los N primeros términos de la
serie 1!, 2!, 3!, 4!, 5!, ...
5. Elabore un algoritmo que lea dos variables X, N y en un solo ciclo repetitivo
DESDE calcule los siguientes valores 2N y XN .
6. Elabore un algoritmo que lea números enteros hasta que se digite 99999. El
algoritmo debe escribir los siguientes resultados:
• La sumatoria de los número leídos
• La cantidad de números leídos
• El menor número leído
• El mayor número leído
• El número leído que haya estado más cerca de 1000.
7. Elabore un algoritmo que lea de un salón de clase el nombre de un estudiante y sus
tres notas parciales (Equivalentes en porcentaje) hasta que el nombre sea ‘0’. El
algoritmo debe decir:
• El nombre del estudiante, las tres notas parciales y la nota definitiva.
• Cuantos estudiantes fueron digitados.
• La nota promedio definitiva del salón .
119
BIBLIOGRAFÍA
[1] CERQUERA, Rojas. Algorítmica para programación,

http://www1.monografias.com/trabajos11/algoritm/algoritm.shtml .
[2] LUCHO, Programación En C. http://www.lucho.com/librc.htm.
[3] RICO, Claudia Patricia, CAICEDO, Mauricio. Manual de

JSCRIPT.
http://donatello.icesi.edu.co/~grupo7/jscript/Recursividad.html.
[4] http://www.lafacu.com/apuntes/informatica/recursividad/.
[5] AGUILAR, Luis Joyanes. Fund amentos De Programación,

Algoritmos y Estructura de Datos. Segunda Edición. MacGraw-
Hill 1996.
[6] HEBERT, Schildt. Turbo C/C++, McGraw -Hill.
120
Anexo A: Modelo de Autodocumentación de Programas
implementado en el PIS (Programa de Ingeniería de Software)
Universidad del Cauca
OBJETIVO
Establecer una directriz general a cumplir en el desarrollo de la documentación interna de los
programas a realizar en el curso.
DOCUMENTACION INTERNA DE LOS PROGRAMAS

Teniendo en cuenta que un programa puede ser consultado, modificado y actualizado por una
persona que no necesariamente es su autor, éstos deben contemplar ciertas características que lo
hagan legible, comprensible y fácilmente modificable. Con el objetivo de lograr esto se pueden
establecer dos tipos de documentación; una primera que es interna al programa y que esta
compuesta básicamente por comentarios, código autodocumentado y una excelente presentación
visual. Por otra parte una documentación externa al programa y compuesta por el manual de
usuario, del operador, de mantenimiento del programa, de especificación del programa, la lista de
datos de prueba y los resultados esperados y el diseño descendente de los módulos y submódulos.
COMENTARIOS
Los comentarios constituyen el principal componente de la documentación interna de los
programas. Sin embargo la escritura de buenos comentarios puede ser tan difícil y en ocasiones
tan importante como escribir buenos programas. Los comentarios se deben incluir en la cabecera
del programa, en la cabecera de cada módulo y en la cabecera de cada rutina.
NOTA: Es muy importante resaltar que un comentario (guía) que no sea correcto o no corresponda
a la versión final, puede generar problemas mayores en el mantenimiento de los programas que
no haber escrito nada.
Al nivel de programa se debe documentar lo siguiente:

ü Nombre del programa.
ü Descripción de la tarea que realiza.
ü Destino del programa (empresa o usuario que utilizará el programa)
ü El nombre y el número telefónico de la persona actualmente responsable del mantenimiento y
la asistencia de este programa.
ü Un reporte de excepciones y/o errores. Estos son los mensajes de error, advertencias u otras
salidas anormales del programa producidas cuando se encuentran datos inválidos. Para cada
error el programa debe explicar que lo causa y como los usuarios deben repararlo.
ü Limitaciones del programa. Estos son las restricciones inherentes al programa que no pueden
ser resultas por los usuarios, por ejemplo, el limite de los arreglos.
ü Estructura general del programa
ü Desarrollo histórico del programa indicando:
ü Fecha y motivo de las actualizaciones
ü Nombre del programador (es) que realizó la actualización, con su número telefónico.
ü Número de versión y/o actualización
ü Lista de módulos y una indicación general de cómo se relacionan.
121
Al nivel de módulo se debe documentar lo siguiente:
ü Nombre del módulo.

ü Descripción de la tarea que realiza, explicando claramente las consideraciones importantes
que se tomaron para realizarla.
ü Desarrollo histórico del desarrollo de la rutina con los mismos elementos de la cabecera del
programa.
ü Lista de funciones del módulo y una indicación de quien llama a quien.
Al nivel de rutina (función y/o procedimiento) se debe documentar lo siguiente:
ü Nombre de la rutina.
ü Descripción de la tarea que realiza, explicando claramente las consideraciones importantes
que se tomaron para realizarla.
ü Desarrollo histórico del desarrollo de la rutina con los mismos elementos de la cabecera del
programa
ü Estructura de los datos de entrada y salida de la versión actual, los rangos aceptables de las
variables de entrada, donde, cuando, en que orden y el dispositivo que se usa para las
entradas.
ü Descripción de las estructuras de datos claves indicando: Nombre de la estructura de datos,
Tipo, Propósito, los módulos que acceden y modifican la estructura y el lugar donde esta
declarada.
Los comentarios también deben acompañar las declaraciones de las variables, las llamadas a
rutinas , las bifurcaciones y los bucles repetitivos, por ejemplo:
int acumulador; //Almacena la suma de las notas definitivas de los estudiantes
// Llena con ceros las mtotal casillas del vector gEstudiantes

InicializarVector (gEstudiantes, mtotal);
if (gEstudiantes[actual].notadefinitiva >= 4.0 )

{
// Instrucciones a realizar si es un estudiante distinguido.
...
}
CODIGO AUTODOCUMENTADO
La razón principal de usar un conjunto coherente de convenciones de código es estandarizar la
estructura y el estilo de codificación de una aplicación de forma que el autor y otras personas
puedan leer y entender el código fácilmente.
Las convenciones de codificación correctas dan como resultado un código fuente preciso, legible y
sin ambigüedad, que es coherente con otras convenciones del lenguaje y lo más intuitivo posible.
Un conjunt o de convenciones de codificación de propósito general debe definir los requisitos

mínimos necesarios para conseguir los objetivos explicados anteriormente, dejando libertad al
programador para crear la lógica y el flujo funcional del programa.
122
El objetivo es hacer que el programa sea fácil de leer y de entender sin obstruir la creatividad
natural del programador con imposiciones excesivas y restricciones arbitrarias. Por tanto, las
convenciones sugeridas son breves y sugerentes.
Variables
Las constantes y variables requieren convenciones de nombres bien compuestas. En esta sección
se muestran las convenciones recomendadas para las constantes y variables permitidas por
C/C++. También se explican cuestiones relacionadas con la identificación del tipo de datos y su
alcance.
Las variables se deben definir siempre con el menor alcance posible. Las variables globales
pueden crear máquinas de estado enormemente complejas y hacer la lógica de una aplicación muy
difícil de entender. Las variables globales tambi én hacen mucho más difícil mantener y volver a
usar el código.
En C/C++ las variables pueden tener el alcance que se muestra en la Cuadro 3.
Cuadro 3 Alcance de las variables en C/C++

ALCANCE DECLARACIÓN VISIBLE EN
El procedimiento en el que está
Nivel de procedimiento En procedimiento o función declarada
Todos los procedimientos del
Nivel de módulo En un módulo.
módulo
Global En un módulo. En toda la aplicación
En una aplicación de C/C++, las variables globales se deben usar sólo cuando no exista ninguna
otra forma cómoda de compartir datos entre módulos. Cuando haya que usar variables globales, es
conveniente declararlas todas en un único módulo agrupadas por funciones y dar al mód ulo un
nombre significativo que indique su finalidad, como globales.c.
Una práctica de codificación correcta es escribir código modular siempre que sea posible. Por
ejemplo, si la aplicación muestra una pantalla de captura de datos, coloque todo el código
necesario para ejecutar la tarea de la entrada de datos en un único módulo. Esto ayuda a tener el
código de la aplicación organizado y facilita el entendimiento del mismo .
A excepción de las variables globales (que no se deberían pasar), los procedimientos y funciones
deben operar sólo sobre las variables que se les pasan. Además, los argumentos se deben pasar a
los procedimientos y a las funciones por valor a menos que sea necesario explícitamente cambiar
el contenido del argumento que se pasa (o en su defecto por que el argumento no se pueda pasar
por valor como por ejemplo los arreglos).
Las variables deben llevar un prefijo para indicar su tipo de datos como se puede apreciar en la
Cuadro 4. Opcionalmente, y en especial para programas largos, el prefijo se puede ampliar para
indicar el alcance de la variable.
123
Cuadro 4 Prefijos para los tipos de datos básicos de C
TIPO DE DATOS PREFIJO
unsigned char uch
char cha
enum enu
unsigned int uin
short int sin
int int
unsigned long ulo
long lon
float flo
double dou
long double ldo
A medida que aumenta el tamaño del proyecto, también aumenta la utilidad de reconocer
rápidamente el alcance de las variables. Esto se consigue escribiendo un prefijo de alcance de
una letra delante del tipo de prefijo, sin aumentar demasiado la longitud del nombre de las variables
como se muestra en la Cuadro 5.
Cuadro 5 Prefijos para el alcance de las variables

ALCANCE PREFIJO EJEMPLO
gintContador
Global g
global – Entera – Contador
muchSecuencia
Nivel de módulo m modular – carácter sin
signo – Secuencia
floPrimerNota
Local del procedimiento Ninguno local – real simple –
Primer Nota
Nombres descriptivos de variables y procedimientos

El cuerpo de un nombre de variable o procedimiento se debe escribir en mayúsculas y minúsculas
y debe tener la longitud necesaria para describir su funcionalidad. Además, los nombres de
funciones deben empezar con un verbo, como InicializarMatriz o CerrarVentana.
Para nombres que se usen con frecuencia o para términos largos, se recomienda usar abreviaturas
estándar para que los nombres tengan una longitud razonable. En general, los nombres de
variables con más de 32 caracteres pueden ser difíciles de manejar.
Cuando se usen abreviaturas, hay que asegurarse de que sean coherentes en toda la aplicación.
Alternar aleatoriamente entre Cnt y Contar dentro de un proyecto provoca una confusión
innecesaria.
Constantes
124
El cuerpo del nombre de las constantes se debe escribir en mayúsculas. Aunque las constantes
estándar de C/C++ no incluyen información de tipo de datos y el alcance, los prefijos como INT,
UCH, CHA, G, M pueden ser muy útiles para entender el valor y el alcance de una constante, Por
ejemplo:
GINTMAXLISTA // Global – Entera - Límite de entradas para la lista de usuarios

MCHANUEVALINEA // Modular – Carácter - Carácter de nueva línea
Tipos y objetos definidos por el usuario

En un proyecto grande con muchos tipos definidos por el usuario, suele ser útil dar a cada uno de
estos tipos un prefijo de tres caracteres sólo suyo. Si estos prefijos comienzan con "u", será fácil
reconocerlos cuando se esté trabajando con tipos definidos por el usuario. Por ejemplo, "ucl" se
podría usar como prefijo para las variables de un tipo Cliente definido por el usuario.
PRESENTACION VISUAL
Como presentación visual se entiende que los párrafos deben estar correctamente identados, que
los coment arios deben estar ubicados de tal forma que no obstruyan la ágil lectura del código
fuente y que las líneas de código no superan el número de las columnas que normalmente maneja
el monitor (80), caso en el cual se debe escribir la instrucción en dos líneas.
También dentro de este tópico se puede catalogar la impresión de los listados de tal forma que sea
agradable para el lector realizar alguna actividad sobre él. por ejemplo: líneas o espacios en blanco
que faciliten la comprensión del programa y el agrupamiento de sentencias de entrada y salida.
125
View publication stats

Introducción A La Informática: Algoritmos y Porgramación en Lenguaje C

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Introducción A La Informática: Algoritmos y Porgramación en Lenguaje C

Încărcat de

Drepturi de autor:

Formate disponibile

See

Introducción a la Informática: Algoritmos y

Book · January 2001

Miguel Angel Niño Zambrano Carlos Cobos

SEE PROFILE SEE PROFILE

Martha Eliana Mendoza

CVN-Virtual E-Commerce Community View project

Cpe-Unicauca View project

The user has requested enhancement of the downloaded file.

Miguel Ángel Niño Zambrano

UNIVERSIDAD DEL CAUCA

MIGUEL ANGEL NIÑO ZAMBRANO

UNIVERSIDAD DEL CAUCA

Cuadro 1: Algunas Funciones Predefinidas En Los Lenguajes 29

Cuadro 2: Comparación Entre Diagramas De Flujo, Pseudocódigo Y

Cuadro 3: Estructura De Los Tipos De Recursividad 115

Cuadro 4 Alcance De Las Variables En C/C++ 123

Cuadro 5 Prefijos Para Los Tipos De Datos Básicos De C 124

Cuadro 6 Prefijos Para El Alcance De Las Variables 124

Figura1: Análisis Del Problema De Lanzar Dados Hasta Obtener Par 10

Figura 2: A,B Anidamientos Correctos, C Anidamiento Incorrecto 73

Figura 3: Explicación De La Recursividad 116

Ejemplo 1: Tirar Los Dados Hasta Obtener Par 13

Ejemplo 2: Conversión De Temperaturas 14

Ejemplo 5: Hallar El Área De Un Triángulo 39

Ejemplo 6: Calcular El Mayor De Tres Números 40

Ejemplo 7: Imprimir Un Menú De Opciones 42

Ejemplo 8: Calculo De La Potencia Xn 42

Ejemplo 9: Hallar El Área De Un Triángulo Pseudocódigo 44

Ejemplo 10: Uso De Constantes (Calculo Del Perímetro) 48

Ejemplo 11: Uso De Variables 50

Ejemplo 12: Uso De Operadores 54

Ejemplo.13: Uso De Printf 56

Ejemplo 14: Calculo De Promedio De Un Estudiante 57

Ejemplo 15: Establecer Si Un Número Es Negativo 70

Ejemplo 16: Establecer Si Un Número Es Par O Impar 72

Ejemplo 18: Menu De Operaciones Matemáticas 80

Ejemplo 19: Presentar Los Números Del 1 Al 100 Menos El 25 82

Ejemplo 20: Tablas De Multiplicar 84

Ejemplo 21: Función Valor Absoluto 105

Ejemplo 22: Función Factorial 107

Ejemplo 23: Programa Completo De Funciones 112

Ejemplo 24: Función Valor Absoluto 118

En este capitulo se van a explorar los conceptos fundamentales de la creación de

4.1.1. Algoritmo. Un algoritmo es el conjunto de operaciones y

4.1.2. Diferencia entre el lenguaje algorítmico y el informático. El lenguaje

4.1.3. Características de un algoritmo. Las carateristicas son:

ü Análisis previo del problema.

Uno de los mejores métodos de diseño de algoritmos consiste en partir los

Veamos un ejemplo inicial de un algoritmo y su solución:

Descripción del problema:

Si (sqr(b)>= 4*a*c) entonces

4.2. METAALGORITMO PARA CREAR ALGORITMOS

En este apartado presentamos un modelo para la creación de algoritmos, en éste

4.2.1. Fase de Formulación del Problema. Esta fase corresponde a la forma de

ü Descripción: Corresponde a una interpretación personal que consiste en

Análisis del Problema

Figura 1: Etapas para resolver problemas

ü Entradas: Corresponde a la información dada al problema. En el ejemplo

ü Procesos: Son todas las operaciones y/o cálculos que se realizan en el

ü Datos Auxiliares: Corresponde a datos que permiten tomar decisiones o se

Aplicando el modelo clásico de sistemas (entradas, procesos, salidas,

Figura 2: Modelo de Análisis de los problemas

Si (sqr(b)>= 4ac) entonces