Manual de Construccion de Programas
Manual de Construccion de Programas
Manual de Construccion de Programas
M AN UAL D E
CON STRUCCI ON
D E PROGRAM AS
M é x ico, 2 0 0 0
1998, Derechos Reservados conforme a la Ley
Construcción de Programas
Jorge Vasconcelos Santillán
México, D.F.
Presentación
Esta obra pretende ser un enlace entre los textos de introducción a la programación
y los de ingeniería de software.
De igual modo puede ser útil para aclarar algunos conceptos sobre
Análisis y Diseño de Sistemas e Ingeniería de Software, que suelen resultar
confusos al estudiarse por primera vez.
Una recomendación final: para que este libro le resulte más útil conviene
que ya haya pasado muchas horas programando y conocer bien algún lenguaje,
aunque no lo domine.
El Autor
V
Prefacio
VI I
La filosofía seguida está plasmada en la frase inicial de Kernigham y
Plauger, pues se ejemplifica con muchos programas para que el lector aprecie
aciertos y errores, y aprenda de la imitación. Los elementos teóricos son los
mínimos para evitar caer en generalidades que resultan tan ilegibles como
inaplicables. No está saturada de ejemplos que resulten difíciles de entender o que
deban imitarse, sino por el contrario, sólo se presentan elementos básicos (ideas,
programas o sugerencias), para que el programador reflexione y le surjan valiosas
ideas.
VI I I
El Capítulo 5 está dedicado al más tedioso trabajo que involucra la
construcción de programas: la documentación. Describe los tres principales niveles
de documentación: interna, técnica y para el usuario. Para facilitar esta fase, se
proveen numerosas sugerencias y formatos básicos útiles para los programadores
que documentan por primera vez.
Reconocimientos
Esta obra es producto de años de experiencia, de ideas de muchos especialistas y de
abundante material bibliográfico; y este espacio está dedicado precisamente a
presentar un reconocimiento a ellos. De antemano ofrezco disculpas por las
omisiones en que haya incurrido.
Peter Juliff, cuyas ideas fueron la base para construir los cuadros sobre las diversas
formas de los módulos, los diagramas de estructura y de Nassi-Schneiderman.
Nora Vasconcelos que elaboró el dibujo del sistema biológico del capítulo 2.
IX
Leticia Mijangos, que elaboró varios documentos cuya estuctura y estilo sirvieron
de base para elaborar las plantillas para los Manuales Técnico y del Usuario.
X
Contenido
3. Diseño de algoritmos
3.1 Etapas del desarrollo de programas 30
3.2 Diferencia entre algoritmo y programa 34
3.3 Bases para el diseño de algoritmos 37
3.4 Diagramas de flujo 41
3.5 Programación estructurada 42
3.6 Programación modular 45
3.7 Diagramas de estructura 56
4. Construcción de programas
4.1 Estilo de programación: ejemplos y
contraejemplos 62
4.2 Criterios para medir la calidad de un
programa 73
4.3 Algunas malas prácticas de programación 79
4.4 El goto 80
4.5 Lenguajes de programación 82
5. Documentación de programas
5.1 ¿Por qué documentar? 86
5.2 Cómo nombrar variables 88
5.3 Documentación interna 90
5.4 Documentación técnica 98
5.5 Documentación para el usuario 104
XI
6. Depuración de programas
6.1 ¿Es inevitable depurar? 112
6.2 Algunas técnicas para comprobación de
rutinas 113
6.3 Errores comunes 118
6.4 Manejo de errores 121
7. Optimización de programas
7.1 Sugerencias de optimización 128
7.2 Uso de memoria dinámica 134
XI I
Índice de cuadros y figuras
XI I I
cuadro 4-5 El goto enmascarado 81
cuadro 4-6 Lenguajes procedurales 82
XI V
Ca pít u lo 1
J. Galicia.
2
LO QUE TODO PROGRAMADOR DEBE SABER
5. Usar las herramientas disponibles, pero evitando que una herramienta detenga
o altere la solución a un problema.
Cuadro 1-1
LAS VIRTUDES DE UN PROGRAMADOR
I
Ser capaz de analizar un problema hasta
comprenderlo completamente.
II
Ser capaz de diseñar una
estrategia que describa los pasos requeridos
para obtener la solución del problema.
III
Conocer el funcionamiento,
capacidades y limitaciones de las computadoras.
IV
Dominar un lenguaje de programación en particular,
y además conocer algún lenguaje adecuado
a la solución del problema.
V
Ser capaz de evitar el perfeccionismo
y equilibrar entre lo ideal y lo real.
3
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
Planear significa pensar un poco antes de dedicarse a construir. Es una labor que
Nunca encienda implica trabajo de escritorio.
la computadora
si desconoce lo La planeación es especialmente importante para desarrollar programas. Si
que va a hacer. el problema es sencillo, la planeación será ligera (una simple inspección al
problema); si el problema es complejo, la planeación será más estricta (pasar por las
fases de análisis, diseño, implementación).
void main()
{
clrscr();
printf("Este programa devuelve el residuo de la division de dos números \n");
printf("(Los números deben ser enteros y el dividendo mayor que el divisor) \n");
printf("Presione [ENTER] para continuar o cualquier otra tecla para salir");
if (getch() != 13)
exit(0);
delline(); printf("\n");
4
LO QUE TODO PROGRAMADOR DEBE SABER
if (Modulo(Dividendo,Divisor) != 0)
printf("El residuo de %d entre %d es igual a %d \n", Dividendo, Divisor,
Modulo(Dividendo,Divisor));
else
printf("La división de %d entre %d es exacta, el residuo es igual a 0 \n",
Dividendo, Divisor);
El cuadro 1-2 (b) muestra otro programa, que realiza la misma tarea que el
anterior, para el cual se tomaron algunos minutos de reflexión, antes de sentarse a
programarlo.
5
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
main ()
{
int dividendo, divisor;
int cociente, residuo;
Para elaborar un programa lo primero que debe hacerse es definir sus objetivos y
delimitar con precisión sus alcances; y enseguida planear todas las tareas que
deberán desarrollarse para construirlo. Esto incluye tanto los elementos teóricos
que deberán investigarse, como las opciones que ofrecerá el programa. Si le es útil,
puede seguir este esquema:
1. Enlistar todas las actividades y opciones que el programa deberá efectuar, sin
detallarlas, ni ordenarlas.
2. Jerarquizar la lista, considerando complejidad y tiempo disponible.
3. Detallar cada actividad, siguiendo este mismo esquema.
4. Asignar tiempos.
Al desarrollar las actividades trate de cumplir con los tiempos marcados.
Si llegara a excederse en el tiempo asignado a un paso, deberá reconsiderar el
tiempo disponible para el resto de las actividades.
No importa que su planeación sea muy sencilla o poco profunda, siempre le
será de mucha ayuda.
6
LO QUE TODO PROGRAMADOR DEBE SABER
cuadro 1-3
Un ejercicio de planeación
Hay programas que muy fácilmente se pueden desarrollar directamente sobre la computadora,
pero también hay otros que sin un análisis previo, no salen. Aquí hay un par de ejercicios que
muestran ambos casos.
(Si tarda más de quince minutos, entonces todavía le falta mucha práctica en la programación.)
A continuación se muestra una estrategia para solucionar ambos problemas, pero no vaya
a verla hasta no haberlo intentado usted mismo.
7
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
Y = MaxY
X = MinX;
Para i desde 0 hasta 50 Hacer
Inicio
DibujaLínea (0,Y,X,0)
y = y - 10;
x = x +10
Fn
8
LO QUE TODO PROGRAMADOR DEBE SABER
y = r ⋅ Sen(θ )
x = r ⋅ Cos(θ )
r= 5
θ = 22.5
Para i desde 1 hasta 8 Hacer
Inicio
y = r*Sen( θ)
x = r*Cos( θ)
dibujar arco con centro en x,y y radio aproxim ado r/ 2
r = r + dr
θ = θ + dθ
Fin
9
Ca pít u lo 2
v Análisis y diseño de
sistemas
1. Información (datos).
2. Transformadores de información.
3. Fuentes de información.
4. Receptores de información.
5. Almacenes de datos.
La Tierra es un complejo sistema donde intervienen muchos actores: el Sol, las plantas, la
atmósfera, el suelo y los animales. Las plantas producen el oxigeno que hay en el aire, para ello
requieren de sustancias alimenticias alojadas en el suelo, de agua y de los rayos solares. En la
atmósfera también se encuentran las nubes, producto de la evaporación del agua (depositada en
mares y lagos); al enfriarse las nubes se deshacen como lluvia que aprovecharán todos los seres vivos
y llenarán nuevamente los depósitos de agua. Las plantas también sirven de alimento a los animales
herbívoros; éstos a su vez, son el alimento de los carnívoros; y todos ellos al morir enriquecen el
suelo. Esta es una compleja red de intercambios de la que dependemos todos.
1 El concepto de sistema de información no considera cuáles son los componentes físicos del
sistema (es decir, no hace referencia a computadoras).
12
ANÁLISIS Y DISEÑO DE SISTEMAS
Cuadro 2-1
Diferencia entre sistema y programa
La forma más sencilla de explicar la diferencia entre sistema y programa es recordar un antiguo
refrán popular: "una golondrina no hace un verano"; con esto queremos hacer notar que un
programa asilado (por largo que sea) no es un sistema. Desafortunadamente hay una tendencia
popular a llamar "sistema" a todo programa y también a considerar que todo sistema involucra
computadoras.
13
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
1. Especificación de Requerimientos.
2. Análisis.
3. Diseño.
4. Implementación y Pruebas.
5. Mantenimiento.
De acuerdo a como se suceden las fases del ciclo de vida del software, han sido
propuestos dos modelos para el desarrollo de sistemas: el modelo cascada y el
modelo espiral (figura 2-2).
14
ANÁLISIS Y DISEÑO DE SISTEMAS
l Especificación de Requerimientos
Este es el primer paso para poder construir el sistema. Consiste en elaborar una
lista que indique* :
1. ¿Qué necesito?
2. ¿Cuál es el esbozo del problema?
3. ¿Qué espero lograr con el sistema?
4. ¿Con qué recursos cuento actualmente?
5. ¿Qué posibilidades tengo de obtener más recursos?
* Sidesea ser muy formal incluya también una exposición de motivos, descripción de antecedentes
y del estado actual, organigrama de la institución, ventajas esperadas, etcétera.
15
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
l La Fase de Análisis
La fase de análisis consiste en hacer un estudio del estado existente de las cosas.
El análisis nos
Esta etapa es muy importante, pues delimitará con precisión al problema y los
dice: "las cosas
alcances de la solución.
están así".
El análisis permite construir un modelo del problema, que pueda utilizarse
para elaborar el modelo de la solución.
El resultado del análisis debe ser una descripción completa y detallada del
funcionamiento del sistema bajo estudio, ya sea que exista o que sólo sea una
propuesta.
cuadro 2-2
Cómo analizar un proyecto
1. Sumergirse en el problema
3. Separar las salidas deseadas de los datos que pueden ser tomados
como entradas.
l El Diseño de Programas
16
ANÁLISIS Y DISEÑO DE SISTEMAS
Esta fase no suele aparecer en los modelos de desarrollo de software; sin El diseño de
embargo si un sistema de cómputo se desarrolla correctamente, hay un paso programas se
intermedio entre el diseño del sistema y su implementación. encarga de
construir
Esta fase debe presentarse siempre antes de sentarse a programar. conceptualmente
la solución
Durante el diseño de programas no se proponen soluciones alternativas,
sólo se construye.
cuadro 2-3
Sugerencias para Análisis y Diseño
3. Dedicar todo el tiempo necesario para establecer una definición exacta acorde
a las necesidades reales.
17
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
7. Cuando tenga que desarrollar programas para otras personas tenga en cuenta
lo siguiente:
l Es muy raro que los usuarios estén completamente conscientes de la
verdadera naturaleza de sus problemas y suelen esperar que el experto les
diga cuál es el problema y cómo resolverlo.
lLos usuarios no están interesados en los detalles de funcionamiento, sólo
desean respuestas del programa.
cuadro 2-4
Quién y cuándo del Análisis de Sistemas.
1966 - Böhm y Jacopini demostraron que para construir programas sólo se requieren tres
estructuras de control (teorema de la estructura).
18
ANÁLISIS Y DISEÑO DE SISTEMAS
19
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
20
ANÁLISIS Y DISEÑO DE SISTEMAS
l FLUJO DE DATOS
Es una tubería imaginaria por la cual fluyen paquetes de información de estructura
conocida. Esta tubería permite el desplazamiento de los paquetes en cualquier
momento; es decir, no indica el momento preciso en el que se moverá información.
El flujo de datos se dibuja como una flecha que conecta dos procesos. El
sentido de la flecha indica la dirección en que viajan los paquetes de datos. A la
flecha se le asigna un nombre (relacionado con el nombre del paquete) que se
registra en el diccionario de datos.
Los paquetes diferentes deben fluir por tuberías diferentes. Una analogía
práctica: el agua fría y el agua caliente fluyen por tuberías diferentes.
l PROCESO
Es un elemento del sistema que se encarga de transformar datos. Los flujos de
datos llegan y salen del proceso.
Se dibuja como un círculo, llamado burbuja, con un nombre y un número
en su interior.
1. El nombre lo tomará según los flujos de E/S. Si no lo puede tomar significa que
es un proceso complejo que deberá descomponerse.
21
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
l DEPOSITOS DE DATOS
Se dibuja como dos líneas paralelas con el nombre de los datos que
guarda, y se registra en el diccionario de datos.
l FUENTES O DESTINOS
Tanto las fuentes como los destinos se dibujan con un rectángulo en cuyo
interior está el nombre del elemento externo.
1. Concentrarse primero en visualizar los flujos de datos: cuáles son, de dónde vienen y a dónde
van.
2. Etiquetar y anexar en el diccionario de datos todos los flujos de datos.
3. Tratar de visualizar cómo se enlazan o separan los flujos de datos para obtener las salidas.
22
ANÁLISIS Y DISEÑO DE SISTEMAS
1. Dibujar un diagrama de
contexto del sistema: representar
con un círculo a todo el sistema e
indicar las entradas al sistema con
flechas que se dirigen hacia la
burbuja, y las salidas con flechas
que salen de la burbuja. Tanto las
entradas como las salidas deben
registrarse en el diccionario de
datos.
Si se ignoran datos en el
diagrama de contexto, deberán
ignorarse en lo sucesivo.
23
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
Es muy importante que cada diagrama de flujo de datos contenga entre 7 y 9 burbujas
(excepto el diagrama de nivel cero). Un número mayor de burbujas indica la necesidad
de descomponer mejor el diagrama.
2. Diccionario de datos
24
ANÁLISIS Y DISEÑO DE SISTEMAS
** comentario
@ dato llave
3. Especificaciones de Proceso
cuadro 2-6
Las ventajas del análisis estructurado para el programador
I. Las burbujas del diagrama de flujo de datos permiten reconocer los módulos
que integrarán al programa, y los flujos de datos muestran los parámetros que
deberán pasarse.
II. El diccionario de datos permite determinar fácilmente los tipos de datos que
deberán definirse en el programa.
III. Las miniespecificaciones serán las base del algoritmo que se programará en
cada módulo.
cuadro 2-7
Una sencilla aplicación del análisis estructurado
En este ejemplo consideramos la operación básica de un videoclub:
1. dar de alta nuevos clientes,
2. rentar películas y
3. recibir la devolución de los videocassettes.
Los procedimientos son: (a) a los nuevos clientes se les asigna una credencial con su
nombre y matrícula; (b) para rentar películas basta con mostrar la credencial, pasar la película
deseada por una lectora de código de barras y efectuar el pago correspondiente; y (c) para la
devolución basta entregar la película (que vuelve a pasar por la lectora).
Para mostrar cómo se aplican las herramientas del análisis estructurado, primero veremos
los diagramas de flujos de datos, luego las especificaciones de proceso y finalmente el diccionario
de datos, sin embargo estas tres se construyen de manera paralela y cada componente está referido
en las otras.
25
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
26
ANÁLISIS Y DISEÑO DE SISTEMAS
Este ejemplo es muy sencillo, por lo que una vez que hemos alcanzado este nivel las
burbujas ya son primitivas, por lo que podemos pasar a la especificación de proceso. (Si el sistema
fuese más complejo, cada una de las burbujas del nivel cero deberá subdividirse, tal como se hizo
con el diagrama de contexto).
Observe que el diagrama de flujo de datos resulta útil para determinar los módulos que
deberá tener el programa o sistema y los parámetros que deberán pasarse entre ellos.
2. Renta de Película
Por cada Clave_Película
Solicitar Matrícula_Cliente
Actualizar servicios en Catálogo de Clientes
Obtener Registro_Película
Actualizar existencias en Catálogo de Películas
Calcular Precio_Servicio
Informar Precio_Servicio
Recibir Pago
27
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
Entregar Comprobante_Renta
3. Devolución de Película
Por cada Clave_Película
Actualizar existencias en Catálogo de Películas
(Los procesos que implican movimientos en los catálogos se efectúan a traves del
administrador de catálogos, que es en realidad un manejador de bases de datos, por lo que no se le
detallará aquí.)
Observe que las especificaciones de proceso resultan útiles para diseñar y construir los
algoritmos que se usarán en los programas.
28
ANÁLISIS Y DISEÑO DE SISTEMAS
Observe que el diccionario resulta útil para determinar las variables y estructura de los
registros que se usarán en los programas.
Una advertencia, este ejemplo sólo es una propuesta del autor, diferentes analistas
pueden tener opiniones diferentes, incluso usted mismo puede encontrar posibles mejoras.
29
Ca pít u lo 3
v Diseño de algoritmos
Para superar esta fase se debe redactar un texto que indique qué es lo que
se pretende solucionar y contenga toda la información útil al respecto.
30
DISEÑO DE ALGORITMOS
Durante esta fase se debe definir con precisión qué información es útil y
cuál no. Si se descubre información faltante, deberá investigarse.
Como resultado de esta fase se propondrá una solución, pero sin indicar
cómo obtenerla.
l Programación y pruebas
l Mantenimiento
El cuadro 3-2 muestra un ejemplo muy sencillo donde se aplican cada una
de estas fases.
31
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
Cuadro 3-2
Centrar un letrero *
l ANALISIS
1o. Enunciado del problema: Centrar un letrero cualquiera de manera similar a como se haría
con una máquina de escribir.
2o. Solución del problema: Para centrar un letrero es necesario dejar espacios antes de escribirlo,
entonces hay que desarrollar un método para calcular esa cantidad de espacios y aplicarlo.
l DISEÑO
Se cuentan las letras (incluyendo los espacios) en el letrero y se resta del total de columnas en
la hoja ("golpes por página"). El número que resulta corresponde al total de espacios en blanco
que quedarían si se escribe la línea desde el margen izquierdo. Por lo tanto, para centrar se deben
repartir los espacios en dos porciones iguales, una quedará antes y otra después del letrero.
3o. Algoritmo
(1) Inicio
(2) ANCHO = 80
(3) Leer LETRERO
(4) LONG = total de caracteres en LETRERO
(5) NUM_ESPACIOS = ANCHO - LONG / 2
(6) Imprimir NUM_ESPACIOS de blancos
(7) Imprimir LETRERO
(8) Fin
Comentarios:
♦ En la línea (2) fijamos el ancho en 80, según sean las necesidades puede fijarse en cualquier
otro valor.
♦ La línea (4) indica el total de caracteres, manualmente se hace contando las letras, en los
lenguajes de programación hay funciones especiales que hacen esto precisamente.
32
DISEÑO DE ALGORITMOS
l Programación
Program CentrarLetrero;
Var
i,
Ancho,
Long,
NumEspacios : Integer;
Letrero : String;
Begin
Ancho := 80;
Write ('Escriba algún mensaje ');
Read (Letrero);
Long := Length(Letrero);
NumEspacios := (Ancho - Long) Div 2;
For i := 1 To NumEspacios Do
Write (' ');
Write (Letrero);
End.
l Mantenimiento
Las necesidades cambia y el ancho de la pantalla será de 132. Tambien deberá aparecer
el letrero entre asteriscos.
Program CentrarLetrero;
Var
i,
Ancho,
Long,
NumEspacios : Integer;
Letrero : String;
Begin
Ancho := 132; ç Modificación
Write ('Escriba algún mensaje ');
Read (Letrero);
Long := Length(Letrero);
NumEspacios := (Ancho - Long) Div 2;
For i := 1 To NumEspacios Do
Write (' ');
Write ('*',Letrero,'*'); ç Modificación
End.
Que una idea (algoritmo, programa o lenguaje) sea antiguo, no implica que sea
obsoleto; por el contrario, le puede aportar valiosos elementos que sólo
requieran adaptarse a su trabajo propio.
33
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
cuadro 3-3
UN ALGORITMO DE SEIS PASOS PARA HACER PROGRAMAS
3. Verifique que el algoritmo sea lógicamente correcto y que cumpla con las
especificaciones.
Richard E. Blahut
Un algoritmo es una fórmula o una secuencia de pasos que resultan útiles para
El algoritmo darle solución a un problema. Debe ser independiente de la sintaxis de un lenguaje
define la lógica de programación en particular puesto que es la concreción de un plan y es un medio
con que fluyen para comunicar ideas entre personas (no obstante un algoritmo puede tomar en
las instrucciones consideración a otros algoritmos).
de un programa.
Un programa es un grupo de instrucciones, escritas en un lenguaje
especializado, cuya finalidad es indicarle a una máquina cómo efectuar un trabajo.
34
DISEÑO DE ALGORITMOS
inicio
leer A, B, C
X1 = (-B + B² - 4 ⋅ A ⋅ C ) / (2 ⋅ A)
X 2 = (-B - B² - 4 ⋅ A ⋅ C ) / (2 ⋅ A)
escribir X1, X2
fin
begin
read A, B, C
X1 = (-B + B² - 4 ⋅ A ⋅ C ) / (2 ⋅ A)
X 2 = (-B - B² - 4 ⋅ A ⋅ C ) / (2 ⋅ A)
write X1, X2
end
cuadro 3-4
l Algoritmo para obtener las raíces de la ecuación cuadrática
Program Obtener_Raices;
Var
A,B,C,
X1,X2 : Real;
Begin
Write ('Escriba el coeficiente cuadrático: ');
Read (A);
Write ('Escriba el coeficiente lineal: ');
Read (B);
Write ('Escriba el término independiente: ');
Read (C);
35
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
cuadro 3-5
Suma de Matrices
a b c z y x a+ z b+ y c+ x
d e f + y v u = d + y e + v f + u
g h i t s r g + t h + s i + r
3. De manera general
Sean
A, B y C matrices de n x m,
aij un elemento cualquiera de A
bij un elemento cualquiera de B
cij un elemento cualquiera de C
cij = a ij + bij , 1≤ i ≤ n y 1≤ j ≤ m
Esta última forma permite indicar con mayor facilidad otros procedimietnos, como
calcular la suma de las diagonales de una matriz
n n
Diagonal= ∑a ii Antidiagonal = ∑ a i ( n − i + 1)
i=1 i =1
Así como éste, hay una gran cantidad de casos en los que hacer el
algoritmo resulta en la construcción del programa3 (si se programa en un lenguaje
de alto nivel). Sin embargo también existen otros casos en los que la diferencia
entre algoritmo y programa es enorme (véase el cuadro 3-5).
36
DISEÑO DE ALGORITMOS
Dos algoritmos
Obsérve que en el ejemplo del cuadro 3-6 resulta más fácil
son compatibles
entender el algoritmo que el programa. Si usted tiene oportunidad de
si producen las
estudiar inteligencia artificial (campo donde suelen utilizarse
mismas salidas
búsquedas, esto es, ubicar la mejor posibilidad entre una gran gama
ante iguales
situaciones, como en el ajedrez) observará que este algoritmo es
entradas.
fácilmente implementable en cualquier lenguaje. Si sólo tuviese el
programa, antes de intentar hacerlo con otro lenguaje, tendría que aprender Lisp.
cuadro 3-6
l Algoritmo para realizar una búsqueda de "primero en profundidad".
cuadro 3-7
Características de un algoritmo
1) Alcanzar la solución (correcta) en un tiempo finito.
2) Constar de pasos claros, precisos y no ambiguos.
37
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
3) Mostrar claramente cuáles son los datos iniciales y cuáles son los
resultados.
Haga
Para establecer esa serie de pasos se requiere reflexionar sobre algoritmos tan
el problema. Si el problema es grande entonces conviene dividirlo en sencillos y
otros más pequeños que puedan entenderse con más detalle y atender claros que su
cada uno de los subproblemas por separado, sin preocuparse por los lógica sea
demás. evidentemente
correcta.
Por cada problema se debe considerar lo siguiente:
a) Pedir datos
b) Desplegar datos
c) Evaluar condiciones
d) Ejecutar operaciones matemáticas
4Para controlar el orden en que se efectúan estas acciones se requiere de estructuras de control o
de saltos (goto).
38
DISEÑO DE ALGORITMOS
39
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
cuadro 3-8
Un lenguaje mínimio
Los procesos más complejos pueden ser construídos a partir de un lenguaje muy reducido que
no contenga estructuras de programación. Este tipo de problemas son estudiados por la
Computabilidad. Enseguida vemos un pequeño conjunto de instrucciones a partir del cual se
construyen las demás estructuras de programación.
l Instrucciones Básicas:
While Aux ≠ 0 Do
Inc Nom1
Inc Nom2
Dec Aux
End While
Procedure If aux
Inc Flag
Clear Aux
While Aux ≠ 0 Do { else }
S2
Clear Aux
Clear Flag
End While
40
DISEÑO DE ALGORITMOS
While Flag ≠ 0 Do
S1
Clear Flag
End While
Los diagramas de flujo son representaciones del flujo que siguen las instrucciones
de un programa.
Pero si bien estos diagramas han caído en desuso, aún pueden resultar
útiles. Conviene recurrir a los diagramas de flujo en los siguientes casos:
41
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
5En realidad los dos últimos son consecuencia de la aplicación del primero.
42
DISEÑO DE ALGORITMOS
; emulacion de For-Next
NEXT: mov cl, 10 ; limite inferior
mov ch, 20 ; limite superior
FOR: cmp cl,ch ; For X := CL To CH Do
je CONTINUE
nop ;call cuerpo del módulo
inc cl
jmp FOR ; Next X
CONTINUE: ;fin ; Salida del FOR-Next
43
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
strcpy(tr,trans[t+1]
;
return 1;
}
}
t += 2;
}
44
DISEÑO DE ALGORITMOS
SECUENCIA
SELECCION
Estructura
utilizada para elegir
entre acciones
diferentes.
ITERACION
45
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
cuadro 3-11
LAS DIVERSAS FORMAS DE LOS MODULOS
MACRO: Es una sola instrucción, que se incluye en el programa fuente, y se expande en varias
instrucciones del mismo nivel del lenguaje.
SUBRUTINA (procedimiento): Es una sección de código que lleva una tarea autocontenida
dentro de un programa. Se ejecuta mediante una llamada desde uno o más puntos dentro del
programa, y después de completarse regresa a la instrucción siguiente de su llamada.
1. Patrón básico:
a) Principio - Rutinas de inicialización, lectura de entradas, apertura de
archivos, activación de modos gráficos.
b) Mitad - Procesamiento de datos.
c) Fin - Emisión de resultados, cierre de archivos, restauración de modos de
video, liberación de memoria.
3. Ciclo determinístico
Los procesos se repiten un predeterminado número de veces.
4. Ciclo indeterminado
Los procesos se repiten hasta que una condición específica es detectada.
46
DISEÑO DE ALGORITMOS
2. Cada subprograma deberá ejecutar una sola tarea, pero hacerla bien.
3. Ningún módulo deberá afectar a algún otro procedimiento. Use variables locales
tanto como le sea posible ya que su margen de acción está limitado naturalmente
al módulo que las define.
4. Cada módulo deberá comportarse como una caja negra: recibir entradas,
efectuar un proceso desconocido y entregar resultados.
7. Cualquier tarea que se efectúa más de una vez en un programa, debe ser
separada en un módulo. Todas las secciones que actúen como interfaces de
entrada y salida de datos hacia el usuario también deberán ser módulos
especiales.
8. Escribir los módulos de modo general. Colocarlos en librerías para que puedan
ser incorporados en programas diferentes.
10. Construir módulos con pocos ciclos y pocas opciones para facilitar su prueba y
depuración. El tamaño máximo conveniente para un módulo es de unas 23 líneas
(una pantalla).
l El acoplamiento y la cohesión
47
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
48
DISEÑO DE ALGORITMOS
49
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
cuadro 3-12
♦ Acoplamiento de contenido
F En este programa hay acoplamiento de contenido entre los módulos ajustar e imprimir.
title SALUDO
.model small
.stack 10h
.data
CR = 0Dh
LF = 0Ah
MESSAGE db CR,LF,'Hola Mundo','$'
.code
inicio proc ç imprime cinco veces el mensaje
mov cx, 5
ciclo: call imprimir
loop ciclo
50
DISEÑO DE ALGORITMOS
♦ Acoplamiento de contenido
F dado que este módulo es recursivo, hay acoplamiento consigo mismo, debido
a que se está haciendo un paso de parámetros por referencia.
♦ Acoplamiento de zonas
Const
MAX_STACK = 20;
Var
Stack : Record;
arr : Array[1..MAX_STACK] Of String;
tope : Byte;
End;
51
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
End;
52
DISEÑO DE ALGORITMOS
♦ Acoplamiento de control
Var
Resp : Char;
Procedure Accion1;
Begin
{ Instrucciones...}
Procedure Acción2;
Begin
If Resp = 'S' Then
Begin
{ Instrucciones... }
End;
End;
Begin
Accion1;
accion2;
End.
F Para liberar este acoplamiento de control, podemos reescribir parte del código.
Var
Resp : Char;
Procedure Accion1;
Begin
{ Instrucciones...}
End;
Procedure Acción2;
Begin
{ Instrucciones... }
End;
Begin
Accion1;
WriteLn ('Desea Continual');
ReadLn (Resp);
If Resp = 'S' Then Accion2;
End.
53
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
♦ Acoplamiento de datos
Const
MAX_STACK = 20;
Type
t_Stack = Record
arr : Array[1..MAX_STACK] Of String;
tope : Byte;
End;
♦ Cohesión coincidental
54
DISEÑO DE ALGORITMOS
C,C2,C3,CONT,CONT1:INTEGER;
BEGIN
CLRSCR;
CONT1:=1;
CONT:=7;
REPEAT
GOTOXY (CONT,CONT1);
WRITELN ('*');
CONT:=CONT-1;
CONT1:=CONT1+1;
UNTIL CONT =1;
BEGIN
C2:=1;
C:=7;
REPEAT
GOTOXY (C,C2);
WRITELN ('*');
C:=C+1;
C2:=C2+1;
UNTIL C2= 7;
BEGIN
C3:=7;
C:=1;
REPEAT
GOTOXY (C,C3);
WRITELN ('*');
C:=C+1;
C3:=7;
UNTIL C=14;
END;
END;
READLN;
END.
Procedure Primero;
BEGIN
CLRSCR;
CONT1:=1;
CONT:=7;
End;
Procedure Segundo;
Begin
REPEAT
GOTOXY (CONT,CONT1);
WRITELN ('*');
CONT:=CONT-1;
CONT1:=CONT1+1;
UNTIL CONT =1;
End;
Procedure Tercero;
55
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
BEGIN
C2:=1;
C:=7;
REPEAT
GOTOXY (C,C2);
WRITELN ('*');
C:=C+1;
C2:=C2+1;
UNTIL C2= 7;
End;
Procedure Cuarto;
BEGIN
C3:=7;
C:=1;
REPEAT
GOTOXY (C,C3);
WRITELN ('*');
C:=C+1;
C3:=7;
UNTIL C=14;
END;
BEGIN
Primero;
Segundo;
Tercero;
Cuarto;
END.
♦ Cohesión en la comunicación
♦ Cohesión Secuencial
Procedure RaícesCuadráticas;
Var
A,B,C,•
X1,X2,
Disc : Real
flag : Boolean;
Begin
A := ObtenerCoeficiente;
B := ObtenerCoeficiente;
C := ObtenerCoeficiente;
Disc := CalcularDiscriminante (A,B,C);
If Disc >= 0 Then
Begin
56
DISEÑO DE ALGORITMOS
X1 := CalcularRaiz1 (A,B,Disc);
X2 := CalcularRaiz2 (A,B,Disc);
Imprimir X1,X2;
End;
End;
l La iteración se indica mediante uan flecha que indica los módulos a repetir.
57
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
58
DISEÑO DE ALGORITMOS
59
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
Programa A
Hacer B Procedimiento D
Mientras condición Mientras condición
Si x entonces Hacer I
Hacer C Hacer J
En otro caso Fin del mientras
Hacer D Fin del procedimiento
Fin del mientras
Hacer E
Fin del programa Procedimiento H
Hacer M
Procedimiento B Hacer N
Hacer F Fin del procedimiento
Hacer G
Fin del procedimiento
Procedimiento J
Procedimiento C Si z entonces
Si y entonces Hacer K
Mientras condición En otro caso
Hacer H Hacer L
Fin del mientras Fin del procedimiento
Fin del procedimiento
60
DISEÑO DE ALGORITMOS
Esta es la versión del diagrama una vez reestructurado, de tal modo que
X sólo se evalúa una sola vez.
61
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
62
Ca pít u lo 4
v Construcción de
programas
cuadro 4-1
Niveles de construcción de programas
Programas de bajo nivel: Son programas que explotan las características propias
de la computadora (normalmente son herramientas dependientes del equipo). Por
ejemplo, las rutinas gráficas, el manejo de puertos, las interfaces con el usuario,
etcétera. En este tipo de programas no puede seguirse estrictamente las fases del
diseño y generalmente son rutinas que deben ser optimizadas, aun sacrificando su
claridad (suelen ser rutinas que sólo estudiarán especialistas).
Programas de alto nivel: Son programas que entregan resultados
independientemente de la máquina. Para construírlos hay que enlazar herramientas
ya disponibles. En este tipo de programas conviene seguir estrictamente las fases
del diseño y generalmente no deben ser optimizadas, ya que se requiere claridad
para que las entienda un no especialista.
Para facilitar el proceso de mantenimiento, hay que evitar mezclar niveles al
construir las rutinas.
l Expresividad
62
MANUAL DE CONSTRUCCION DE PROGRAMAS
#define N 4
main ()
{
int i,j;
int x[N][N];
for (i=1;i<=N;i++)
for (j=1;j<=N;j++)
x[i-1][j-1] = (i/j) * (j/i);
}
#define N 4
main ()
{
int i,j;
int x[N][N];
#define N 4
main ()
{
int i,j;
int x[N][N];
63
CONSTRUCCION DE PROGRAMAS
x[i-1][i-1] = 1.0;
}
}
En sólo diez líneas hay seis goto. Antes de continuar leyendo, trate de
decir qué hace este programa?.
10 SMALL = X
20 IF Y < SMALL THEN SMALL = Y
30 IF Z < SMALL THEN SMALL = Z
Reescribiendo el código
CONST
MSG1 : STRING[20] = 'AREA BAJO LA CURVA';
MSG2 : STRING[23] = 'POR LA REGLA DEL TRAPECIO';
MSG3 : STRING[16] = 'PARA DELTA X = 1/';
VAR
I : INTEGER;
J : INTEGER;
64
MANUAL DE CONSTRUCCION DE PROGRAMAS
K : INTEGER;
L : REAL;
M : REAL;
N : INTEGER;
AREA1 : REAL;
AREA : REAL;
LMTS : REAL;
PROCEDURE OUT;
BEGIN
AREA := AREA + LMTS;
WRITELN (MSG3,K,AREA);
AREA := 0;
END;
BEGIN
WRITELN (MSG1);
WRITELN (MSG2);
WRITELN ;
AREA := 0;
FOR K := 4 TO 10 DO
BEGIN
M := 1 / K;
N := K - 1;
LMTS := 0.5 * M;
I := 1;
FOR J := 1 TO 10 DO
BEGIN
L := SQR(1 / K);
AREA1 := 0.5 * M * (2 * L);
AREA := AREA + AREA1;
IF I = N THEN OUT
ELSE I := I + 1;
END;
END;
END.
Para modificarlo: hacer una cosa a la vez. Poner los mensajes en sentencias
WRITE donde pertenecen. Eliminar las variables intermedias innecesarias.
Simplificar las inicializaciones y borrar el procedimiento innecesario. Combinar las
declaraciones restantes. El código se encoje ante sus ojos, revelando un algoritmo
simple.
PROGRAM TRAPECIO;
VAR
J,K : INTEGER;
AREA : REAL;
BEGIN
WRITELN ('EL AREA BAJO LA CURVA');
WRITELN ('POR LA REGLA DEL TRAPECIO');
WRITELN ;
65
CONSTRUCCION DE PROGRAMAS
FOR K := 4 TO 10 DO
BEGIN
AREA := 0.5 / K;
FOR J := 1 TO K-1 DO
AREA = AREA + (SQR(J/K)/K);
5) BREAK e ITERATE, que salen de un ciclo o saltan una parte del mismo.
Hay una tendencia a creer que sólo por usarlas (y sólo con ellas) se pueden
evitar todos los problemas. Esto es falso, no son la panacea. Un buen estilo,
cuidado e inteligencia, son necesarios. A continuación mostramos algunos vicios en
que se puede incurrir, aun con las estructuras de programación.
Entonces nulo
Se evalua una condición, que de resultar verdadera, no ejecuta acción alguna. Por
ejemplo, la siguiente rutina debería ordenar un arreglo de ocho números en orden
ascendente según su valor absoluto:
For i := 1 to 8 Do
If Abs(A[i]) < ABS (A[i+1]) Then ;
Else
Begin
Tmp := A[i];
A[i] := A[i+1];
A[i+1] := A[i];
End;
66
MANUAL DE CONSTRUCCION DE PROGRAMAS
2) Se hace una referencia fuera de los límites del arreglo cuando A[I+1] es
accedido en la última iteración, con I = 8;
For m .= 1 To N-1 Do
For j := 1 to N-1 Do
If Abs(A[j]) < ABS (A[j+1]) Then
Begin
Tmp := A[i];
A[i] := A[i+1];
A[i+1] := A[i];
End;
Var
i : Integer;
Begin
Read (i);
If i > 40000 Then WriteLn ('Número muy grande');
....
End
En caso de fallar la evaluación de la condición del If, entonces se "brinca" (sale de)
esa sección del código.
67
CONSTRUCCION DE PROGRAMAS
ENTONCES - SI
Intente decir qué hace este código cuando QTY = 350, y si QTY = 150.
68
MANUAL DE CONSTRUCCION DE PROGRAMAS
Lo cual asegura que I está dentro del rango antes de usarla como índice.
Lenguajes como Pascal o C proveen de conectores booleanos que garantizan la
evaluación (de derecha a izquierda) y la salida tan pronto como el valor de verdad
de la expresión sea determinado, por ejemplo:
Arboles frondosos
If X >= Y Then
If Y >= Z Then
SMALL = Z
Else
SMALL = Y
Else
If X >= Z Then
SMALL = Z
Else
SMALL = X
* Existen algunos algoritmos, como las búsquedas empleadas en juegos como ajedrez o gato; cuya base de funcionamiento es
expandir el árbol de posibilidades del juego y elegir la mejor rama para ganar.
69
CONSTRUCCION DE PROGRAMAS
l Resumen de If-Then-Else
If...
Then If.....
Else....
Else If....
Then If.....
Else....
l Ciclos
cuadro 4-2
Seis formas de decir: "HOLA MUNDO"
BASIC básico
10 PRINT "HOLA MUNDO"
20 END
Pascal básico
program Hola(input, output)
begin
writeln('Hola Mundo')
end.
Lisp básico
(defun hola
(print
(cons 'Hola (list 'Mundo))))
C con apuntadores
#include <stdio.h>
void main(void)
{
char *message[] = {"Hola ", "Mundo"};
int i;
C con trucos
#include <stdio.h>
#define S "Hola, Mundo\n"
main(){exit(printf(S) == strlen(S) ? 0 : 1);}
C orientado a objetos
71
CONSTRUCCION DE PROGRAMAS
#include <iostream.h>
#include <string.h>
class string
{
private:
int size;
char *ptr;
public:
string() : size(0), ptr(new char('\0')) {}
~string()
{
delete [] ptr;
}
friend ostream &operator <<(ostream &, const string &);
string &operator=(const char *);
};
ostream &operator<<(ostream &stream, const string &s)
{
return(stream << s.ptr);
}
int main()
{
string str;
cuadro 4-3
72
MANUAL DE CONSTRUCCION DE PROGRAMAS
l Confiabilidad
Un programa confiable es aquél que rara vez falla. Esto es de especial importancia
en programas que manejen gran cantidad de datos en una misma corrida, puesto
que si una secuencia de datos provoca la caída del programa es muy difícil detectar
qué dato en particular lo provocó.
x := -3.14;
While x < 3.14 Do
Begin
y := Sen(x) / Cos(x);
x := x + 0.1;
End;
73
CONSTRUCCION DE PROGRAMAS
l Mantenibilidad
l Transportabilidad
74
MANUAL DE CONSTRUCCION DE PROGRAMAS
3) Aislar lo más posible aquellas rutinas que exploten características propias del
hardware y documentarlas adecuadamente. Así podrán ser modificadas sin tener
que reconstruir todo el código.
No es posible hacer programas que funcionen para todas las máquinas. Aun así
conviene programar de la manera más transportable posible.
l Extensibilidad
1) Se requieren cambios
2) Deben añadirse nuevas funciones
3) Se deben explotar nuevas características del hardware.
Por ejemplo, este procedimiento ordena un arreglo de enteros:
Const
N = 10000;
Var
A : Array [1..N] Of Integer:
Procedure OrdenarEnteros;
Begin
For m .= 1 To N-1 Do
For j := 1 to N-1 Do
If Abs(A[j]) < ABS (A[j+1]) Then
Begin
Tmp := A[i];
A[i] := A[i+1];
A[i+1] := A[i];
End;
End;
75
CONSTRUCCION DE PROGRAMAS
Const
N = 10000;
Type
Persona = Record
Nombre,
Dirección : String;
Edad : Integer;
Telefono : String;
End;
Var
A : Array [1..N] Of Persona:
Procedure OrdenarRegistros;
Begin
For m .= 1 To N-1 Do
For j := 1 to N-1 Do
If Abs(A[j].Nombre) < ABS (A[j+1].Nombre) Then
Begin
Tmp := A[i];
A[i] := A[i+1];
A[i+1] := A[i];
End;
End;
l Generalidad
76
MANUAL DE CONSTRUCCION DE PROGRAMAS
Sin embargo observe que mientras más general es una rutina, es más difícil
su lectura ya que abarca gran cantidad de posibilidades que opacan la claridad del
algoritmo.
l Código reutilizable
Las tareas que se utilizan muchas veces dentro de un mismo programa suelen ser
también muy utilizadas en varios programas diferentes.
Tal es el caso de las rutinas que inicializan gráficos, manejan archivos, las
interfaces con el usuario, los módulos de entradas y salidas, los ordenamientos y
muchas más. Es realmente un desperdicio de tiempo reescribir estas rutinas cada
que se hace un programa nuevo.
l Eficiencia
Const
TOTAL_ESTRELLAS = 10000;
Var
i,X,Y,col,
MaxX,
MaxY,
MaxCol,
NumEstrellas: Integer;
Begin
Randomize;
{ Limpiar pantalla }
ClearDevice;
NumEstrellas := TOTAL_ESTRELLAS;
For i := 1 To NumEstrellas Do
Begin
MaxX := GetMaxX;
MaxY := GetMaxY
MaxCol := GetMaxColor;
{ Calcular coordenadas }
X := Random (MaxX);
Y := Random (MaxY);
{ Calcular color }
col := Random (MaxCol);
77
CONSTRUCCION DE PROGRAMAS
l Elegancia
Elegancia es una cualidad ambigua y muy relativa, sin embargo podemos considerar
que un programa es elegante cuando tiene un buen estilo de programación.
Resulta también elegante hacer programas cuyo código sea tan simple y
claro que su lógica sea evidentemente correcta.
l Interfaz amigable
De acuerdo a las necesidades particulares del usuario, la interfaz debe ser lo más
sencilla y agradable.
cuadro 4-4
¿Hice un buen programa?
Mi programa...
7o. ¿Tiene una interfaz que muestra suficiente información para que el
usuario sepa cómo usarlo?
78
MANUAL DE CONSTRUCCION DE PROGRAMAS
B. Construir funciones muy grandes (que exceden de dos páginas, por ejemplo).
Los programas o módulos muy grandes son difíciles de entender y mantener
79
CONSTRUCCION DE PROGRAMAS
4.4 El goto
Goto es una palabra que suele ser odiada y repudiada ante su sola mención. Sin
embargo, quien aspire a convertirse en un buen programador debe conocer el
concepto y aprender a manejarlo, pues así podrá recurrir a varios lenguajes,
transportar códigos y estudiar libros antiguos de programación.
80
MANUAL DE CONSTRUCCION DE PROGRAMAS
Pero ¿qué ocurre con la gran cantidad de código y algoritmos que fueron
escritos aplicando este primer elemento de control?, ¿o si el lenguaje no posee las
estructuras de programación, como ocurre con el lenguaje máquina?, ¿y si el
algoritmo que necesita sólo está disponible en diagrama de flujo?
cuadro 4-5
El goto enmascarado
Mas aún, ciertas instrucciones de los lenguajes de alto nivel son un goto casi
evidente:
en C: return/continue/break
en Pascal: exit, halt, case (puede sustituir saltos de manera estruturada)
en ASM: jmp, jne, jz,...
Las esctructuras
de iteración y
Los lenguajes de alto nivel suelen proveer las estructuras de control las llamadas a
necesarias para evitar al goto, pero los lenguajes de bajo nivel normalmente no las procedimientos
tienen (no considere sólo lenguajes para computadoras, incluso las calculadoras se traducen
científicas tienen facilidades de programación e incluso en los procedimientos como goto a
administrativos para organizaciones se usa el goto). Y aun cuando crea que no lo nivel de lenguaje
usa (véase el cuadro 4-5), puede abusar de él. máquina.
For .....
For ....
While ...
Begin
If cond Then Goto Stop;
....
End
Stop: WriteLn ('Se ha producido un error');
81
CONSTRUCCION DE PROGRAMAS
Thomas Murphy.
Actualmente hay una gran cantidad de lenguajes para las más diversas aplicaciones;
muchos son sólo productos de laboratorio, otros ya cayeron en desuso y otros son
muy utilizados.
La selección del lenguaje debe hacerse de acuerdo con las facilidades que
posea (eficiencia de los compiladores, herramientas de apoyo al desarrollo,
editores, librerías, etcétera), su disponibilidad en el mercado, e incluso las
preferencias del programador.
cuadro 4-6
Lenguajes procedurales
Fortran: Es muy útil para Aplicaciones numéricas fuera del mundo de las PC; y
facilita la comunicación con científicos.
82
MANUAL DE CONSTRUCCION DE PROGRAMAS
83
Ca pít u lo 5
v Documentación de
programas
86
DOCUMENTACIÓN DE PROGRAMAS
Cuadro 5-1
Documentación
MANUAL TECNICO O DE MANTENIMIENTO: Documentación destinada a los
programadores y sirve de referencia para darle mantenimiento a un sistema durante su vida
útil. Tiene dos niveles: Interna y Externa.
Documentación interna: Son los comentarios que se encuentran dentro del programa
fuente, y que describen detalles significativas para un programador.
87
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
1. Escoger los nombres de los identificadores con cuidado, de tal modo que su
significado se comprenda sin ambigüedades y explicarlos de manera detallada.
Ejemplos:
Var
lechuga : Integer;
q : Real;
Procedure Julia;
Ejemplos:
Var
i : Integer;
cont : Integer;
opción : Char;
Ejemplos:
Var
Cont1, Cont2 : Integer;
Aux, Aux1 : Integer;
Aux2 : Real;
Aux3 : Char;
Bandera : Boolean;
Vandera : Boolean;
88
DOCUMENTACIÓN DE PROGRAMAS
cuadro 5-2
NOTACION HUNGARA7
l Variables
89
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
Set1 : t_SetChar;
l Constantes
Utilizar mayúsculas en todas las letras; si son varias palabras separarlas con "_".
Por ejemplo:
Const
MIN = 0;
MAX = 100;
Var
ci : Integer; { contador de enteros }
l Procedimientos y Funciones
90
DOCUMENTACIÓN DE PROGRAMAS
cuadro 5-3
Los comentarios generales de un programa son:
l ¿Qué comentar?
Cuadro 5-4
Ejemplo de un encabezado con historial
UNIT PlotData; { versión 2.01 }
{ Versión 1.00 -
Rutina original ViewGraph, para datos reales
1.01 -
Se agrega el visualizador en coordenadas polares
1.02 -
Se hace rutina paralela para datos enteros
1.03 -
Se modifica la 1.01 para anexar datos a un mismo despliegue
2.00 -
Se generaliza la rutina para graficar indistintamente enteros
o reales. Se elimina la opcion en coordenadas polares.
Se optimiza el calculo de la retícula, eliminandose la
posibilidad de dimensionar directamente la ventana, y
calculándolo en base a una cantidad de Pixels por Division.
Se agrego la opcion para limpiar un área.
2.01 - Aumento de las posibilidades de casting para graficar
enteros cortos sin signo. Se agrega la función overview
para graficar datos sobre otros. Se añaden las rutinas
SetGridColor y SetDataColor. Se mantiene SetColors por, y
se colocó nuevamente SetDimVent, por compatibilidad.
Se mejora la rutina SetAutoRange. Se agregan rutinas para
91
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
etiquetar. }
2. Encabezado particular de cada rutina:
a) nombre de la rutina,
b) descripción de parámetros (entradas y salidas),
c) propósito de la rutina,
d) breve descripción del método aplicado,
e) bibliográfía o referencia a documentación externa.
cuadro 5-5
Ejemplos de subrutinas y parámetros comentados
Procedure CursorMouse(X,Y:Integer; var CURSOR:ARRCUR);
{OBJETIVO: Asigna la forma del cursor al cursor del ratón y
fija el punto de seleccion dentro de la forma del cursor.
PARAMETROS:
X,Y son los pixels dentro del cursor que contienen el
punto de selección (hot pixel).
CURSOR es un arreglo que describe la forma de cursor.
ARRCUR es un tipo definido como ARRAY[0..31] of INTEGER
}
{...........................................}
92
DOCUMENTACIÓN DE PROGRAMAS
6. No comentar lo obvio:
Por ejemplo:
m = i++; /* m toma el valor de i y luego i se incrementa en 1 */
8Rutina que aparece en Embree, Paul M. and Kimble, Bruce. C Languaje for Digital Signal
Processing. p.111. Prentice Hall, 1991.
93
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
cuadro 5-7
DESCRIPCION DE ALGORITMOS.
En los siguientes ejemplos se describe, con lenguaje cotidiano, el funcionamiento
de varios algoritmos
Inicio
Leer A,B
C=A+B
Escribir C
Fin
Inicio
SUMA = 0
CONTADOR = 1
Repetir
SUMA = SUMA + CONTADOR
CONTADOR = CONTADOR + 1
Hasta que CONTADOR = 100
Escribir SUMA
Fin
End;
Begin
Yp := GetMaxY - Trunc(Yr + GetMaxY/2);
End;
cuadro 5-8
Un ejemplo de código comentado
{ _______________________________________________________________________ }
{ _ UNIDAD MANEJADORA DE ARREGLOS DINAMICOS _ }
{ _ (arreglos de dos dimensiones) _ }
{ _ versión 1.0 Octubre, 1993 _ }
{ _ Jorge Vasconcelos Santillán _ }
{ _______________________________________________________________________ }
{ _---------------------------------------------------------------------_ }
{ _ > EXPLICACION: La unidad ArrBytes permite definir (dinámicamente) _ }
{ _ un arreglo de dos dimensiones en tiempo de ejecución. Se proveen _ }
{ _ las rutinas necesarias para inicializar y finalizar el arreglo, _ }
{ _ (de cualquier tamaño, para cualquier tipo de datos); y para leer _ }
{ _ e introducir valores en las casillas del arreglo. _ }
{ _ _ }
{ _ La unidad se basa en reservar un espacio de memoria (necesario _ }
{ _ para almacenar NxM casillas de un mismo tipo) y en calcular la _ }
{ _ posición interna de ese espacio equivalente a la casilla (i,j) _ }
{ _ mediante apuntadores a bytes. _ }
{ _ _ }
{ _ Se define una estructura para manejar los arreglos dinámicos, _ }
{ _ ArrByte, que soporta un apuntador a la memoria reservada, las _ }
{ _ dimensiones del arreglo, y el tamaño de los datos que se almace- _ }
{ _ nen. _ }
{ _ _ }
{ _ Para poder utilizar los arreglos antes deben inicializarse indi- _ }
{ _ cando las columnas y renglones necesarios y el tipo de dato que _ }
{ _ contendrán las casillas. Cuando se haya finalizado el uso del _ }
{ _ arreglo debe liberarse la memoria reservada para el arreglo, _ }
{ _ mediante la rutina de cierre del arreglo. _ }
95
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
{ _---------------------------------------------------------------------_ }
UNIT ArrBytes;
INTERFACE
{ ________________________________________ }
{ _ Tipo Disponibles _ }
{ ________________________________________ }
Type
ArrByte = Record
byTamDato : Byte; { Tamaño del tipo de datos de cada casilla }
wNumBytes, { Número de bytes de memoria reservada }
wMaxRen, { Total de renglones en en arreglo }
wMaxCol : Word; { Total de columnas en en arreglo }
pBuff : Pointer; { Apuntador a la memoria reservada }
End;
{ ________________________________________ }
{ _ Librería Disponible _ }
{ ________________________________________ }
{ _---------------------------------------------------------------------_ }
{ _ DESCRIPCION DE LAS RUTINAS _ }
{ _ _ }
{ _ InitArray: Inicializa Arreglo[wRen,wCol], teniendo cada celda datos _ }
{ _ de tamaño DataSize. _ }
{ _ _ }
{ _ CloseArray: Termina el uso del Arreglo indicado. _ }
{ _ _ }
{ _ InsertarDato: Asigna un valor a una casilla. Es equivalente a _ }
{ _ Arreglo[wRen,wCol] := Dato _ }
{ _ _ }
{ _ LeerDato: Regresa el valor contenido en una casilla. Equivale a _ }
{ _ Dato := Arreglo[wRen,wCol] _ }
{ _---------------------------------------------------------------------_ }
IMPLEMENTATION
{ ----------------------------------------------------------------------- }
Begin
With Arreglo Do
Begin
byTamDato := DataSize;
wMaxRen := wRen;
wMaxCol := wCol;
wNumBytes := wMaxRen*wMaxCol*byTamDato;
(* Tratar de validar mejor la reserva de memoria *)
if MaxAvail < wNumBytes Then
Begin
WriteLn('Memoria insuficiente para crear arreglo');
Halt(1);
End;
GetMem (pBuff,wNumBytes);
FillChar (pBuff^,wNumBytes+1,0);
End;
End;
96
DOCUMENTACIÓN DE PROGRAMAS
{ ----------------------------------------------------------------------- }
{ ----------------------------------------------------------------------- }
Var
wPosByte,
wPosDeRen,
wPosDeCol : Word;
pby : ^Byte;
Begin
With Arreglo Do
Begin
{Calcular posición del byte}
wPosDeRen := (wRen-1)*(wMaxCol*byTamDato);
wPosDeCol := (wCol-1)*byTamDato+1;
wPosByte := wPosDeRen+wPosDeCol;
{Transferir datos}
Move (Dato,pby^,byTamDato); {pby^ := Dato^}
End;
End;
{ ----------------------------------------------------------------------- }
{Transferir datos}
Move (pby^,Dato,byTamDato); { Dato^ := pby^ }
End;
End;
{ ----------------------------------------------------------------------- }
BEGIN
END.
97
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
El cuadro 5-10 muestra una plantilla que cuenta con elementos mínimos y
ejemplos para elaborar el manual técnico de su propio proyecto. Adecuelo a sus
necesidades y redáctelo con un lenguaje conciso y formal.
Para elaborar el manual técnico, el programador debe explicarse el programa a
sí mismo (como si fuese otro programador). No debe dejar detalles importantes
a su memoria, pues al cabo de un tiempo los olvidará.
cuadro 5-10
Plantilla general para un manual técnico
F Este es un modelo de los temas que puede incluir en el manual del usuario, algunas de las
secciones incluyen una redacción propuesta para abordar ese punto en particular, y otras sólo
mencionan qué deberá incluirse.
Indice
Apéndices, A-1.1
A-1. Formato de los archivos y pantallas.
A-2. Diagramas.
A-3. Listado del programa fuente.
A-4 Características Técnicas
Indice analítico.
99
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
θ 1)
X = r Cos (θ
θ 2)
Y = r Cos (θ
θ 3)
Z = r Cos (θ
4. Librerías requeridas
100
DOCUMENTACIÓN DE PROGRAMAS
F Haga una lista de los datos (con su respectivo tipo) que se utilizaron para probar
el programa y de los resultados que se obtuvieron.
Entrada Resultado
x:5.12
y:0.12
z:-1.2 m:16
l Puntos débiles:
l Futuras expansiones:
Tipo: archCampos
Descripción: Archivo con estructura campos.
Estructura: file of regCampos
Tipo: cad12
Descripción: Cadena de longitud 12.
Estructura: string [12]
Tipo: puntRegCad
101
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
l Constantes
l Variables globales
102
DOCUMENTACIÓN DE PROGRAMAS
Apéndices
Nombre String 30
Direccion String 50
Telefono String 7
Edad Byte 1
1 Tecla Cadena 20
3 CLN
4 CLN
5 CLN
A-2. Diagramas.
103
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
El manual del usuario, junto con la interfaz y las "ayudas", forman la carta
de presentación del programa, por lo que resultan primordiales. Todas las ventajas
que puedan tenerse, resultan inútiles cuando el usuario no entiende cómo usarlas.
104
DOCUMENTACIÓN DE PROGRAMAS
* Las "ayudas en línea" son parte de la interfaz del programa principal, y se encargan de enlazar
un grupo de archivos (con texto que describe el uso de algún elemento del programa) con el
programa. Básicamente, la ayuda en línea permite mostrar en pantalla las explicaciones, sin
alterar los contenidos anteriores de la pantalla, en cualquier momento de la operación del
programa. La cosntrucción del manejador de ayuda está bastante relacionada con la construcción
de la interfaz con el usuario, y rebasa los alcances de este libro.
105
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
Presentación
Al adquirir este producto usted da un paso adelante en tecnología, pues este sistema
convertirá su computadora en una poderosa herramienta para ____________. Con
XXXXXX usted podrá [mencionar características principales].
Antes de empezar, dedique algunos minutos a leer este manual, donde encontrará
toda la información que necesita para aprender a usar XXXXXX y obtener los máximos
beneficios.
1. Antes de Empezar
El producto que que usted adquirió consta de [número] diskettes de [tamaño] pulgadas,
[número] manuales, y [mencionar otras cosas].
106
DOCUMENTACIÓN DE PROGRAMAS
Le recomendamos que haga una copia de respaldo de los diskettes que acompañan este
producto, antes de iniciar el proceso de instalación. Guarde los originales en un lugar
seguro. Si no sabe cómo copiar discos consulte la sección [numero] de este manual.
Convenciones usadas
convención indicación
Negritas nombres de comandos, modificadores y texto que debe
escribirse exactamente como aparece
Cursiva parámetros, términos nuevos y texto que debe escribirse
de manera variable
MAYUSCULAS nombres: directorios, archivos y abreviaturas
< > teclas que deberán oprimirse
2. Instalación
1. Encienda su computadora.
2. Inserte el diskette de instalación en la unidad de discos A o B.
107
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
-----------------------------------------------------------------------------------------------
F Las siguientes secciones deberán redactarse según las características
propias de cada sistema
-----------------------------------------------------------------------------------------------
3. Conociendo su computadora
F Describa aquí los elementos previos que considera necesarios para que el usuario pueda
usar su programa.
Antes de desarrollar esta sección, piense a quién va dirigido el sistema. Por ejemplo, si el
producto es un tutorial para niños, conviene que proporcione mucha información previa, tanto
para el niño como para el padre.
l Descripción
l Aplicaciones principales
l Tipo de interface
l Facilidades y ayudas
l Soporte técnico
108
DOCUMENTACIÓN DE PROGRAMAS
1. Encienda su computadora.
2. Cambiese al subdirectorio [nombre].
3. Teclee [nombre] y oprima <ENTER>.
l Menú pricipal: mencionar cada una de las opciones que sean mostradas.
Es muy importante mencionar cómo salvar el trabajo, cómo recuperar
un trabajo salvado y cómo salir del programa.
l Obtención de ayuda: Qué teclas oprimir para obtener ayuda, qué tipo
de ayuda aparece, cómo quitar la ayuda, etcétera.
7. Apéndices
F Incluya información para los siguientes temas
109
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
l Glosario: incluya las palabras que no son del uso común del usuario
y se incluyen en el manual.
l Indice
cuadro 5-12
l Desarrollando el programa de instalación
Este programa puede ser tan sencillo, que sólo copie archivos de un lugar a otro, o tan
complejo que permita personalizar la instalación. Puede estar desarrollado en modo texto o en un
atractivo ambiente gráfico.
2. Copiar únicamente los archivos necesarios (ejecutables, datos, imágenes) para ejecutar el
programa.
110
Ca pít u lo 6
v Depuración de programas
112
DEPURACIÓN DE PROGRAMAS
Cuadro 6-1
CUATRO IDEAS VALIOSAS SOBRE DEPURACION
2o. Comenzar de nuevo suele ser más fácil que parchar un programa viejo.
4o. Los parches tienden a introducir tantos errores como los que corrigen.
I. Módulos vacíos
113
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
114
DEPURACIÓN DE PROGRAMAS
V. Datos de prueba
115
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
cuadro 6-2
♦ METODO DE CAJA NEGRA PARA
VERIFICACION DE ERRORES:
Considere al módulo como una caja negra que recibe un dato y arroja un resultado.
Usted debe evaluar si los resultados están acordes con las entradas proporcionadas.
Este método no evalúa la lógica del programa.
a) verificables manualmente,
b) típicos y realistas,
c) valores extremos y
d) valores ilegales.
Este método permite analizar la estructura lógica del programa, para ello utiliza los
datos que activen cada alternativa del programa.
Para utilizar este método debe probar cada una de las opciones que ofrece su
programa (y algunas que no ofrece).
Aplique este método a cada pequeño módulo conforme lo escriba y luego use
esos mismos datos en secciones más amplias.
if ((in=fopen("ARCH.DAT","r")) == NULL)
abre un archivo y lo asocia con el manejador in, pero en caso de que el archivo no
exista, se obtiene un valor de NULL.
116
DEPURACIÓN DE PROGRAMAS
int main ()
{
PUSH_DEP (ID_MAIN);
......
......
POP_DEP;
}
VIII. Validación
cuadro 6-3
VERIFICACIONES ANTES DE ENTREGAR PROGRAMAS
Asegurarse que el programa ejecutable corresponde a la última versión del programa fuente.
Efectuar una serie de pruebas finales, tanto en el programa fuente, como en el ejecutable, y
especialmente sobre los diskettes.
117
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
Por ejemplo:
If (A Mod 2) = 0 Then
impar := FALSE;
Else
impar := TRUE;
Por ejemplo:
Un error de lógica, muy común y también muy fácil de detectar, es que los
contadores o índices se pasen por uno o les falte uno.
Por ejemplo:
y = Sqrt (x);
118
DEPURACIÓN DE PROGRAMAS
cuadro 6-4
Ä VARIABLES
1. ¿Cada variable tiene un nombre diferente por módulo?, ¿El tamaño de los identificadores es
importante para el compilador?
2. ¿Se ha modificado el valor de una variable cuando ésta aún era útil, por ejemplo, en ciclos o
parámteros?
3. ¿Los subíndices de los arreglos son enteros y están dentro de los límites?
Ä CALCULOS
5. ¿Qué tipo de datos producen los cálculos y a qué variables se asignan?
8. ¿Un divisor es tan pequeño que provoca una división por cero?
10. ¿Se utilizó correctamente la jerarquía de operadores? La jerarquía llega a variar según el
lenguaje y la notación.
Ä COMPARACIONES
12. ¿Se comparan tipos simples con tipos simples y no con estructuras?
15. ¿Se utilizaron adecuadamente los operadores booleanos de los relacionales? (recuerde A>B OR
C es diferente de A>B OR A>C?
9Basada en una idea de G.J. Myers (The Art of Software Testing), publicada en Enciclopedia Práctica de Inforática, Vol. 3.
Ediciones Algar. España, 1986.
119
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
Ä CONTROL
17. ¿Los ciclos y los algoritmos terminan sin importar el caso?
18. ¿Los ciclos y los algoritmos tienen un solo punto de entrada y un solo punto de salida?
21. ¿Hay errores de stack debidos a un exceso de llamadas recursivas o de variables locales?
Ä LIBRERIAS
22o. ¿Están actualizadas las librerías?
Ä ARCHIVOS
25. ¿Los archivos de configuracióm son correctos?
30. ¿Se vació el buffer de transferencia de archivos, antes de salir del programa?
Ä APUNTADORES
31. ¿Hay memoria suficiente para cada nuevo apuntador?
32. ¿Se reservó la memoria necesaria antes de utilizar el apuntador para guardar datos?
120
DEPURACIÓN DE PROGRAMAS
Los errores durante la ejecución del programa son inevitables, por lo que un
manejo elegante de ellos es importante en un buen programa. Aquí hay cuatro
sugerencias para manejar los errores cuando ocurran.
If Code < 3 Then Halt(code+300); {Evitar colisión con los errores estándar de DOS}
End;
121
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
Begin
Case Codigo Of
{Error} 0 : Error(3);
255 : Error(4);
{funcionamiento normal}
1 : Cero (Parametros[1]);
2 : Sumar (Parametros[1]);
3 : Copiar (Parametros[1],Parametros[2]);
4 : Saltar (Parametros[1],Parametros[2],Parametros[3]);
End;
cuadro 6-5
SUGERENCIAS DE PROGRAMACION CON LISTAS LIGADAS10
4. Verifique que su algoritmo funciona para un lista vacía y para una lista con sólo
un nodo.
5. Trate de referenciar sólo un nodo a la vez (es decir, evite las construcciones del
tipo p^.liga^.liga^.dato). Las referencias repetidas indican que el algoritmo
puede mejorarse.
6. Evite que dos apuntadores señalen a un mismo nodo, salvo que uno de los
apuntadores sea para recorrer una lista.
122
DEPURACIÓN DE PROGRAMAS
cuadro 6-6
Estos son errores con los que se ha topado el autor, puede ocurrir que bajo
circunstancias diferentes, no se presenten. Hay que tener en mente que algunos de
estos errores se deben a las directivas de compilación, y algunos se corrigen con un
coprocesador matemático o la librería de emulación correspondiente.
Program Errores_Deliberados;
Var
i1,i2,i3 : Integer;
r1,r2,r3: Real;
a : Array [1..10] of Char;
f : File;
Begin
i1 := 32767; ç límite de los enteros de dos bytes
i2 := 1;
r1 := sqrt(i1+i2); ç la evaluación se hace entera, dando un número negativo y
"tronando" el programa.
i1 := 6;
i2 := 6;
a[i1+1] := '5';
a[i1+i2] := '7'; ç el subíndice queda fuera de rango
Assign (f,'AUX.DAT');
Rewrite (f,1);
BlockWrite (f,a,10); ç el sistema reportará un error de dispositivo no preparado
(o similar). Esto se debe a que AUX es un archivo predefinido
por el DOS e ignora la asignación anterior.
Close (f);
123
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
/* SERIE DE FIBONACCI */
#include <stdio.h>
#include <conio.h>
main()
{
unsigned int a,b,c,num;
clrscr();
a = b = 1;
printf ("\n\n%u %u ",a,b);
for (num=1;num<=100;num++){
c = a + b;
printf ("%u ",c);
a = b;
b = c;
}
}
F Al ejecutar este programa se observa que los primeros resultados son correctos,
pero tras algunas iteraciones empiezan a salir mal. Esto se debe a que
se sobrepasa el límite superior de los números enteros , y en lugar de
producirse un error, la variable empieza a tomar valores a partir del
límite inferior de los enteros (esta es una característica de los números
representados mediante complemento a dos).
Const
MAX = 15;
Var
i : Integer;
Input : Array [1..MAX] Of Real;
dx,x : Real;
Begin
dx := 2*PI / MAX;
x := 0.0;
i := 1;
F Tal como está este programa se cicla infinitamente o provoca un error de fuera de
rango. Esto se debe a que para completarse el rango (0 <= x <=2*Pi) se
debe iterar 16 veces (no 15). Si no se detecta que el índice se salió de rango,
entonces ese último ciclo provoca que se corrompan las
variables dx y x perdiéndose la condición de parada.
124
DEPURACIÓN DE PROGRAMAS
Var
Sx, Sy,
X,Y,Z : Integer;
Begin
Sx := D * X / Z; ç La operación D * Z se efectúa como multiplicación de
Sy := D * Y / Z; enteros y con el resultado se hace la división real.
End;
Var
Sx, Sy,
X,Y,Z : Integer;
Begin
Sx := D * (X / Z); ç La operación X / Z se efectúa como división de reales
Sy := D * (Y / Z); y con el resultado se hace la multiplicación real.
End;
Var
i,r : real;
Begin
i := 0.0;
While i <= 2*Pi Do
Begin
writeln (sin (i));
writeln (cos(i));
r := 1 / (sin (i) + (Cos (i)-1));
WriteLn (r);
i := i + 0.5;
End;
End.
125
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
Program PuntoFlotante;
Var
h,x,y,e,f,q : Real;
Begin
H := 1/2; ç 1/2 = 0.5
X := 2/3 - H; ç 2/3 - 1/2 = 1/6 = 0.166666...
y := 3/5 - H; ç 3/5 -1/2 = 1/10 = 0.1
E := (x+x+x) - H; ç 3/6 - 1/2 = 0
F := (y+y+y+y+y) - H; ç 5/10 - 1/2 = 0
Q := E/F ; ç aquí debería producirse un error.
End.
126
Ca pít u lo 7
v Optimización de
programas
cuadro 7-1
Program Copy1; { Versión ineficiente }
Var
fOld,
fNew : File;
by : Byte;
Begin
{ abrir archivo original }
Assign (fOld,'ARCHIVO1.DAT');
Reset (fOld,1);
{ cerrar archivos }
Close (fOld);
Close (fNew);
End.
{--------------------------------------------------------------------}
128
OPTIMIZACIÓN DE PROGRAMAS
Var
fOld,
fNew : File;
buffer : Array[1..MAX_BUFF] of byte;
Begin
{ abrir archivo original }
Assign (fOld,'ARCHIVO1.DAT');
Reset (fOld,1);
{ cerrar archivos }
Close (fOld);
Close (fNew);
End.
Los programas que manejan muchos datos mediante archivos, como los
manejadores de bases de datos, deben efectuar las actualizaciones físicas al final de
la sesión; por ejemplo, no conviene borrar cada vez que se ordena eliminar un
registro, sino marcarlo y al terminar de usar el programa entonces borrar
físicamente todos los registros borrados.
Para evitar que el usuario se aburra, conviene que los archivos se lean y
escriban mientras el usuario está ocupado haciendo alguna otra cosa (por ejemplo,
leer instrucciones).
129
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
A = ac + ad + bc + bd
Esta expresión requiere de tres divisiones y dos sumas (la resta es una suma con
signo negativo). Observe cómo podemos reacomodar los términos para optimizar
las operaciones:
x y+ x
1+
y y y+ x
= =
x y− x y− x
1−
y y
Por lo tanto, la última expresión sólo contiene dos sumas y una división:
y + x
m =
y − x
130
OPTIMIZACIÓN DE PROGRAMAS
Si n es par
y = x 2
P = xn = n
P = y ⋅ y ... y ⋅ y ( 2 veces)
Si n es impar
y = x2
n-1
P = x n = Q = y ⋅ y ... y ⋅ y ( veces)
2
P = x ⋅ Q
5. Evite calcular un mismo valor una y otra vez en los ciclos, calcule afuera e
incorpórelo como una variable. Evite también llamadar repetidamente funciones
que regresen el mismo valor en cada iteración (véase el ejemplo del cuadro 7-2).
cuadro 7-2
Procedure PintarEstrellas;
{ Colocar aleatoriamente puntos en la pantalla,
para simular estrellas }
Const
TOTAL_ESTRELLAS = 10000;
Var
i,X,Y,col : Integer;
Begin
Randomize;
{ Limpiar pantalla }
ClearDevice;
For i := 1 to TOTAL_ESTRELLAS Do
Begin
{ Calcular coordenadas }
131
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
X := Random (GetMaxX); ç Durante todo el ciclo se hace una llamada a las función
GetMaxX
Y := Random (GetMaxY); ç Durante todo el ciclo se hace una llamada a las función
GetMaxY
{ Calcular color }
col := Random (GetMaxColor); ç Durante todo el ciclo se hace una llamada a las función
GetMaxColor
{------------------------------------------------------------------------}
Procedure PintarEstrellas;
{ Colocar aleatoriamente puntos en la pantalla,
para simular estrellas }
Const
TOTAL_ESTRELLAS = 10000;
Var
i,X,Y,col : Integer;
MaxX,MaxY,
MaxCol : Integer;
Begin
Randomize;
{ Limpiar pantalla }
ClearDevice;
For i := 1 to TOTAL_ESTRELLAS Do
Begin
{ Calcular coordenadas }
X := Random (MaxX);
Y := Random (MaxY);
{ Calcular color }
col := Random (MaxCol);
F La rutina putpixel consume mucho tiempo, por ello es mejor calcular y guardar los valores y
despues sólo graficarlos. Esto se muestra en el siguiente programa.
{-------------------------------------------------------------------------------------------------------------------}
Procedure PintarEstrellas;
{ Colocar aleatoriamente puntos en la pantalla,
para simular estrellas }
132
OPTIMIZACIÓN DE PROGRAMAS
Const
TOTAL_ESTRELLAS = 10000;
Type
Punto = Record
X,Y,Col : Integer;
End;
Var
i,X,Y,col : Integer;
MaxX,MaxY,
MaxCol : Integer;
Begin
Randomize;
{ Limpiar pantalla }
ClearDevice;
For i := 1 to TOTAL_ESTRELLAS Do
Begin
{ Calcular coordenadas }
X := Random (MaxX);
Y := Random (MaxY);
{ Calcular color }
col := Random (MaxCol);
{ Colocar estrellas }
For i := 1 to TOTAL_ESTRELLAS Do
With Estrellas[i] Do
PutPixel (X,Y,col);
End.
133
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
10. No permita que nadie le diga que un código claro o bien hecho no es eficiente,
solamente que le sea probado y le sea medido.
l Conceptos
El empleo de Hay una tendencia a creer que el uso de apuntadores revoluciona y mejora sus
memoria programas. Así mismo, suele confundirse memoria dinámica con apuntadores.
dinámica no hace
que una El apuntador en sí es una variable estática (es una localidad de memoria de
aplicación sea cuatro bytes, que guarda el número que le corresponde a otra localidad de
más rápida que memoria), que es indispensable para el manejo de memoria dinámica, pero que
su puede usarse en memoria estática.
implementación
con variables
estáticas. Algunos programadores llegan a creer que nunca deberían usar el
indexamiento de arreglos porque los punteros son más eficaces.
134
OPTIMIZACIÓN DE PROGRAMAS
l Desventajas:
135
CASOS PRACTICOS DE PLANEACION
Apé n dice
v Casos prácticos de
planeación de programas
137
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
Para ilustrar mejor estas ideas, en esta sección presentamos dos casos:
• El diseño de un programa para controlar un inventario bibliotecario.
• El análisis para elaborar un programa que administre un registro civil.
138
CASOS PRACTICOS DE PLANEACION
139
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
Los índices secundarios también constan de dos campos, uno para el autor
(o el título) y otro para la clasificación . De este modo al buscar un título se
obtendrá la clasificación del libro y luego deberá buscarse en el índice primario
hasta encontrar el número de registro de la ficha bibliográfica correspondiente (fig.
A-1). Por comodidad llamaremos AUTOR y TITULO a estas estructuras:
140
CASOS PRACTICOS DE PLANEACION
Estas rutinas son la interfaz con el usuario y deben estar hechas de tal modo que los
datos mostrados resulten fáciles de entender y manipular por el usuario.
Conviene que la primera versión del programa utilice rutinas muy sencillas
(para no desviar la atención del problema principal) pero suficientemente robustas
para tratar los datos adecuadamente. De ser necesario después se emigrará hacia
una interfaz más compleja.
Por otra parte, la rutina Mostrar recibe cómo parámetro una variable de
tipo LIBRO y envia su contenido a la pantalla.
141
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
Diagrama
de los
módulos
• Menú principal
El menú principal sirve para que el usuario elija alguna de las principales funciones
del programa. En este caso las opciones son: (1) altas, (2) bajas, (3) cambios,
(4) consultas, y (5) terminar.
142
CASOS PRACTICOS DE PLANEACION
• Módulo de altas
Este módulo registra las fichas bibliográficas nuevas. Para ello solicita al operador Algoritmo
los datos de indentificación del libro y les agrega automáticamente la clave de de cada
clasificación. Enseguida guarda los datos en el archivo principal y actualiza los módulo
índices.
El algoritmo seguido por este módulo es:
1º Leer ficha bibliográfica y guardar sus datos en LIBRO (utilizando la rutina
Captura/Edición).
2º Agregar CLAVE de clasificación a LIBRO (utilizando la rutina Generar Clave).
3º Actualizar archivos con la información contenida en LIBRO.
• Módulo de consultas
Este módulo recupera una ficha bibliográfica a partir de alguno de sus datos: la
clave, el autor o el título. Como se tienen varias posibilidades su funcionamiento se
controla con un menú cuyas opciones son: (1) clave, (2) autor, y (3) título.
Este módulo utiliza dos diferentes estrategias de búsqueda (fig. A-3), una
para el índice primario y otra para los índices secundarios (autor y título).
143
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
El algoritmo seguido por las dos consultas secundarias (autor o título) es:
1º Leer LLAVE (autor o título).
2º Buscar LLAVE en el índice secundario correspondiente y devolver la CLAVE de
clasificación asociada.
3º Utilizar CLAVE para recuperar el registro haciendo una consulta primaria.
Estos dos últimos pasos deben efectuarse varias veces por que una misma
llave secundaria pueden tener varias claves asociadas (por ejemplo, cuando un
mismo autor ha publicado varios libros).
• Módulo de cambios
Este módulo permite modificar alguno de los datos guardados. Para ello solicita la
clave del libro y localiza la ficha correspondiente, mostrándola y permitiendo su
edición.
• Módulo de bajas
Este módulo se encarga de eliminar un registro no deseado. El operador sólo tiene
acceso al borrado lógico con lo cual podría recuperarlo en cualquier momento
durante la sesión de trabajo. El programa automáticamente deberá hacer las bajas
físicas al terminar la sesión.
144
CASOS PRACTICOS DE PLANEACION
El borrado físico consiste eliminar del archivo principal todos los registros
que hayan sido borrados lógicamente.
Para reconstruir los índices basta borrar los archivos de éstos y leer cada
uno de los registros del archivo principar para obtener los datos de clave, autor y
título y construir los índices de manera similar a la captura desde teclado.
• Módulo de actualización
145
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
Definición El registro civil es la institución que acredita los actos relacionados con el estado y
del capacidad de las personas, como su nacimiento o su enlace matrimonial. En sus
problema oficinas se efectúan los procedimientos necesarios para dejar constancia de tales
hechos.
• Panorama general
Análisis El diagrama de contexto nos permite identificar todos los datos que estarán en
del movimiento, así como las personas involucradas en su manejo (fig A-5).
problema
Los principales datos que fluirán a través del programa son el nombre de
los participantes, las actas civiles, las referencias de localización, la identificación de
la oficina, el tipo de acto efectuado y la autorización de actos.
146
CASOS PRACTICOS DE PLANEACION
• Componentes principales
El diagrama de nivel "0" sirve para identificar las principales actividades realizadas
y agruparlas en rubros cualitativamente diferentes. En el problema del registro civil
encontramos cuatro grandes rubros: (i) registro de los actos, (ii) expedición de las
constancias, (iii) emisión de reportes, y (iv) actualización de los datos (fig. A-6).
En el mismo diagrama podemos identificar claramente cuáles datos son entradas y
cuáles son salidas, según indique la flecha del flujo.
Figura A-6. Diagrama de nivel 0; principales componentes del programa para registro civil.
147
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
• Registro de actos
Este diagrama nos muestra los procesos involucrados en el asentamiendo de datos
de un acto civil. La figura A-7 nos muestra que básicamente hay tres procesos:
• La captura de datos. Toda la información relacionada con el acto será
concentrada en un formato especial que pueda ser revisado antes de elaborar el
acta oficial y así minimizar los errores.
• El registro en el libro de actas. Dependiendo del acto celebrado (nacimiento,
matrimonio o defunción) se efectuará un vaciado de los datos del formato en el
libro correspondiente.
• Emisión de constancias. Este documento servirá para comprobar que se
verificó el acto en tanto se puede emitir una copia certificada del acta.
• Expedición de constancias
Este diagrama nos muestra los procesos para comprobar documentalmente la
realización de un acto civil. La figura A-8 nos muestra que básicamente hay tres
procesos:
• Preparar un patrón de búsqueda. Consiste en recabar los datos necesarios
para el acta localizar en el libro correspondiente. En este caso se requieren: el
tipo, la fecha del acto y el número de referencia del acta.
• Búsqueda del patrón. Consiste en revisar el libro de actas hasta encontrar
aquélla que corresponde a los datos solicitados en el patrón.
• Emisión de constancias. Este documento servirá para comprobar que se
localizó el acta en tanto se puede emitir una copia certificada.
148
CASOS PRACTICOS DE PLANEACION
• Emisión de reportes
Este diagrama muestra los procesos para elaborar listas de los actos realizados. En
la lista pueden abarcarse todos los actos o sólo aquéllos que cumplen con alguna
caracteristica en común (el tipo de acto, el período de realización, la coincidencia
de apellidos, etc.). La figura A-9 nos muestra que básicamente hay tres procesos:
• Preparar un patrón de búsqueda. Consiste en recabar ciertos datos que
limiten la cantidad de actas a ser incluídas en el reporte.
• Búsqueda del patrón. Consiste en revisar los libros para encontrar cada acta
que cumpla con los datos solicitados en el patrón.
• Emisión del reporte. Este proceso imprimirá la lista de actos que cumplieron
con las especificaciones del patrón de búsqueda.
149
MANUAL DE CONSTRUCCIÓN DE PROGRAMAS
Figura A-10. Diagrama de nivel 1 del subprograma para modificación o cancelación de actas.
150
CASOS PRACTICOS DE PLANEACION
151
Indice
acoplamiento, 46 diseño, 16
acoplamiento de contenido, 47 diseño de sistemas, 16
acoplamiento de control, 47 diseño del algoritmo, 31
acoplamiento de datos, 47 documentación, 86
acoplamiento de zonas, 47 documentación interna, 90
algoritmo, 34
analistas, 2 eficiencia, 77
análisis, 16 elegancia, 78
análisis del problema, 31 errores de ejecución, 118
aplicaciones de alto nivel, 62 errores de lógica, 118
aplicaciones de bajo nivel, 62 errores de sintaxis, 118
apuntador, 134 errores inesperados, 123
archivoos, errores en, 120 especificación de requerimientos, 15
especificaciones de proceso, 25
buffer, 22 especificaciones estructuradas de proceso, 19
burbuja, 21 estilo, 62
extensibilidad, 75
código reutilizable, 77
códigos de error, 116 flujo de datos, 21
caja de cristal, 116 for, 66
caja negra, 116 funciones, 45
calculos, errores en, 119 generalidad, 76
ciclo de vida del software, 14 goto, 80
ciclo determinístico, 45
ciclo indeterminado, 45 if-then-else, 66
cohesión, 46 implementación, 17
cohesión coincidental, 48 impresión de listados, 114
cohesión lógica o temporal, 48 interfaz, 78
comparaciones, errores en, 119
confiabilidad, 73 librerías, errores en, 120
construccion de diagramas de flujos de datos, 23 lista de comprobación de errores, 119
control, errores de, 120
corrutinas, 45 módulos manejadores, 113
módulos vacíos, 113
datos de prueba, 115 macro, 45
datos de prueba, 112 manejadores de grupos de bytes, 135
definición del problema, 30 mantenibilidad, 74
depositos de datos, 22 mantenimiento, 31
depuración difícil, 112 manual del usua, 98, 104
depuración profunda, 112 manual para el usuario, 98, 104
depurar, 112 memoria dinßmica, 136
desarrollo de sistemas, 13 metodologías estructuradas, 19
diagrama de flujo de datos, 19 modelo, 13
diagramas de estructura, 56 modelo cascada, 14
diagramas de estructura, 56 modelo espiral, 14
diagramas de flujo, 41
diccionario de datos, 19 optimización, 128
diccionario de datos, 24
diseñadores, 2 paquetes de información, 21
153
patrón básico de programas, 45
pila de depuración, 117 sistema, 12
planeación, 4 sistema computacional, 13
primitivas funcionales, 24 sistema de información, 12
problema, 30 subrutina, 45
proceso, 21 subrutina recursiva, 45
programa, 34
programa eficiente, 128 trabajo de escritorio, 4
programación estructurada, 42 transportabilidad, 74
programación modular, 45 trucos, 79
programación y pruebas, 31 validación, 117
programador, 2 variable estática, 134
prototipos, 17 variables, errores en, 119
prueba, 112 while, 68
pseudocódigo, 35