LenguajesAlgoritmicosExcelente

8/3/2019 LenguajesAlgoritmicosExcelente

http://slidepdf.com/reader/full/lenguajesalgoritmicosexcelente 1/252

Realizó: Ing. Domingo Olivares Barrios Pág. 1

LENGUAJES ALGORITMICOS

ÍNDICE

1. - Introducción y conceptosbásicos. ................................................ 81.1. - Lenguaje................................................ 81.2. - Programación. ...................................... 81.3. - Programa. ............................................. 81.4. - Lenguaje de programación. .................. 91.4.1. Lenguaje Máquina................................ 91.4.10. – Semántica. ..................................... 121.4.2. Lenguajes de Alto Nivel........................ 91.4.3. – Traductores. ...................................... 9

1.4.3.1. – Intérpretes. ...................................... 91.4.3.2. – Compiladores. ................................ 91.4.4. – Palabras reservadas........................ 101.4.5. – Código. ............................................ 101.4.5.1. - Código fuente. .............................. 101.4.5.2. – Código objeto. .............................. 101.4.5.3. – Código ejecutable......................... 101.4.6. – Compilación. ................................... 101.4.7. – Enlazado. ......................................... 111.4.8. – Librerías. ......................................... 111.4.8.1. – Librerías preenlazadas.................. 11

1.4.9. – Sintaxis. ........................................... 111.5. - Sistema informático o aplicación........ 121.6. - Programador....................................... 121.7. - Técnicas de programación.................. 121.8. - Usuario. .............................................. 12

10. – Introducción a la Programación Dirigida porlos Datos......................................... 197

10.1. – Programación Código-Fijo (Hard-

Code). ..................................................... 19710.2. – Programación Dirigida por los Datos(Data-Driven). ........................................ 198

10.3. – Diccionario de datos. ..................... 20210.4. – Programación de plantillas. ........... 20210.4.1. - ¿ Qué es una plantilla ? ............... 20210.4.2. – Ventajas de una plantilla............. 20310.4.3. – Cuando utilizar una plantilla. ..... 20310.4.4. – Generadores de Código............... 203

11. – Introducción a la Programación Orientada al Objeto. ...............................................205

11.1. – Introducción. ...................................20511.2. – Vocabulario OOPS..........................20611.3. – Conceptos básicos. ..........................20611.4. – Clarificando conceptos. ..................20811.4.1. - ¿ Qué es una clase ? .....................20811.4.2. - ¿ Qué es un objeto ? .....................20911.4.3.- El concepto de herencia. ................20911.4.4.- El concepto de jerarquía................20911.5. – Conclusiones. ..................................21011.5.1. – Lo mejor. ......................................21011.5.2. – Lo peor. ........................................21011.5.3. – Posibles soluciones. .....................210

12. - Introducción a la Programación dirigida poreventos. .............................................211

13. - Documentación de programas......................................215

13.1.- Manual del Sistema...........................21513.2. - Manual del programa. .....................21613.3. - Manual del usuario. .........................216

2. - Tipos y estructurasbásicas de datos. ........................13

2.1. - Dato. ....................................................132.2. - Tipos de datos. .....................................132.2.1. - Datos numéricos. ..............................13

2.2.2. - Datos tipo carácter. ..........................132.2.3. - Datos alfanuméricos, de cadena o

string. ........................................................142.2.4. - Datos lógicos (booleanos). ...............142.3. - Constantes, variables y funciones. .......142.4. - Expresiones. .........................................142.4.1. - Expresiones aritméticas. ...................152.4.2. - Expresiones alfanuméricas. ..............16




2.4.3. - Expresiones lógicas (booleanas)...... 162.4.3.1. - Operadores de relación.................. 162.4.3.2. - Operadores lógicos........................ 172.4.4. – Reglas globales de prioridad o

precedencia. ............................................. 182.5. - Arreglos (arrays)................................. 18

2.5.1. - Arreglos unidimensionales............... 182.5.2. - Arreglos bidimensionales................. 192.5.3. - Arreglos multidimensionales. .......... 19

3. - Técnicas deProgramación............................. 20

3.1. - Importancia. ........................................ 203.2. - Objetivo. .............................................. 203.3. - Estilos de programación. .................... 203.4. La Notación Húngara y otras

convenciones. ........................................... 21

4. - Técnica de diseño generalo elemental. ................................... 27

4.1. - Fases de resolución de problemas. ..... 274.2. - Simbología de diagramas de bloques o

diagramas de flujo de sistemas. ............... 334.3. - Simbología de diagramas de flujo. ..... 344.4. - Recomendaciones para el desarrollo de

diagramas. ................................................ 354.4.1. - Diagramas de bloques o diagramas de

flujo de sistemas. ...................................... 35

4.4.2. - Diagramas de flujo. ......................... 354.5. - Resolución de problemas aplicando la

Técnica de diseño general o elemental. ... 36

5. - Diagramas de flujo. ........... 485.1. - Tipos de diagramas de flujo. ............... 485.1.1. - Diagramas de flujo lineales. ............ 485.1.2. - Diagramas de flujo cíclicos. ............ 485.2. - Estructuras de diagramas de flujo

lineales. .................................................... 485.2.1. - Estructura de secuencia. .................. 48

5.2.2. - Estructura de decisión. .................... 495.2.3. - Ramificaciones. ................................ 495.3. - Estructuras de diagramas de flujo

cíclicos...................................................... 505.3.1. - Creación de ciclos, iteraciones o

bucles........................................................ 505.3.2. - Pasos de un ciclo o bucle. ................ 505.3.3. - Ciclos o bucles anidados. ................ 51

5.3.4. - Estructura de " para hasta ". ............515.3.5. - Estructura de " hacer mientras ". .....535.3.6. - Estructura de " hacer hasta ". (repetir

hasta).........................................................54

6. - Herramientas de

programación. ..............................566.1. - El contador. .........................................566.2. - El acumulador o sumador....................566.3. - La bandera o indicador. ......................576.4. - Salida de un programa por opción. .....586.5. - Salida de un programa por centinela. .596.6. – Subrutinas, procedimientos y funciones.

...................................................................596.6.1.- Subrutinas. .........................................596.6.2.- Procedimientos...................................636.6.3.- Funciones. ..........................................63

6.6.3.1.- Funciones Implícitas. ......................646.6.3.2.- Funciones de Usuario......................646.6.4.- Parámetros en procedimientos y

funciones. ..................................................646.6.4.1.- Parámetros por valor.......................646.6.4.2.- Parámetros por referencia (por

variable).....................................................666.6.5.- Variables en procedimientos y

funciones. ..................................................676.6.5.1.- Variables Globales..........................676.6.5.2.- Variables Locales............................67

6.6.5.3.- Reglas de ámbito.............................676.6.5.4.- Efectos laterales. .............................696.6.6.- Recursividad. .....................................716.7. - Encadenamiento de programas. ..........74

7. - Técnica de diseño modular. ............................................75

7.1. - Fases de resolución de problemas. ......757.2. - Estructuras jerárquicas o en árbol. .....757.3. - Resolución de problemas aplicando la

Técnica de diseño modular........................78

8. - Técnica de diseño descendente. .................................100

8.1. - Fases de resolución de problemas. ....1008.2. - Resolución de problemas aplicando la

Técnica de diseño descendente. ..............102




9. – Introducción a la programación para gestión de archivos. .................................. 117

9.1. - Conceptos básicos............................. 1179.1.1. - Archivo. .......................................... 117

9.1.2. - Campo. ........................................... 1179.1.3. - Registro. ......................................... 1179.1.4. - Base de datos. ................................ 1189.2. - Tipos de Archivos y accesos.............. 1199.2.1. - Archivos secuenciales .................... 1199.2.2. - Archivos directos............................ 1199.2.3. – Archivos indexados........................ 1199.2.4. – Otros tipos de archivos. ................ 1209.3. – Bases de datos. ................................. 1209.3.1. - ¿ Qué es un SGBD ? ...................... 1209.3.2. – La independencia de los datos. ..... 1219.3.3. – Lenguajes y Bases de Datos. ......... 1229.3.4. – Los tres enfoques. .......................... 1229.3.4.1. – Enfoque jerárquico. .................... 1229.3.4.2. – Enfoque de red (Codasyl). .......... 1249.3.4.3. – Enfoque relacional...................... 1259.3.5. – Diseño de Bases de Datos. ............ 1279.3.6. – El modelo Entidad-Relación.. ....... 1289.3.7. – Normalización. .............................. 1319.3.7.1. – Formas normales. ....................... 1329.3.8. – Índices y ordenaciones. ................. 1359.3.9. – Lenguajes de cuarta generación (4GL).

................................................................ 1379.4. – Gestión de archivos de datos............ 1389.4.1. – Gestión de archivos secuenciales. . 142

9.4.2. – Gestión de archivos directos. .........1599.4.3. – Gestión de archivos indexados. ......1749.4.4. – Gestión de una base de datos

relacional constituida por dos archivos..190

APENDICE A.............................222

APENDICE B.............................225 APENDICE C .............................227

BIBLIOGRAFIA.....................252

IMPRESIÓN DE UNA LISTA ENLAZADA........................................237

INSERCIÓN EN UNA LISTA ENLAZADA........................................238

LIBRERIAS ...........................................222

OBJETIVOS...........................................7

PILAS, COLAS, COLAS DOBLES,ÁRBOLES BINARIOS. .................246

PREFACIO......................................................5PROGRAMACION SEGMENTADA

.................................................................225PRÓLOGO......................................................4PUNTEROS Y LISTAS

ENLAZADAS. ...................................229S O L U C I O N E S ...................................218

SUPRESIÓN EN UNA LISTA ENLAZADA........................................242VARIABLES DINÁMICAS.............227




PRÓLOGO

Puesto que no se puede ser universal y saber todo lo que se puede saber acerca de todo, hayque saber poco de todo. Porque es mucho más hermoso saber algo de todo que saber todo de unacosa. Blaise Pascal (Pensamientos, 37)

Fue Confucio quien dijo, <<Lo que oigo lo olvido, lo que veo lo recuerdo, lo que hago locomprendo>>.

Este libro se ha escrito con esas ideas en mente. He llenado este libro de ejemplos,especialmente en el capítulo <<soluciones>>, de manera que pueda ver y entender cómo las teorías yconceptos presentados son aplicables a situaciones de empresa de la vida real.

El presente trabajo, lo inicie por Marzo de 1993, con la idea de hacer un manual que unificaracriterios y se utilizara como guía para los maestros de una escuela donde, desde su fundación, participecomo catedrático y finalmente como director administrativo. Sin embargo, en ese tiempo por diversascircunstancias, a pesar de que se estrenaba la materia de Lenguajes Algorítmicos (la cual propuse que se

implantara), ni el manual ni yo, tuvimos el tiempo ni la aceptación suficiente, de mis compañeros, ni dela dirección académica, para presentarlo y mucho menos aplicarlo (en otras palabras, no les intereso);de tal manera que únicamente lo aplique1 a los grupos a los cuales impartía la primera materia deprogramación, BASIC; puesto que anteriormente, no estaba contemplada la materia de LenguajesAlgorítmicos o Algorítmica (como le llaman algunos). En dicho manual, pretendí recopilar loaprendido en la escuela, la experiencia y algo de documentación que tenía a mano, en aquellos años.

Por azares de la vida, el trabajo se vio interrumpido, en varias ocasiones, por muchas y muydiversas causas. Aunque ese tiempo no se perdió, puesto que fui adquiriendo mayor experiencia encuanto al desarrollo de programas y análisis de sistemas, así como en lo que respecta a impartir clasesen diversas escuelas y a muchos particulares; también fui acrecentando mis conocimientos en la diariainvestigación que esta motivada por la curiosidad y las ganas de aprender2. Todo esto, ha servido paraenriquecer el que inicialmente se quería fuese un manual y, posteriormente se deseo desarrollarlo comoun libro3. En ese punto, querido lector, usted dirá después de estudiarlo, si se logro el último objetivo.

1Como venía haciéndolo –aunque sin una estructura claramente definida-.

2 Siempre he dicho que mi profesión es de las más difíciles, ya que ser ESTUDIANTE no es nada fácil.3 Esto fue creando con fragmentos de diversas fuentes, notas, experiencias y memorias profesionales, sin ánimo alguno delucro. Y lo menciono por aquello de que alguien quiera hacer algún reclamo por los copyrights.




PREFACIO

Durante todos estos años en el área de sistemas, he podido observar que a todos los estudiantesque inician la carrera de sistemas computacionales de cualquier nivel (técnico o licenciatura), más quetener problemas con los lenguajes de programación (más adelante veremos la definición técnica, por lopronto, son “idiomas” que utilizamos para comunicarnos con la computadora), tienen muchos

problemas con la LÓGICA.Respecto a esto, y fuera de los conceptos teóricos puros e ideológicos de la LÓGICA formal; y

desde un punto de vista más personal y práctico, podría decir (perdónenme los puristas) que laLÓGICA, es la forma estructurada y ordenada de nuestros pensamientos, ideas y acciones. Claro debeestar que, todos tenemos LÓGICA (léase pensamiento lógico), solo que algunos más desarrollada queotros. Una prueba de ello es el hecho de que primero nos ponemos la ropa interior y después el resto, oque, cuando tenemos la lengua de fuera, primero la metemos para cerrar la boca y no mordernos (salvocasos motivados por problemas de salud, en los cuales no tiene nada que ver la lógica y que sinembargo seguimos teniendo), ya que si no tuviéramos LÓGICA, nos veríamos ridículamente vestidoscon la ropa interior por fuera, o sufriríamos constantes mordidas de lengua, ¿o no?. -

La LÓGICA al igual que los músculos de nuestro cuerpo, necesitamos ejercitarla, y esta por

demás decir, que algunas personas tienen cuerpos atléticos y otras son muy delgadas o bien obesas; sinembargo, todos tenemos músculos. De la misma manera, todos tenemos LÓGICA, si bien, algunos aligual que estas personas que tienen cuerpos atléticos, tienen su LÓGICA ágil, firme y bien desarrollada;otros, como las personas delgadas u obesas, la tenemos muy débil, lenta o mal desarrollada.

Y bien, siguiendo este ejemplo, podríamos decir que para tener un cuerpo atlético (ignorando elaspecto de herencia en los genes, para no complicarnos el asunto) debemos ejercitar mucho nuestrosmúsculos; pues, de la misma manera, para tener una LÓGICA ágil, firme y bien desarrollada, debemosejercitar nuestra mente.

El desarrollo de nuestra lógica y habilidades de programación es similar a la construcción deuna casa: si empezamos con una base fuerte e incrementamos nuestro conocimiento de forma gradual,evitaremos muchos problemas a largo plazo. Piense en el presente libro como ese trabajo de base. En élaprenderemos a construir pequeñas soluciones o programas para aplicar los conceptos de programaciónfundamentales, y posteriormente añadir, a nuestros sólidos conocimientos los conceptos deprogramación avanzados.

Podemos crear soluciones de muchas diferentes maneras para elaborar la misma tarea. Noobstante, algunas maneras son mejores que otras. En este libro se explicará, paso a paso, la mejormanera para crear una solución. La ventaja del aprendizaje por pasos consiste en que podremos ver porqué ciertas tareas se realizan de una manera particular y podremos entender cómo se ajustan las partesindividuales afectando así a la totalidad. Podríamos limitarnos simplemente a mostrar la solución ydecir “Aquí está la solución” y explicarla, pero eso no serviría de mucho a largo plazo. Existe un

antiguo proverbio que dice, “Dadle al hombre un pescado y lo alimentaréis por un día, enseñadle a pescar y lo alimentaréis de por vida”. En este caso quisiera enseñarle a pescar.

Este libro está dirigido a quienes quieren convertirse en diseñadores de soluciones(desarrolladores de programas o programadores), y necesitan aprender los conceptos básicos deprogramación, así como desarrollar su lógica; y no a quienes ya son diseñadores de soluciones o queson programadores expertos.

Para convertirse en un diseñador de soluciones, primero tendrá que aprender las bases ycomprender los conceptos que esconden algunos de los temas avanzados. Podremos considerar este




libro como un escalón hacia libros de programación avanzados y especificos para cada lenguaje.Además de una buena lógica, un buen diseñador de soluciones debe tener un conocimiento

general sólido sobre qué utilidades tiene un producto (traductor de algún lenguaje de programación) yqué funcionalidad nos proporciona dicho producto.

En este libro aprenderá a convertirse en un hábil diseñador de soluciones y aprovechará las

potentes utilidades de desarrollo de las técnicas y estilos de programación, con el fin de construirverdaderas soluciones de empresa reales con éxito. Entendemos como <<soluciones de empresareales>> el tipo de soluciones que han de tomar en cuenta los programadores y diseñadores en sutrabajo diario.




OBJETIVOS.

El primero y más directo es el de aportar una guía básica y sencilla para que, cualquier personaque se interese y le agrade el área de sistemas computacionales, aprenda, partiendo de la nada, adesarrollar soluciones (programas).

Otro objetivo, no menos importante, es el de dar a conocer, a través de los conceptos básicos y

una gran cantidad de ejercicios, las técnicas de programación.

Aunque, en realidad, dejar satisfecho al lector que tenga en sus manos este libro y que estaslíneas ayuden en su aprendizaje a quien ha puesto su confianza en él, es el mayor y principal objetivode cualquier autor.

Debo hacer notar que para comprender algunos conceptos de este libro, primero debe habersetomado un pequeño curso previo de Introducción a la Computación y sería fantástico si se tomo uncurso de algún Sistema Operativo previo, para comprender algunos de los conceptos, como son lamemoria de la computadora, los componentes básicos que la conforman, y su funcionamientoelemental, ya que el presente libro no pretende cubrir estos aspectos.




1. - Introducción y conceptos básicos.

INTRODUCCION

En el mundo de la computación, uno de los aspectos más importantes es la resolución deproblemas con la ayuda de la computadora, para agilizar los procesos y el manejo de información. Sin

embargo debemos recordar que la computadora no puede resolver problemas por sí sola, ya que solo esuna “máquina” o dispositivo electrónico que nos es útil como herramienta de trabajo, para el manejode grandes cantidades de información; por esto, somos nosotros quienes debemos darle lasinstrucciones necesarias para que ella desarrolle los procesos que le indiquemos. Estas instruccionesdeben tener un cierto orden y deben ser especificadas concienzudamente y bien detalladas.

Para lo anterior, se siguen ciertas reglas para poder escribir las instrucciones que resuelvan unproblema en particular. Es aquí donde entra el uso de los Lenguajes Algorítmicos.

Un lenguaje algorítmico, es una forma de escribir las instrucciones u ordenes, en forma de pasos lógicos para resolver problemas específicos, en el lenguaje que normalmente utilizamos; siendoen nuestro caso, el español; de una manera sencilla y simple.

La palabra ALGORITMICO, proviene de la palabra ALGORITMO4, que en una de susdefiniciones básicas nos dice que es: Un procedimiento paso a paso para resolver un problema en unacantidad determinada (finita) de tiempo.

Por lo anteriormente descrito, se puede decir que la materia de Lenguajes Algorítmicos esprimordial, ya que nos enseña a resolver problemas, y así escribir las instrucciones para lacomputadora, y que ésta realice los procesos.

A continuación y para entendernos mejor, se dan algunos conceptos básicos utilizados en lacomputación, y específicamente en el ambiente de los programadores.

1.1. - Lenguaje.

Un lenguaje es un medio de comunicación, que hace uso de símbolos, caracteres ypalabras, para expresar ideas.

1.2. - Programación.

Es la actividad de desarrollar programas, que serán suministrados a la computadora.

1.3. - Programa.

Es un conjunto de instrucciones, escritas en una secuencia lógica, en un lenguaje de

programación.

4 Algoritmia: f. Ciencia del cálculo aritmético y algebraico.Algoritmo: m. Conjunto ordenado y finito de operaciones que permiten la resolución de un problema; p. Ej. La extracciónde raices cuadradas o el cálculo de una suma, producto o división de números. (Enciclopedia Textual Permanente Salvat).




1.4. - Lenguaje de programación.

Es el conjunto de caracteres y reglas de utilización, aplicadas para desarrollar programasy comunicarnos con la computadora, para así darle las instrucciones adecuadas; y que éstadesarrolle una determinada actividad o labor.

1.4.1. Lenguaje Máquina.

Es el “idioma” de la computadora, y lógicamente, solo entendible por ella. Estelenguaje implica las instrucciones que son entendibles por la computadora.

La computadora solo entiende o capta impulsos eléctricos, los cuales procesa através de una compleja red de dispositivos electrónicos. Dichos impulsos eléctricos,nosotros los humanos los representamos como “circuitos apagados” o “encendidos”, obien 0 y 1; los cuales relacionamos con el sistema binario de numeración (base 2).

1.4.2. Lenguajes de Alto Nivel.

Es un lenguaje de programación que utilizamos para comunicarnos con lacomputadora, el cual utiliza palabras o abreviaturas, casi siempre del idioma inglés (aúnno he visto un lenguaje que use palabras de otro idioma5). Estos lenguajes implicaninstrucciones fácilmente entendibles por cualquier programador, y que están listas paraser traducidas a lenguaje máquina, por el programa traductor adecuado.

1.4.3. – Traductores.

En computación, se define como traductor, a un programa cuya función es la detraducir las instrucciones en lenguaje de alto nivel a lenguaje máquina, para que ésta

efectúe las operaciones que se le indican.

1.4.3.1. – Intérpretes.

Un intérprete, es un programa traductor, el cual debe permanecer en lamemoria de la computadora para realizar la traducción a lenguaje máquina de unprograma escrito en lenguaje de alto nivel, así como su ejecución simultánea.Muchos de estos lenguajes han desaparecido o bien, tienden a desaparecer.

1.4.3.2. – Compiladores.

Un compilador, es un programa traductor, el cual realiza la traducción delprograma escrito en lenguaje de alto nivel, durante un proceso llamadocompilación del código fuente, obteniendo un código objeto, el cualposteriormente, pasa al proceso de enlazado, para obtener un código ejecutable

5 Salvo el caso de unos amigos de la escuela, cuya tarea era hacer un lenguaje compilado, y lo llamaron lenguaje LEPERO(Lenguaje en Español Pseudoestructurado pero Revuelto con Otros), el cual nunca terminaron totalmente, solo lo quenecesitaron para aprobar, hasta donde tengo entendido.




por la computadora.Al obtener el código ejecutable, es posible ejecutar el programa sin

necesidad de recurrir al compilador, puesto que el código ejecutable esindependiente y entendido directamente por la computadora, sin necesidad delcompilador.

1.4.4. – Palabras reservadas.

Son aquellas palabras propias de un lenguaje de programación, las cuales nopueden ser utilizadas para describir datos o información del usuario, es decir, nombresde variables, funciones o procedimientos de usuario.

1.4.5. – Código.

Desde el punto de vista informático, el Código, son las instrucciones de unprograma, escritas en un lenguaje de programación.

El proceso de traducir nuestro algoritmo (escrito en lenguaje común) a código

fuente (escrito en un lenguaje de programación) se denomina codificación.

1.4.5.1. - Código fuente.

Son las instrucciones de un programa, escritas en un lenguaje deprogramación de alto nivel.

Normalmente el código fuente es capturado en un programa editor detextos, que bien puede ser independiente al traductor o estar incluido dentro delmismo.

1.4.5.2. – Código objeto.

Son las instrucciones de un programa, escritas en un formato intermediode traducción. Todos los compiladores generan el código objeto a partir delcódigo fuente, como un paso intermedio para obtener el código ejecutable.

1.4.5.3. – Código ejecutable.

Son las instrucciones de un programa, escritas en lenguaje máquina, porun programa enlazador.

Todos los compiladores generan el código ejecutable a partir del códigoobjeto; y dicho código ejecutable, como su nombre lo indica, puede ser ejecutadodirectamente por la computadora sin necesidad de recurrir al compilador otraductor.

1.4.6. – Compilación.

Es el proceso de traducción del código fuente a un formato intermedio detraducción, llamado código objeto.




1.4.7. – Enlazado.

Es el proceso de traducción del código objeto a código ejecutable, por medio deun programa de enlazado o enlazador.

Durante este proceso, las instrucciones, funciones y procedimientos escritos porel compilador en código objeto se relacionan o enlazan con el código ejecutable, que se

encuentra en las librerías propias del lenguaje de programación.

1.4.8. – Librerías.

Una librería de funciones es un archivo, normalmente con extensión.LIB, quecontiene un conjunto de rutinas compiladas, que han sido diseñadas para realizar una

tarea en particular, y que el enlazador añade a los programas conforme éste las necesita.Las librerías pueden ser específicas para un tema (p. e. Gráficos), para unaaplicación en particular, para un compilador (p. e. Clipper) o bien tener un carácterestándar, con funciones de todo tipo, reutilizables en cualquier aplicación.

Un compilador se acompaña, normalmente, de una o más librerías que son lasque contienen las funciones del lenguaje en general6.

1.4.8.1. – Librerías preenlazadas.

Son aquellas librerías que contienen módulos objeto previamenteenlazados, y por lo tanto sus instrucciones, funciones y procedimientos ya están

traducidos a lenguaje máquina. Normalmente son almacenados como archivoscon extensión.PLL (Pre Linked Library) u otra similar.

Algunos compiladores nos permiten crear archivos con libreríaspreenlazadas de forma que, al enlazar nuestra aplicación final, el ejecutableocupe una cantidad mínima debido a que toma una cantidad muy importante deaquello que necesita para trabajar de un archivo.PLL (Pre Linked Library).

Dicho en otra forma, al compilar y enlazar nuestra aplicación, solo setraducirán a lenguaje máquina aquellas instrucciones, funciones oprocedimientos que no se encuentren en la librería preenlazada, puesto que, elresto ya están enlazadas en el archivo PLL, y cuando se ejecute el programa, éstellamará a las funciones de la librería preenlazada y las ejecutará directamente.

La ventaja de utilizar librerías preenlazadas, básicamente es el ahorro deespacio en disco, sin embargo, por lo general el tiempo de carga de la aplicación(inicialización del programa) a memoria es mayor.

1.4.9. – Sintaxis.

6 En el apéndice A se trata con un poco más de detalle el tema de las librerías. Sin embargo, se recomienda tratar estos temas

cuando ya se tenga un poco más de conocimientos acerca de la programación avanzada.

Códigofuente

Códigoobjeto

Enlazador Códigoejecutable

Librería(s)

Compilador




Son las reglas de escritura de las instrucciones del lenguaje de programación.

1.4.10. – Semántica.

Son las reglas, normas o técnicas que permiten dar legibilidad al código de un

programa, es decir, que permiten que el código sea fácil de entender y comprender.

1.5. - Sistema informático o aplicación.

Conjunto de programas que funcionan coordinados entre sí, para el manejo de grandesvolúmenes de información.

1.6. - Programador.

Es la persona que desarrolla programas para computadoras.

1.7. - Técnicas de programación.

Conjunto de reglas o normas utilizadas para el desarrollo de programas.

1.8. - Usuario.

Es cualquier persona que hace uso de una computadora.




2. - Tipos y estructuras básicas de datos.

2.1. - Dato.

Un dato es la expresión general que describe los objetos con los cuales opera unacomputadora.

A los datos se les puede considerar como la materia prima que se da a un proceso paraobtener un producto terminado, llamado información.

2.2. - Tipos de datos.

2.2.1. - Datos numéricos.

Un tipo numérico es el conjunto de valores numéricos, con los cuales podemosrealizar operaciones aritméticas. Estos pueden representarse en dos formas distintas:

- Tipo numérico entero (integer).- Tipo numérico real (real).

El tipo numérico entero (integer), como su nombre lo indica son aquellos valoresnuméricos que no cuentan con una parte fraccionaria o fracción; y obviamente no tienenen su estructura el punto decimal o formato de fracción.

Ejemplos de tipos numéricos enteros: 5, 3, 8, 23, …

El tipo numérico real (real), son aquellos valores numéricos que incluyen en suestructura el punto decimal o formato de fracción, y desde luego una parte fraccionaria o

fracción.Ejemplos de tipos numéricos reales: 1.5, 2.34, 0.47, ¾, 5 ½, …

Normalmente en las computadoras, los números reales se representan en formatodecimal (p. Ej. 1.5, 3.56, …); y en raras ocasiones en formato fraccionario (p. Ej. ¾, 3½,1¾, …).

2.2.2. - Datos tipo carácter.

El tipo carácter es el conjunto finito (limitado) y ordenado de caracteres que lacomputadora reconoce. Un tipo de dato carácter contiene un solo carácter.

Los caracteres que reconocen las diferentes computadoras no son estándar; sinembargo, la mayoría reconoce los siguientes caracteres alfabéticos y numéricos:

- Caracteres alfabéticos (A, B, C,..., Z, a, b, c,..., z).- Caracteres numéricos (0,1,2,3,4,5,6,7,8,9).- Caracteres especiales (!, ", $, %, &, /, ...).




2.2.3. - Datos alfanuméricos, de cadena o string.

Una cadena (string) de caracteres es una sucesión de caracteres que se encuentrandelimitados por una comilla (apóstrofo), dobles comillas, o corchetes ([]); según el tipode lenguaje de programación. La longitud de una cadena de caracteres es el número deellos comprendidos entre los separadores o delimitadores.

2.2.4. - Datos lógicos (booleanos).

El tipo lógico (también denominado booleano) es aquel dato que solo puedetomar uno de dos valores:

CIERTO o VERDADERO (true) y FALSO (false)

Este tipo de datos se utiliza para representar las alternativas (SI / NO) adeterminadas condiciones. Por ejemplo, cuando se pide si un valor entero es par, larespuesta será verdadera o falsa, según sea par o impar.

2.3. - Constantes, variables y funciones.

CONSTANTES

Son valores estáticos, es decir, que no cambian, y se mantienen fijos durante la ejecuciónde un programa.

Pueden ser de cualquiera de los tipos de datos vistos anteriormente.Ejemplos: 23,”España”, Verdadero.

VARIABLES

Una variable es un objeto o partida de datos cuyo valor puede cambiar durante laejecución de un programa. A estos objetos o partida de datos se les puede asignar un nombre,que será el NOMBRE DE VARIABLE , para identificarlos.

Ejemplos: Edad, Nombre, Salario.

FUNCIONES

Son un conjunto de operaciones predefinidas dentro de un lenguaje de programación opor el programador.

2.4. - Expresiones.

Las expresiones son combinaciones de constantes, variables, símbolos de operación,paréntesis y nombres de funciones especiales.




2.4.1. - Expresiones aritméticas.

Son semejantes a las formulas aritméticas. Las variables y constantes sonnuméricas (reales o enteras) y las operaciones son las aritméticas. Los operadoresaritméticos son los siguientes:

+ SUMA- RESTA* MULTIPLICACIÓN / DIVISIÓN^, ** EXPONENCIACIÓNDIV DIVISIÓN ENTERA \,MOD MÓDULO (resto, residuo)

Los cuales se rigen sobre la base de ciertas REGLAS DE PRIORIDAD oPRECEDENCIA, que permiten determinar el orden de las operaciones, y que se basan enreglas matemáticas, las cuales son:

A. - Las operaciones que están encerradas entre paréntesis se evalúan primero. Siexisten diferentes paréntesis anidados (interiores unos a otros), las expresiones másinternas se evalúan primero.

B. - Las operaciones aritméticas dentro de una expresión suelen tener el siguienteorden de prioridad.

1. - Operador exponencial ^ o **.2. - Operadores *, /.3. - Operadores +, -.

4. - Operadores DIV y MOD.

En caso de coincidir varios operadores de igual prioridad en una expresiónencerrada entre paréntesis o no, el orden de prioridad en este caso es de izquierda aderecha.

Ejemplos:EXPRESION OPERACIONES RESULTADO

5 DIV 2 División entera 25 MOD 2 Módulo o residuo 1

4+6/2 4+3 7(4+6)/2 10/2 5

((3+5)/2^2)+1 (8/2^2)+1 = (8/4)+1 = 2+1 34*2/4 8/4 22^2/4 4/4 1




2.4.2. - Expresiones alfanuméricas.

Son expresiones que incluyen asignaciones o funciones especiales, de datoscarácter o de cadena (string).

Ejemplo de concatenamiento.- “Casa” + “segura” = “Casa segura”

2.4.3. - Expresiones lógicas (booleanas).

Una expresión lógica es una expresión que solo puede tomar uno de dos valores,ya sea VERDADERO o FALSO. Se denominan también EXPRESIONES BOOLEANAS en honor del matemático británico George Boole, que desarrollo el Algebra lógica, deBoole o Booleana.

2.4.3.1. - Operadores de relación.

Los operadores relacionales o de relación permiten realizarcomparaciones de valores de tipo numérico, carácter o de cadena. Los

operadores de relación sirven para expresar las condiciones en losalgoritmos. Los operadores relacionales son:

< MENOR QUE> MAYOR QUE= IGUAL QUE<= MENOR O IGUAL A>= MAYOR O IGUAL A<> DIFERENTE A

Ejemplos:

EXPRESION RELACIONAL RESULTADO5 < 3 FALSO3 < 5 VERDADERO8 > 2 VERDADERO2 > 8 FALSO3 = 3 VERDADERO3 = 2 FALSO

3 <= 5 VERDADERO6 <= 5 FALSO

3 >= 5 FALSO6 >= 5 VERDADERO3 <> 3 FALSO3 <> 2 VERDADERO




2.4.3.2. - Operadores lógicos.

Los operadores lógicos o booleanos básicos son NOT (no), AND (y) yOR (o), y nos permiten unir expresiones booleanas o de relación.

Las estructuras para el uso de los operadores lógicos son:

Expresión Lógica 1 AND Expresión Lógica 2Expresión Lógica 1 OR Expresión Lógica 2NOT Expresión Lógica

Los resultados del uso de los operadores lógicos se pueden observar enlas siguientes TABLAS DE VERDAD:

Expresión Lógica 2

AND Verdadera FalsaExpresión Verdadera Verdadera Falsa Resultados

Lógica 1 Falsa Falsa Falsa

Resultados


OR Verdadera FalsaExpresión Verdadera Verdadera Verdadera Resultados

Lógica 1 Falsa Verdadera Falsa

Resultados

NOT Resultado

Expresión Verdadera Falsa Lógica Falsa Verdadera

Existe otro operador lógico, llamado XOR, que es utilizado en algunoslenguajes de programación, y es considerado un OR exclusivo. Su tabla deverdad es la siguiente.


XOR Verdadera FalsaExpresión Verdadera Falsa Verdadera Resultados

Lógica 1 Falsa Verdadera Falsa Resultados

Como se puede observar, únicamente se obtiene un resultado verdaderocuando solo una de las expresiones lógicas es verdadera. Si las dos llegan a serverdaderas el resultado es falsa; ya que una expresión verdadera excluye a laotra.




2.4.4. – Reglas globales de prioridad o precedencia.

Como ya se menciono, para el caso de los operadores aritméticos, existen ciertasReglas de Prioridad o Precedencia. Pero estas reglas de precedencia para operadoresaritméticas, no son únicas ya que existen otras de mayor jerarquía, las cuales llamaremos

REGLAS GLOBALES DE PRIORIDAD O PRECEDENCIA, ya que implican de manerageneral a las expresiones, las cuales para resolverse siguen el siguiente orden oprecedencia:

1. Operaciones Aritméticas, Operaciones Alfanuméricas.2. Operaciones Relacionales.3. Operaciones Lógicas.

2.5. - Arreglos (arrays).

Un arreglo (array) es un conjunto limitado y ordenado de elementos similares (del

mismo tipo de dato) que reciben el mismo nombre.La propiedad "ordenado" significa que el elemento primero, segundo, tercero, .., n-ésimode un arreglo puede ser identificado por medio de un índice o subíndice.

2.5.1. - Arreglos unidimensionales.

Es el tipo más simple de arreglos, también reciben el nombre de VECTORES,solo cuenta con un subíndice, es decir, solo tiene una dimensión, ya que solo contará conun número determinado de filas, o bien de columnas, únicamente. Para hacer referenciaa un elemento se puede indicar de la siguiente manera: X(4) ó X[4].

Si representamos gráficamente un vector con cuatro elementos, tendremos:

Cuatro columnas,

Ó

Cuatro filas

NOTA: Debo anotar que la posición 0 (cero), en los lenguajes de programaciónse define automáticamente como una posición de arreglo válida, de tal manera que sidefinimos un vector X(4) de, aparentemente, 4 posiciones, realmente representará unvector de 5 posiciones, que van desde X(0) hasta X(4). De la misma manera será paralos demás tipos de arreglos. Sin embargo, para no confundir al lector, tomaremos los




conceptos matemáticos sobre arreglos, con fines de explicación, en los cuales no seconsidera la posición 0.

2.5.2. - Arreglos bidimensionales.

Estos arreglos tienen dos dimensiones, es decir, cuentan con un número

determinado de filas y columnas; también reciben el nombre de MATRICES o TABLAS.Para hacer referencia de uno de sus elementos se deben utilizar dos subíndices(A[f, c]).

Si representamos gráficamente una tabla con cinco filas y cuatro columnastendremos:

1 2 3 42345

2.5.3. - Arreglos multidimensionales.

Cuando un arreglo cuenta con tres o más subíndices, se dice que es un arreglomultidimensional, ya que cuenta con múltiples dimensiones.

Si representamos gráficamente una matriz tridimensional conF filas, C columnas y N niveles tendremos:

Cuando un arreglo tiene más de tres dimensiones, no es posible representarlográficamente, sin embargo, tanto matemáticamente como en la computadora si esposible manejarlo.

F filas

C columnas

N niveles




3. - Técnicas de Programación.

3.1. - Importancia.

El dominio y aplicación de las técnicas de programación, es de gran importancia, ya queel uso de éstas nos facilita en gran medida el desarrollo de programas que resolverán problemas

prácticos, puesto que nos ayudan a determinar muchos aspectos y detalles durante la resoluciónde problemas, y con esto se reducen los errores al mínimo, y se obtienen programas oaplicaciones en una menor cantidad de tiempo, mayor calidad, legibilidad y funcionalidad, yaque nos permite planificar, con mínimo error, los programas que hemos de desarrollar.

3.2. - Objetivo.

Es el de economizar tiempo, disminuir la cantidad de errores que se pudieran presentardurante el desarrollo de una aplicación o programa, y con esto reducir los costos de elaboraciónde software.

3.3. - Estilos de programación.

El estilo en la construcción de programas, al igual que el estilo de escritura, no es unacosa que pueda adquirirse solo a partir del conocimiento de las reglas de sintaxis de un lenguajey las técnicas básicas de programación. El estilo en programación como en otras actividades dela vida es una cuestión de gustos personales; sin embargo, en programación es posible unir lainventiva y la ingeniosidad del programador con unas reglas de disciplina y orden en el diseñode programas.

El estilo de la buena programación está íntimamente unido con la legibilidad de losprogramas. La legibilidad de un programa es el criterio más sencillo para evaluar la calidad de

un programa; si el programa es fácil de leer, probablemente será un buen programa; si esdifícil de leer, no es un buen programa (Kernighan* y Planger. Software Tools. Addison-Wesley, 1976).

La legibilidad es la clave para la comprensión de un programa; un programa que no sepuede comprender, no se le podrá modificar ni mantener actualizado. Es muy importantedistinguir entre legibilidad (semántica) y facilidad de escritura (sintaxis). Las técnicas deprogramación deben facilitar la escritura de programas y posteriormente facilitar su lectura.

La escritura de algoritmos y su posterior codificación conduce a la creación de hábitosde programación. La formación de buenos hábitos de programación, desde el inicio de suaprendizaje de programación, será, sin duda, uno de los puntos más importantes en los quedeberá prestar atención.

La calidad de un programa se puede medir con diferentes parámetros; entre ellosdestacaremos:

A). - Un programa debe funcionar.Obviamente es la característica más simple e importante.




B). - La documentación.Desde luego debe contener en su código los comentarios necesarios para

explicar detalladamente su funcionamiento, así como la documentación que seutilizo y desarrollo durante la fase de análisis de los problemas.

C). - La eficiencia.

El programa debe ser óptimo, es decir, debe utilizar únicamente aquellosrecursos de hardware (principalmente RAM, entre otros) estrictamentenecesarios, y nunca desperdiciarlos; también debe ser rápido, es decir, debeprocesar la información lo más rápidamente posible.

D). - Corrección.Debe ser fácil la localización de errores en el código, y por ende, permitir

realizar las correcciones necesarias en el menor tiempo posible. De ahí quenuestra programación debe ser estructurada (por ejemplo, técnica modular odescendente, que se verán más adelante), evitando saltos de una línea delprograma a otra, y tratando de hacerlo lo más aproximado a un programa lineal,

es decir, que se ejecute línea a línea sin saltos.

E). - Flexibilidad.Debe estar estructurado de tal manera que permita realizar cambios o

actualizaciones de manera rápida y sin modificar gran cantidad de código. Estocon el fin de cubrir rápidamente las necesidades de los usuarios.

F). - Fiabilidad.El proceso de la información y entrega de resultados del programa al

usuario final debe ser totalmente confiable, ya que dicho usuario espera que losresultados que obtenga a través de nuestros programas sean 100% correctos (A

excepción expresa de los errores de captura que el propio usuario pueda cometer,y que no pudiéramos evitar).

G). - La presentación.El programa deberá tener una presentación agradable e intuitiva para el

usuario, es decir, que las pantallas de intercambio de información (interfases)sean sencillas, ordenadas, fáciles de comprender, y; en lo posible, con toques decolores e imágenes agradables al usuario.

3.4. La Notación Húngara y otras convenciones.

A la hora de desarrollar programas o sistemas, el algoritmo o código puede a vecesvolverse complejo y terminar por ser bastante largo. Un algoritmo o código largo y entrevesadopuede resultar difícil de leer si necesitásemos depurarlo, o si lo que estamos es regresando a él,después de una larga ausencia. Por ello a través del tiempo y la experiencia de los primerosprogramadores, se han creado varias convenciones que facilitan la comprensión, y así poderseguir las acciones que nuestro programa va ejecutando.

Pese a que no hemos escrito ningún algoritmo o código hasta el momento, deberíamosfamiliarizarnos con las convenciones que facilitarán la legibilidad de nuestro código. Estas




convenciones nos permiten hacer lo siguiente:

- Añadir comentarios a nuestro algoritmo o código.- Escribir múltiples sentencias en una sola línea (dependiendo del lenguaje utilizado).- Utilizar el carácter de continuación de línea (también dependiendo del lenguaje

utilizado).

- Aplicar sangrías sobre el código, es decir, indentarlo o tabularlo.

Como primer punto tenemos que, los comentarios son líneas del programa que seintroducen para dar legibilidad al código y siempre son ignorados por los traductores.

¿Para qué usarlos entonces? La finalidad es darle claridad al programa, expresando quéhace cada una de sus partes.

Resulta recomendable agregar comentarios a nuestro algoritmo o código, con el fin deexplicar claramente el objetivo o tarea de un grupo de ordenes o instrucciones. En todos loslenguajes de programación esta situación ha sido contemplada; así por ejemplo tenemos que enBASIC y sus “dialectos” (perdón a los puristas por –dialecto-) (por ejemplo: GWBASIC, Quick

BASIC, Turbo BASIC, Visual BASIC, etc.), una línea de comentario empieza con la palabra osentencia REM, de REMark (-comentario- en inglés) o un apóstrofe (‘), mientras que en loslenguajes xBase (por ejemplo: DBase, Clipper, Fox Base, Fox Pro, etc.) tenemos los caracteres*, //, /* */ ó &&, dependiendo del lenguaje xBase; en Pascal los caracteres (* *), y así por elestilo.

Para el caso especifico de los algoritmos, es recomendable anotar y resaltar loscomentarios; por eso algunos programadores acostumbramos diferenciarlos anotando unasterisco (*) al inicio del comentario, aunque cada programador resalta los comentarios comomás le parece y conviene. Los primeros libros de programación (que conocí) y desde luegotambién los primeros programadores; acostumbraban anotar comentarios inclusive en eldiagrama de flujo del programa7; pero en lo personal, me confunden más y no me ayudan.

Ejemplo:

* Este es un comentario, y el que sigue también.* Lo que sigue son las primeras tres instrucciones de un programa.Instrucción 1Instrucción 2Instrucción 3* A continuación siguen otras dos instrucciones.Instrucción 4Instrucción 5* Este es el final del pseudo código o algoritmo.

En el segundo punto de la lista, se nos marca el uso de múltiples sentencias en una solalínea, y aunque acortan un poco el código y evitan que se vea excesivamente largo, en lopersonal, a veces me pierdo y no visualizo las sentencias correctamente, pues me confunden y

7 No te preocupes si este término es nuevo para ti, son simplemente unos gráficos representando un algoritmo o código, masadelante conocerás su definición exacta y hasta soñarás con ellos.




pienso que es una sola instrucción; sin embargo, allí queda la opción para quien le guste usarla,y además le sea posible programarla así, en el lenguaje que escoja y más le guste. Pues no todoslos lenguajes de programación permiten esta característica, algunos de los que si lo permiten sonel BASIC y algunos de sus “dialectos”, así como Clipper y Pascal, entre otros.

Ejemplo:

Instrucción 1Instrucción 2: Instrucción 3: Instrucción 4: Instrucción 5Instrucción 6

Como puedes ver, solo ocupa tres líneas, y no seis, por lo cual se ve mas corto el pseudocódigo.

Para el tercer punto anotado, cabe hacer mención que la mayoría de los traductoresentienden que cada mandato o función se va a poner en una sola línea. Cuando el traductor seencuentra con un salto de línea en la instrucción (carácter 13 <intro> del código ASCII), a todos

los efectos, ésta ha finalizado.A medida que profundicemos en la programación, veremos que las expresiones sepueden complicar cuanto queramos, a veces más de lo que sería deseable.

No es recomendable, por cuestión de legibilidad, que una línea supere el margen derechode nuestra pantalla cuando capturemos el código fuente del programa. Para solventar este eventodisponemos de un carácter especial, que varía dependiendo del lenguaje, el cual indica altraductor que el código se corta en ese punto, pero el que viene en la o las siguientes líneas escontinuación de éste. (como ejemplo de carácter especial tenemos el punto y coma -;- en loslenguajes xBase).

La ubicación de este carácter especial, en la mayoría de los casos, es flexible, pero nopuede ponerse indiscriminadamente. Por ejemplo, las palabras reservadas o el nombre de las

variables, no pueden cortarse.

Ejemplo:

Instrucción Larga;Continuación de la Instrucción Larga

Si se anotara en una sola línea se escribiría:

Instrucción Larga Continuación de la Instrucción Larga

Sin embargo no es válido hacer esto:

Instr;ucción larga

Por último, tenemos la aplicación de sangrías al código, es decir, indentación otabulación. Esto se aplica para diferenciar el inicio y finalización de instrucciones compuestas,es decir, de aquellas instrucciones que dentro de su estructura o sintaxis pueden incluir otras




instrucciones independientes a la compuesta.

Ejemplo:

Inicio de la Instrucción Compuesta 1Instrucción 1

Instrucción 2Instrucción 3Continuación de la Instrucción Compuesta 1

Instrucción 4Instrucción 5

Fin de la Instrucción Compuesta 1Instrucción Compuesta 2

Instrucción 6Instrucción 7Instrucción 8Instrucción Compuesta 3

Instrucción 9Instrucción 10Fin de Instrucción Compuesta 3

Fin de Instrucción Compuesta 2

Como puede observarse las instrucciones 1 a 3 se ejecutarán dentro de la primerasección de la Instrucción Compuesta 1 y las instrucciones 4 y 5 en la segunda parte de la misma;pues después de esto termina la instrucción compuesta.

La Instrucción Compuesta 2 incluye dentro de su estructura las Instrucciones 6 a 8 y laInstrucción Compuesta 3; cuya estructura incluye a su vez a las Instrucciones 9 y 10.

Espero quede claro que es más fácil revisar un grupo de instrucciones indentadas, pues

fácilmente encontraremos el inicio y fin de las instrucciones compuestas.

Como habrás notado, los humanos nos entendemos a fuerza de convenciones. Laescritura de un programa es un asunto lleno de estas ceremonias. ¿Por qué indentamos elcódigo? ¿Por qué escribimos cosas en mayúsculas y cosas en minúsculas? Las razones estánclaras: para hacernos entender mejor. Este es el objetivo principal de cualquier sistema denotación. Todo programador, de acuerdo a su estilo, ha empleado un sistema de notación propiobasado en las reglas que más lo han ido convenciendo de los distintos métodos que ha visto. Sinembargo, es recomendable ajustarse al estándar. Y este estándar no es ni más ni menos que la notación húngara, un invento maléfico de un programador magiar que trabaja para Microsoft yque está a punto de conseguir que media humanidad escriba programas tal como a él le dé lagana que lo hagan. Simonyi se llama el bárbaro en cuestión, y sus reglas ya han sido asumidaspor todos los productos de Microsoft y por bastantes de la competencia. Por lo tanto, esrecomendable, intentar siempre ajustarnos al estándar y en este libro intentamos que se dé elprimer paso para ello.

Así, pues, hemos tomado las mismas normas de la notación húngara que Nantucket (unaempresa de software) ha asumido para algunos de sus productos. Esto no supone asumir dichanotación en su totalidad. Esto es así porque Simonyi escribió sus convenciones pensando en ellenguaje C y este lenguaje tiene sus diferencias con otros lenguajes. Por ejemplo en C es




obligatorio escribir todas las funciones del sistema en minúsculas, y por ello, una norma de lanotación húngara es que todas estas funciones han de ir escritas en dicha tipografía. En otroslenguajes (por su traductor), cosas como esta no son necesarias. Por ello en el sistema denotación que empleamos los mandatos y las funciones de las librerías del sistema se escribencon mayúsculas8. En fin, el conjunto de normas que seguimos son:

1. La primera letra de una variable siempre ha de escribirse en minúscula y debe indicar el tipode la misma:

a Array b Codeblock (para lenguaje Clipper). c Cadena d Fechal Lógica n Numérica o Objeto x Cualquier tipo

2. Los mandatos y funciones del sistema se escriben siempre en mayúsculas. Por ejemplo:RETORNAR (RETURN en inglés), FECHA() (DATE en inglés), etc.

3. Los nombres de cualquier objeto introducido por el usuario: variable, función, etc. Nuncadeben separarse mediante el símbolo del subrayado sino poniendo en mayúsculas la primeraletra de cada trozo de palabra con significado. Por ejemplo: DbMenu(), StrCount(),nFilaInicial, etc. (Técnica WordMixing –Mezcla de palabras-)

Como has visto, la notación húngara se trata de un sistema de convenciones de escriturade código que hacen que los programas, sean más legibles.

A casi todos los traductores no les importa que una palabra, sea mandato, variable,

función o lo que sea, esté escrita en mayúsculas o minúsculas (salvo en casos específicos dellenguaje, como C), con uno o más blancos por delante o por detrás, etc. Al que sí le importa esal que tiene que leer eso, es decir, a nosotros.

Como en casi todas las normas, existen corrientes, la notación húngara no podía sermenos. En algunos libros de programación y lenguajes, por ejemplo; las obras realizadas y/oeditadas por grupo EIDOS9, se sigue la llamada notación gallega inversa, una mezcla del 95%de notación húngara y un 5% de especifidades (de la cosecha del grupo EIDOS) y chanza (el

8 En general seguimos la adaptación de la Notación Húngara para Clipper realizada por Robert DiFalco en Reference

(Clipper) Vol. V, núm. 5, de mayo de 1991 y por Antonio Linares en clippeRmanía núm. 3, de julio de 1991.

9 Grupo EIDOS es una empresa especializada en el área de lenguajes xBase. Sus actividades abarcan la edición dedocumentación técnica (entre la que destacan la revista clippeRmanía así como varios libros sobre productos de entorno xBasepublicados a través de Editorial RAMA, la formación, la consultoría, el desarrollo, la producción y distribución de productossoftware. Grupo EIDOS es VAR (Distribuidor Autorizado de Valor Añadido) y Centro de Formación Autorizado de ComputerAssociates. Sus dos centros en Madrid y Valencia cubren la totalidad de los aspectos reseñados.En el área de la formación, Grupo EIDOS ha organizado en España en 1992 y 1993 los ENCUENTROS DE USUARIOSCLIPPER y en Argentina en 1993 (a través de WorldNet, su representante en la zona) los PRIMEROS ENCUENTROSLATINOAMERICANOS DE USUARIOS CLIPPER; todos ellos con la asistencia de los más cualificados desarrolladores enClipper y el patrocinio de las principales empresas del sector. Asimismo, mantiene un aula de formación permanente paraprogramadores dentro de este mismo entorno.




nombrecito es fruto de una mezcolanza entre la notación polaca y una deferencia para uno desus mejores amigos y colaboradores: Ramón Delgado, gallego él).

A continuación se muestran las normas seguidas por la notación gallega inversa, en laque se podrán notar las similitudes y diferencias con relación a la notación húngara, y son:

1. Los nombres de las variables han de ir precedidos en minúsculas por un identificador de sutipo:

c Carácter o memo n Numérical Lógica d Fecha (date) o Objeto (genérico) b CodeBlock (para lenguaje Clipper) x Tipo indeterminado (no conocido a priori) a Array

ac Array de cadenas (todos los elementos tipo c) a… Array de … (todos los elementos de tipo …)

Si la variable contiene un objeto específico, del que conocemos su tipo (su clase),entonces usaremos como identificador 3 letras (consonantes) para representar ese tipo deObjeto:

vntTest vnt -> VentanakktPrueba kkt -> Kikito

2. Utilización de la técnica WordMixing (mezcla de palabras) para diferenciar las distintas

partes de un nombre.cEjemploTipico

3. No usar subrayados “_” para separar esas partes de los nombres.4. A todos los efectos, los nombres que demos a nuestras funciones y métodos seguirán las

mismas reglas de codificación. A fin de cuentas tanto el nombre de una variable como elnombre de una función son símbolos que contienen un valor (unos lo tienen y otros logeneran). Aplicar indistintamente estas técnicas en variables y funciones evitará un buenmontón de errores.

5. Todos los mandatos se escribirán en mayúsculas.

Cada programador tiene su propio método o estilo, pero todo apunta hacia una unificaciónde criterios, y esta notación húngara (o la similar gallega inversa) es la de mayor aceptación.




4. - Técnica de diseño general o elemental.

Esta técnica es aplicable a cualquier tipo de problema que se presente, pero tiene elinconveniente de que, en el desarrollo de grandes sistemas, resulta muy poco recomendable su uso, yaque resultaría confusa y laboriosa su aplicación. Por lo tanto, es recomendable para proyectos en

pequeña escala o módulos del proyecto.

4.1. - Fases de resolución de problemas.

TECNICA DE DISEÑO GENERAL O ELEMENTAL

Las fases o pasos para resolver problemas con esta técnica, y obtener programas enlenguajes de alto nivel, son:

1. - Determinar el objetivo o problema.

2. - Análisis del problema: A) Determinar los datos de salida solicitados, y los datos de entrada necesarios. B) Determinar los pasos para resolver el problema.C) Comprender y detallar los pasos para resolver el problema.

3. - Desarrollar el diagrama de bloques o diagrama de flujo de sistemas. 4. - Diseñar el diagrama de flujo. 5. - Desarrollar el algoritmo o pseudo código.6. - Codificar el programa.7. - Capturar la codificación.8. - Prueba y detección de errores. 9. - Depuración del programa.

10. - Ejecución y puesta en operación del programa.

A continuación se explica detalladamente cada uno de los pasos indicados.

1. - Determinar el objetivo o problema.

La determinación de un objetivo o problema, generalmente lo hace el Ingeniero, Técnico enSistemas Computacionales o Programador Analista, el cual sobre la base de una serie de estudios(Análisis de Sistemas), enfocados a la administración de una empresa, detecta las fallas de ésta ypropone soluciones, las cuales serán los objetivos o problemas que resolverá el Técnico en Informática,Técnico Programador o Programador de Computadoras.

2. - Análisis del problema:

A) Determinar los datos de salida solicitados, y los datos de entrada necesarios.

Para resolver este paso nos apoyaremos en el punto 1, y definiremos que es loque se nos esta pidiendo, es decir, "hacia donde vamos"; y determinaremos que es loque necesitamos para obtener lo que se nos pide, en otras palabras, "de donde




partiremos".

B) Determinar los pasos para resolver el problema.

Aquí, debe pensarse como se resolvería el problema a mano, paso a paso, yanotarlos. Se debe tener el cuidado de revisar los pasos especificados.

C) Comprender y detallar los pasos para resolver el problema.

Se desglosaran todos y cada uno de los pasos listados en el punto anterior,tratando de que se detallen todos los aspectos, y posibles casos que se pudiesenpresentar.

3. - Desarrollar el diagrama de bloques o diagrama de flujo de sistemas.

El diagrama de bloques es la representación gráfica, de manera general, de la resoluciónde un problema. Para resolver este punto nos apoyaremos en el paso 2b. Más adelante veremos

todo lo relacionado con los diagramas de bloques.

4. - Diseñar el diagrama de flujo.

Un diagrama de flujo es la representación gráfica de la resolución de un problema. Pararesolver este punto nos apoyaremos en el paso 2c. Posteriormente veremos con mayor detalle eltema de diagramas de flujo.

5. - Desarrollar el algoritmo o pseudo código.

En este caso, el algoritmo o pseudo código se considera como la traducción del diagrama

de flujo a instrucciones en lenguaje común, es decir, el que utilizamos cotidianamente. Porejemplo, en nuestro caso, el español.

Dependiendo del estilo de programación que se tenga, se pueden usar palabrasreservadas de algún lenguaje de programación, mezcladas con palabras del lenguaje quecomúnmente utilizamos.

6. - Codificar el programa.

La codificación de un programa, puede ser considerada como, la traducción de lasinstrucciones en lenguaje común a un lenguaje de programación, es decir, la traducción delalgoritmo o pseudo código a un lenguaje de programación.

A continuación se muestra un cuadro con las instrucciones más comúnmente utilizadasal programar, así como sus equivalentes en algunos lenguajes de programación.




Lenguaje Común Lenguaje Basic Lenguaje Pascal Lenguaje Clipper Lenguaje C Desplegar

(en pantalla)Print

(imprimir)Write

(escribir)Say

(decir)Printf

(imprimir) Introducir

(por teclado)Input

(introducir)Read(leer)

Get-Read(tomar-leer)

Scanf (examinar)

Sí-Entonces-Sino If-Then-Else(Si-Entonces-Sino) If-Then -Else-;(Sí-Entonces-Sino) If-Else-EndIf (Sí—Sino-FinSí) If-Else-;(Sí—Sino-;)En caso On-goto

(Según-ir a)Case Of

(Caso de)Do Case

(Hacer en caso)Switch-Case

(Interruptor-Caso)

Para-Hasta-Siguiente For-To-Next(Para-Hasta-Siguiente)

For-To-;(Para-Hasta-;)

For-To-Next(Para-Hasta-Siguiente)

For(){};(Para()-{}-;)

Hacer Mientras While-Wend(Mientras-FinMientras)

While-Do-;(Mientras-Hacer-;)

Do While-EndDo(Hacer-Mientras-FinHacer)

While-;(Mientras-;)

Hacer Hasta Do-Until(Hacer-Hasta)

Do-while-;(Hacer-Mientras-;)

Como se puede observar, cada instrucción en lenguaje común tiene su equivalente encada uno de los lenguajes de programación mencionados en la tabla.

A continuación daré una breve descripción del uso de cada instrucción, sin embargodebo anotar, que cada una de las instrucciones se verá con mayor detalle a continuación, claroestá, sin profundizar en ningún lenguaje de programación, pues no es el objetivo.

La instrucción Desplegar tiene como objetivo mostrar información en la pantalla dela computadora.

La instrucción Introducir tiene como objetivo el indicarle a la computadora que tome,recoja o lea datos del teclado.

La instrucción Sí-entonces-sino es utilizada para ejecutar grupos de instruccionesdependiendo del resultado que arroje una expresión lógica, es decir, Sí la expresión lógica esverdadera entonces ejecuta el primer grupo de instrucciones sino es así ejecuta el segundogrupo de instrucciones.

La sentencia En Caso, es utilizada para ejecutar un grupo de instrucciones específicodependiendo del valor o condición de una o más variables en una expresión lógica, o bien, delresultado de una o más expresiones lógicas.

La sentencia Para-Hasta-Siguiente, tiene como objetivo ejecutar un grupo deinstrucciones o sentencias un determinado número de veces.

La sentencia Hacer-Mientras, es similar a la anterior, pero en este caso el número deveces que se ejecute el grupo de instrucciones es indeterminado y dependerá del resultado de

una expresión lógica, la cual se evalúa primero.La sentencia Hacer-Hasta, es parecida a la anterior pero, en esta, se evalúa la expresiónlógica después de que se ejecuto el grupo de instrucciones al menos una vez.

7. - Capturar la codificación.

La captura de la codificación es la introducción de las instrucciones escritas en unlenguaje de programación, en la computadora. Este trabajo normalmente lo realiza el personal




de Captura de datos, o bien el auxiliar del programador, cuando se labora en una empresa degran tamaño, y que en su estructura estén considerados estos puestos; pero si no es así, la realizael Técnico o Ingeniero que desarrollo los programas.

Cuando el programador ya tiene suficientes “horas de vuelo”, inclusive omite todos lospuntos anteriores y directamente codifica “al vuelo”, sin embargo, es recomendable, para elprincipante no omitir ningún paso, hasta que se sienta lo suficientemente experimentado para

hacerlo.Y, aún cuando un programador tenga suficiente experiencia, siempre es aconsejabledesarrollar los pasos anteriores, inclusive aún cuando ya tenga funcionando el programa en elsistema, puesto que todo eso servira como documentación del programa y sustentará lainformación global de un sistema más complejo.

8. - Prueba y detección de errores.

Una vez que se ha codificado un programa, es necesario probarlo, para ellointroduciremos datos que serán procesados y de los cuales previamente conocemos el resultado;para esto debemos realizar el proceso a mano con cuando menos, dos series de datos de entrada

hasta obtener los resultados finales. El objetivo de dichas pruebas es la detección o localizaciónde errores en nuestro programa.

TIPOS DE ERRORES

Existen dos tipos de errores, del programador, que se pueden presentar durante eldesarrollo de un programa: Errores de sintaxis y errores de lógica. Los primeros, la mayoría delas veces son fáciles de detectar y localizar, ya que la mayoría de los traductores nos indican,aproximadamente, donde está el error. Estos errores generalmente se cometen durante la capturade la codificación, y casi nunca alteran la lógica del programa, aunque en ocasiones puedeexistir un error de sintaxis que no detecte el traductor y altere la lógica de nuestros programas,

pero esto resulta ser en casos muy raros (en lo personal me paso en una ocasión con GwBasic).En el segundo caso, con los errores de lógica, debemos preocuparnos un poco mas, ya

que estos errores son difíciles de detectar y localizar, y vienen de malos planteamientos en laresolución del problema, así que en caso de presentarse, deberemos revisar la resolución delproblema desde el principio y los planteamientos que se especificaron al inicio de la resolución,hasta localizar el error.

Por último, otro tipo de errores, no imputables al programador, que debemos contemplary prever, son los que se generan en tiempo de ejecución (cuando la aplicación o programa estáen marcha),.

En tiempo de ejecución, si el usuario intenta una operación que el sistema o programa nopuede realizar, entonces se produce lo que se conoce como un error en tiempo de ejecución.Supongamos, por ejemplo, que vamos a hacer que nuestra aplicación vuelque (grabe) algunainformación a un disco flexible, o incluso a otro disco fijo (también llamado duro). ¿Qué tiposde errores podríamos anticipar? Que dicha unidad no exista, que el disco se encuentre lleno oque el disco no se encuentre formateado. Puede que queramos escribir código que se refiera a unarchivo de datos y luego renombremos el archivo sin actualizar nuestro código: aunque nuestrasintaxis sea correcta, resulta que el objeto o archivo no existe y se producirá un error en tiempode ejecución.




Los errores en tiempo de ejecución son habitualmente más difíciles de arreglar que loserrores de sintaxis, simplemente porque los errores en tiempo de ejecución pueden serocasionados por múltiples razones. Además, las fuentes de los errores en tiempo de ejecuciónno siempre serán obvias; a menudo tendremos que hacer algunas verificaciones paraencontrarlos. Por ejemplo, puede darse el caso de que una aplicación funcione bien bajo ciertascircunstancias, puede que no lo haga si un usuario introduce de manera accidental un tipo de

datos erróneo. Tendremos que ser capaces de crear rutinas de tratamiento de errores parainterceptar dichos errores en tiempo de ejecución y actuar de manera especifica sobre ellos,dependiendo del tipo que sean.

CONTROL DE ERRORES EN TIEMPO DE EJECUCION.

Al controlar los errores en tiempo de ejecución, haremos que nuestra aplicación sea mástolerante con los errores que se encuentre. Podremos tratar estos errores utilizando rutinas detratamiento de errores, haciendo así que nuestra aplicación parezca más robusta y permitiendosalidas de programa más elegantes cuando se produzca lo inesperado.

Las aplicaciones que controlan errores en tiempo de ejecución podrán manejar los

errores de usuario más comunes sin necesidad de parar la aplicación. Cuanto más habilidadtengamos de anticipar los errores convencionales (tales como que nuestra aplicación estéesperando que el usuario introduzca un número y éste introduce un carácter) y protegernosfrente a ello, menos posibilidades tendrá nuestra aplicación de interrumpirse. Por ejemplo, enuna situación en la cual nuestra aplicación está esperando que el usuario introduzca un número,podríamos utilizar una rutina de tratamiento de errores que solicite al usuario a que inserte unnúmero en vez de un carácter alfabético.

CIERRE DE LA APLICACIÓN EN FORMA ADECUADA.

En aquellas ocasiones en las que una rutina de tratamiento de errores no pueda resolver

un error en tiempo de ejecución, todavía podrá ejecutar importantes acciones, tales como cerrarcualquier archivo de datos abierto (y potencialmente guardando considerables cantidades dedatos que de manera contraria se perderían). En el ejemplo anterior, si el usuario no introduceun número cuando se le solicita, la aplicación se podría cerrar, de tal manera que no le estépreguntando continuamente al usuario que introduzca un número. Procure generar salidasdelicadas al crear su rutina de tratamiento de errores.

En otras palabras, para prever los errores en tiempo de ejecución, debemos pensar en losposibles errores que podría generar el usuario e intentar hacer programas a prueba de usuariosnovatos, por no decir lo que me decían mis maestros (ahí te lo dejo a la imaginación).

9. - Depuración del programa.

La depuración de un programa, es en sí, el proceso de localización y corrección de loserrores detectados. Cuando se ha localizado un error de sintaxis, basta con colocar el cursordonde el traductor nos lo indica, y corregirlo de acuerdo a la sintaxis de la instrucción.

Cuando se ha detectado un error de lógica, el proceso de depuración resulta ser muycomplicado ya que, es muy poco probable (casi imposible) que un error de sintaxis hayamodificado la lógica de nuestro programa, pero aun así, lo primero que debemos hacer esobtener un listado impreso del programa para revisarlo a conciencia, y en caso de ser necesario




hacer una "corrida de escritorio" (simular manualmente la ejecución de cada instrucción)directamente con la codificación del programa (la corrida será únicamente con el segmento querealiza el proceso en sí).

Otra forma de localizar un error de lógica, es intercalar algunas instrucciones dedespliegue, en algunos puntos del programa, tratando de que se nos muestren los valores de lasvariables que utilizamos y en las cuales se nos muestra el error (dichas instrucciones serán

temporales). En él ultimo de los casos, para detectar un error, ejecutaremos una a una lasinstrucciones del programa para observar los resultados que arroja; y si con esto no se localiza elerror, se deberá revisar en su totalidad la resolución del problema desde el primer punto, hastaeliminar todos los errores.

Actualmente, la gran mayoría de los traductores traen consigo, una opción llamada Depurador , que, sinceramente nos ayuda bastante si lo sabemos aprovechar; pues nos permiteejecutar instrucción por instrucción y ver los valores almacenados en cada variable, entre otrasmuchas facilidades que nos brinda.

Después de una depuración, se deberá probar nuevamente el programa, y depurarlo siexisten errores, y así sucesivamente, hasta que el programa funcione correctamente, y no sedetecte ningún error de sintaxis o de lógica, o se crea que se hayan previsto los posibles errores

en tiempo de ejecución que se pudieran presentar.En la actualidad debemos considerarnos afortunados, ya que los traductores cuentan conuna opción para depurar10 o eliminar errores, y estas opciones nos permiten llevar unseguimiento del contenido de las variables en nuestro programa, así como ejecutar línea a líneael mismo, con el fin de evitar las “corridas de escritorio” y encontrar más rápidamente loserrores11, para corregirlos al momento.


Una vez que se ha probado el programa y no se han detectado errores de ningún tipo;antes de integrarlo a un sistema de información, debemos ejecutarlo a manera de prueba,

durante un buen período de tiempo, con copias de la información utilizada en el sistema, paraevitar que la información original pueda ser dañada por algún error que haya pasadodesapercibido.

Después que el programa ha estado funcionando correctamente, trabajando con copiasde la información del sistema, y arrojado resultados satisfactorios, entonces podremos integrarloal sistema principal de información, para que pueda trabajar con la información original ycomplementar el sistema, resolviendo así el problema planteado.

10 Debug en inglés. Proviene de BUG, que significa bicho, y con la preposición DE, podría traducirse textualmente como

desbichar, quitar bichos, o literalmente quitar errores.11 Bugs en inglés, que aunque quiere decir bichos, se tomo para denominar técnicamente así a los errores, los cuales seconsideran como plagas, tales como la de los insectos o bichos.




4.2. - Simbología de diagramas de bloques o diagramas de flujo de sistemas.

Aunque hay muchos tipos y formas de diagramas de bloques, así como símbolos, acontinuación se presentarán los más utilizados, así como el significado o descripción que le danla mayoría de los programadores.

SIMBOLO ESCRIPCIÓN

Proceso

Proceso

Almacenamiento en mediomagnético en general

Almacenamiento físico(archivo físico manual)

Almacenamiento en mediomagnético (disco duro o fijo)

Almacenamiento en mediomagnético (cinta magnética)

Entrada/Salida general deinformación

Salida de información,reporte por impresora




4.3. - Simbología de diagramas de flujo.

De la misma manera que en el punto anterior, aunque hay muchos tipos y formas dediagramas de flujo, así como símbolos, a continuación se presentarán los más conocidos, así como el significado o descripción que le dan la mayoría de los programadores.

SIMBOLO ESCRIPCIÓN OPERACION

ENTRADA/SALIDA DEINFORMACION (ARCHIVOS)

SALIDA DE DATOS POR IMPRESORA

CONECTOR

TOMA DE DECISION

SUBRUTINA(PROCEDIMIENTO O FUNCION

ENTRADA DE DATOS POR TECLADO

INICIO/FIN DEL DIAGRAMA

SALIDA DE DATOS POR PANTALLA

CONECTOR FUERA DE PÁGINA




4.4. - Recomendaciones para el desarrollo de diagramas.

4.4.1. - Diagramas de bloques o diagramas de flujo de sistemas.

RECOMENDACIONES PARA EL DESARROLLO DEDIAGRAMAS DE BLOQUES

ODIAGRAMAS DE FLUJO DE SISTEMAS

Realmente, no se puede decir que exista alguna regla escrita acerca de la diagramación,pero si se establecen ciertas recomendaciones, como las que se indican:

1. - No interceptar (cruzar) líneas de flujo de información.2. - Usar claves dentro de los símbolos, y especificar la nomenclatura correspondiente.

4.4.2. - Diagramas de flujo.

RECOMENDACIONES PARA EL DISEÑO DE DIAGRAMAS DE FLUJO

1. El símbolo de inicio y fin, solo se utilizara dos veces, al principio y al final deldiagrama.

2. La línea de flujo debe "tocar" tanto al símbolo del que sale como al símbolo al quellega.

3. Pueden existir varios conectores de "salida", pero solo uno de "llegada"; con elmismo carácter o símbolo dentro de ellos.

4. El carácter que esta dentro del conector de salida debe ser igual al carácter dentro delconector de llegada, donde continuara el flujo del diagrama.

5. Al diagramar trataremos siempre que el flujo sea de arriba hacia abajo y de izquierdaa derecha.

6. A cualquier símbolo solo llegara una línea de flujo y saldrá de éste una línea deflujo; con excepción del símbolo de toma de decisión, al cual llega una línea de flujoy salen dos de él; y también el conector y el símbolo de inicio y fin, del cualsolamente saldrá una línea o llegara una línea de flujo.

7. No interceptar (cruzar) líneas de flujo.




4.5. - Resolución de problemas aplicando la Técnica de diseño general o elemental.

EJEMPLO DE RESOLUCION DE PROBLEMAS USANDO LA

TECNICA DE DISEÑO GENERAL O ELEMENTAL

1. - Determinar el objetivo o problema.(Deberá especificarse por el maestro el problema en sí).

- Diseñar un programa que solicite los siguientes datos de un empleado: Ficha, nombre, puesto,antigüedad, sueldo diario, días trabajados; que calcule y muestre el sueldo total neto a pagar, así comolas cuotas por pagar por el patrón por sus prestaciones sobre su sueldo total bruto: un 3 % del SeguroSocial, 1 % de Apoyo a la Educación, 5 % de Infonavit, 2 % de I.S.P.T. (Impuesto Sobre Productos delTrabajo; y 3 % del SAR (Sistema de Ahorro para el Retiro. Sí el empleado tiene 5 años o más deantigüedad, se le dará un bono del 5 % sobre su sueldo total bruto.

2. - Análisis del problema:

A) Determinar los datos de salida solicitados, y los datos de entrada necesarios.

DATOS DE SALIDA: Total neto a pagar, salario total a pagar, Cuotas del I. M. S. S., de Apoyoa la Educación, del Infonavit, del S.A.R., Retención del I.S.P.T., Importe del Bono.

DATOS DE ENTRADA: Nombre, puesto, antigüedad, salario diario, días trabajados.

B) Determinar los pasos para resolver el problema.

1. Solicitar los datos del empleado.

2. Calcular el salario total a pagar.3. Calcular las cuotas por pagar.4. Calcular el Total Neto a Pagar.5. Mostrar los importes del sueldo total neto a pagar, sus prestaciones y deducciones.

C) Comprender y detallar los pasos para resolver el problema.

1. Inicializar variables.2. Pedir el Nombre.3. Pedir el Puesto.4. Pedir la Antigüedad.5. Pedir el Salario Diario.6. Pedir los Días Trabajados.7. nSalarioTotalAPagar = nDiasTrabajados*nSalarioDiario8. nImss = nSalarioTotalAPagar * 0.039. nApoyoEducación = nSalarioTotalAPagar * 0.0110. nInfonavit = nSalarioTotalAPagar * 0.0511. nSar = nSalarioTotalAPagar * 0.0312. nIspt = nSalarioTotalAPagar * 0.02




13. ¿ nAntigüedad => 5 años ?SI: nBono = nSalarioTotalAPagar * 0.05NO: nBono = 0

14. nTotalAPagar = nSalarioTotalAPagar + nBono15. Mostrar: nImss16. Mostrar: nApoyoEducación

17. Mostrar: nInfonavit18. Mostrar: nSar19. Mostrar: nIspt, nBono20. Mostrar: nSalarioTotalAPagar21. Mostrar: nTotalAPagar.

1. Desarrollar el diagrama de bloques.

Datos delEmpleado

Calculo delSueldo

Total de deducciones,prestaciones y Total a

Pagar

Calculo de lasdeducciones yprestaciones




2. Diseñar el diagrama de flujo.

INICIO

INICIALIZARVARIABLES

“Dame lossiguientes datos:”

“Nombre:”

cNombre

“Puesto:”

cPuesto

“Antigüedad:”

nAntig

1

1

“SalarioDiario:”

nSalDia

“DíasTrabajados:”

nDiasTrab

nSalTotAPag =nDiasTrab * nSalDia

nImss =nSalTotAPag * 0.03

nApEduc =nSalTotAPag * 0.01

2

2

nInfonavit =nSalTotAPag * 0.05

nSar =nSalTotAPag * 0.03

nIspt =nSalTotAPag * 0.02

¿ nAntig >= 5 ?

SI

NO

nBono =nSalTotAPag * 0.05

nTotNetoAPagar =

nSalTotAPag + nBono

“Resultados:”,“IMSS:”; nImss, “ISPT:”; nIspt,“SAR:”; nSar, “Ap. Educ.:”; nApEduc,“Infonavit:”; nInfonavit,“Bono:”; nBono,“Sal. Total a Pagar:”; nSalTotAPag,“Tot. Neto a Pagar:”; nTotNetoAPagar

FIN

3

3




3. Desarrollar el algoritmo o pseudo código.

NOTA: Por esta única ocasión, tanto en el algoritmo como en las codificaciones que se veran acontinuación, se resaltan en rojo las palabras reservadas y los operadores; así mismo se resaltan enazul los nombres de variables. El objetivo es que establezcas la relación entre las palabras utilizadas

en el algoritmo y su equivalente en los diferentes lenguajes de programación.

1. Inicializar variables.2. Desplegar "Dame los siguientes datos:"3. Desplegar "Nombre:"4. Introducir cNombre 5. Desplegar "Puesto:"6. Introducir cPuesto 7. Desplegar "Antigüedad:"8. Introducir nAntig 9. Desplegar "Salario Diario:"

10. Introducir nSalDia 11. Desplegar "Días Trabajados:"12. Introducir nDiasTrab 13. nSalTotAPag = nDiasTrab * nSalDia 14. nImss = nSalTotAPag * 0.0315. nApEduc = nSalTotAPag * 0.0116. nInfonavit = nSalTotAPag * 0.0517. nSar = nSalTotAPag * 0.0318. nIspt = nSalTotAPag * 0.0219. Sí nAntig >= 5 entonces

nBono = nSalTotAPag * 0.05

sino nBono = 0

20. nTotNetoAPagar = nSalTotAPag + nBono 21. Desplegar “Resultados:”22. Desplegar “IMSS:”; nImss 23. Desplegar “ISPT:”; nIspt 24. Desplegar “SAR:”; nSar 25. Desplegar “Ap. Educ.:”; nApEduc 26. Desplegar “Infonavit:”; nInfonavit 27. Desplegar “BONO:”; nBono 28. Desplegar “Sal. Total a Pagar:”; nSalTotAPag 29. Desplegar “Tot. Neto a Pagar:”; nTotNetoAPagar 30. FIN.

6. - Codificar el programa.

Esta actividad se realiza cuando se domina algún lenguaje de programación, por ejemplo Basic,Pascal, C, Clipper, etc.

A continuación presentare la codificación del programa anterior en algunos lenguajes.




Lenguaje Basic.

10 REM Programa EJEMGBAS.BAS 20 REM Método de Diseño General o Elemental. 30 REM Programa Principal. 40 REM ***********************************************************************50 REM Inicializando variables. 60 REM ***********************************************************************

70 CNOMBRE$="":CPUESTO$="":NANTIG=0:NSALDIA=0:NDIASTRAB=0:NSALTOTAPAG=080 NIMSS=0:NAPEDUC=0:NINFONAVIT=0:NSAR=0:NISPT=0:NBONO=0:NTOTNETOAPAGAR=090 CLS 'Borra la pantalla100 REM ***********************************************************************110 REM Solicitud de datos al usuario. 120 REM ***********************************************************************130 PRINT "Dame los siguientes datos:"140 PRINT "Nombre:";150 INPUT CNOMBRE$ 160 PRINT "Puesto:";170 INPUT CPUESTO$ 180 PRINT "Antigüedad:";190 INPUT NANTIG 200 PRINT "Salario Diario:";

210 INPUT NSALDIA 220 PRINT "Dias Trabajados:";230 INPUT NDIASTRAB 240 REM ***********************************************************************250 REM Cálculos de ingresos y cuotas.260 REM ***********************************************************************270 NSALTOTAPAG = NDIASTRAB * NSALDIA 280 NIMSS = NSALTOTAPAG * .03290 NAPEDUC = NSALTOTAPAG * .01300 NINFONAVIT = NSALTOTAPAG * .05310 NSAR = NSALTOTAPAG * .03320 NISPT = NSALTOTAPAG * .02330 IF NANTIG >= 5 THEN NBONO = NSALTOTAPAG * .05 ELSE NBONO = 0340 NTOTNETOAPAGAR = NSALTOTAPAG + NBONO 350 REM ***********************************************************************360 REM Despliegue de Resultados.370 REM ***********************************************************************380 PRINT "Resultados:"390 PRINT "IMSS: ";NIMSS 400 PRINT "ISPT: ";NISPT 410 PRINT "SAR: ";NSAR 420 PRINT "Apoyo a la Educación: ";NAPEDUC 430 PRINT "INFONAVIT: ";NINFONAVIT 440 PRINT "Bono: ";NBONO 450 PRINT "Salario Total a Pagar: ";NSALTOTAPAG 460 PRINT "Total Neto a Pagar: ";NTOTNETOAPAGAR 470 END 'Fin del programa.




Lenguaje Quick Basic. (Podríamos considerar éste, como un dialecto del Basic).

REM Programa EJEGQBAS.BAS REM Método de Diseño General o Elemental. REM Programa Principal. REM Inicializando variables.

cNombre$ = "": cPuesto$ = "": nAntig = 0: nSalDia = 0: nDiasTrab = 0

nSalTotAPag = 0: nImss = 0: nApEduc = 0: nInfonavit = 0: nSar = 0: nIspt = 0nBono = 0: nTotNetoAPagar = 0

CLS 'Borra la pantalla.

REM Solicitud de datos al usuario.

PRINT "Dame los siguientes datos:"PRINT "Nombre:";INPUT cNombre$ PRINT "Puesto:";INPUT cPuesto$ PRINT "Antigüedad:";INPUT nAntig

PRINT "Salario Diario:";INPUT nSalDia PRINT "Días Trabajados:";INPUT nDiasTrab

REM Cálculos de ingresos y deducciones.

nSalTotAPag = nDiasTrab * nSalDia nImss = nSalTotAPag * .03nApEduc = nSalTotAPag * .01nInfonavit = nSalTotAPag * .05nSar = nSalTotAPag * .03nIspt = nSalTotAPag * .02

IF nAntig >= 5 THEN nBono = nSalTotAPag * .05

ELSEnBono = 0

END IF

nTotNetoAPagar = nSalTotAPag + nBono

REM Despliegue de Resultados.

PRINT "Resultados:"PRINT "IMSS: "; nImss PRINT "ISPT: "; nIspt PRINT "SAR: "; nSar PRINT "Apoyo a la Educación: "; nApEduc

PRINT "INFONAVIT: "; nInfonavit PRINT "Bono: "; nBono PRINT "Salario Total a Pagar: "; nSalTotAPag PRINT "Total Neto a Pagar: "; nTotNetoAPagar

END




Lenguaje Pascal.

PROGRAM Ejemplo;

(* Programa EJEGPASC.PAS *)(* Método de Diseño General o Elemental. *)(* Programa Principal. *)

(* Especificación del dispositivo o unidad de salida *)

USES CRT; (* Usar el monitor –Catodic Ray Tube, Tubo de Rayos Catódicos- *)

(* Declarando variables. *)

VAR cNombre : STRING[10];cPuesto : STRING[10];nAntig : REAL;nSalDia : REAL;nDiasTrab : REAL;nSalTotAPag : REAL;nImss : REAL;nApEduc : REAL;nInfonavit : REAL;

nSar : REAL;nIspt : REAL;nBono : REAL;nTotNetoAPagar : REAL;

BEGIN (* Inicio *)

(* Inicializando variables. *)

nAntig := 0;nSalDia := 0;nDiasTrab := 0;nSalTotAPag := 0;nImss := 0;

nApEduc := 0;nInfonavit := 0;nSar := 0;nIspt := 0;nBono := 0;nTotNetoAPagar := 0;

CLRSCR; (* Borra la pantalla *)

(* Solicitud de datos al usuario. *)

WRITELN('Dame los siguientes datos:');WRITE('Nombre: ');READLN(cNombre);WRITE('Puesto: ');READLN(cPuesto);WRITE('Antigüedad: ');READLN(nAntig);WRITE('Salario Diario: ');READLN(nSalDia);WRITE('Días Trabajados: ');READLN(nDiasTrab);

(* Cálculos de ingresos y deducciones. *)




nSalTotAPag := nDiasTrab * nSalDia;nImss := nSalTotAPag * 0.03;nApEduc := nSalTotAPag * 0.01;nInfonavit := nSalTotAPag * 0.05;nSar := nSalTotAPag * 0.03;nIspt := nSalTotAPag * 0.02;

IF nAntig >= 5 THEN nBono := nSalTotAPag * 0.05

ELSEnBono := 0;

nTotNetoAPagar := nSalTotAPag + nBono;

(* Despliegue de Resultados. *)

WRITELN('Resultados:');WRITELN('IMSS: ',nImss:10:2);WRITELN('ISPT: ',nIspt:10:2);WRITELN('SAR: ',nSar:10:2);WRITELN('Apoyo a la Educación: ',nApEduc:10:2);WRITELN('INFONAVIT: ',nInfonavit:10:2);

WRITELN('Bono: ',nBono:10:2);WRITELN('Salario Total a Pagar: ',nSalTotAPag:10:2);WRITELN('Total Neto a Pagar: ',nTotNetoAPagar:10:2);

END.




Lenguaje Clipper12.

FUNCTION Ejemplo()

* Programa EJEGCLIP.PRG* Método de Diseño General o Elemental.* Programa Principal.

* Declarando e Inicializando variables.

LOCAL cNombre := " ", cPuesto := " ",;nAntig := 0, nSalDia := 0, nDiasTrab := 0, nSalTotAPag := 0,;nImss := 0, nApEduc := 0, nInfonavit := 0, nSar := 0,;nIspt := 0, nBono := 0, nTotNetoAPagar := 0

CLS //Borra la pantalla.

* Solicitud de datos al usuario.

@ 1,10 SAY "Dame los siguientes datos:"@ 2,10 SAY "Nombre:"@ 2,30 GET cNombre

@ 3,10 SAY "Puesto:"@ 3,30 GET cPuesto @ 4,10 SAY "Antigüedad:"@ 4,30 GET nAntig @ 5,10 SAY "Salario Diario:"@ 5,30 GET nSalDia @ 6,10 SAY "Días Trabajados:"@ 6,30 GET nDiasTrab READ

* Cálculos de ingresos y deducciones.

nSalTotAPag := nDiasTrab * nSalDia nImss := nSalTotAPag * .03nApEduc := nSalTotAPag * .01nInfonavit := nSalTotAPag * .05nSar := nSalTotAPag * .03nIspt := nSalTotAPag * .02

IF nAntig >= 5nBono := nSalTotAPag * .05

ELSEnBono := 0

END IF

nTotNetoAPagar := nSalTotAPag + nBono

* Despliegue de Resultados.

@ 8,10 SAY "Resultados:"@ 9,10 SAY "IMSS: "

12 Aunque algunos programadores van muy lejos negándole el título de lenguaje a Clipper, eso es una verdad a medias. Lamayoría sabemos que los programas generados por Clipper son en realidad P-CODE, es decir pseudo código (muyoptimizado por cierto), que se interpreta en tiempo de ejecución, en lugar de ejecutarse directamente. Ese posible “defecto”no resta valor alguno a una de las mejores y mas potentes herramientas de programación existentes en el mercado. Tanto queinclusive ha incursionado en las tendencias de programación orientada al objeto y programación dirigida por eventos,logrando con esto crear aplicaciones incluso para ambiente Windows. En el presente ejemplo, se utilizo la versión 5.2e




@ 9,35 SAY nImss @ 10,10 SAY "ISPT: "@ 10,35 SAY nIspt @ 11,10 SAY "SAR: "@ 11,35 SAY nSar @ 12,10 SAY "Apoyo a la Educación: "@ 12,35 SAY nApEduc @ 13,10 SAY "INFONAVIT: "@ 13,35 SAY nInfonavit @ 14,10 SAY "Bono: "@ 14,35 SAY nBono @ 15,10 SAY "Salario Total a Pagar: "@ 15,35 SAY nSalTotAPag @ 16,10 SAY "Total Neto a Pagar: "@ 16,35 SAY nTotNetoAPagar

RETURN




C++

/* Programa EJEMGC.C Método de Diseño General o Elemental.Programa Principal. */

#include <stdio.h> /* Incluir archivo stdio.h –stANDARd iNPUT oUTPUT. hEADING- *//* Encabezado Normal o Universal de Entrada Salida*/

main () /* Inicio del programa principal */

{ /* Declarando e inicializando variables. */char cNombre[10];char cPuesto[10];float nAntig = 0;float nSalDia = 0;float nDiasTrab = 0;float nSalTotAPag = 0;float nImss = 0;float nApEduc = 0;float nInfonavit = 0;float nSar = 0;

float nIspt = 0;float nBono = 0;float nTotNetoAPagar = 0;

/* Solicitud de datos al usuario. */

printf("Dame los siguientes datos:\n");printf("Nombre: ");scanf("%s",cNombre);printf("Puesto: ");scanf("%s",cPuesto);printf("Antigüedad: ");scanf("%f",&nAntig);printf("Salario Diario: ");

scanf("%f",&nSalDia);printf("Días Trabajados: ");scanf("%f",&nDiasTrab);

/* Cálculos de ingresos y deducciones. */

nSalTotAPag = nDiasTrab * nSalDia;nImss = nSalTotAPag * 0.03;nApEduc = nSalTotAPag * 0.01;nInfonavit = nSalTotAPag * 0.05;nSar = nSalTotAPag * 0.03;nIspt = nSalTotAPag * 0.02;

if(nAntig >= 5)nBono = nSalTotAPag * 0.05;

elsenBono = 0;

nTotNetoAPagar = nSalTotAPag + nBono;

/* Despliegue de Resultados. */

printf("Resultados:\n");printf("IMSS: %f\n",nImss);printf("ISPT: %f\n",nIspt);printf("SAR: %f\n",nSar);




printf("Apoyo a la Educación: %f\n",nApEduc);printf("INFONAVIT: %f\n",nInfonavit);printf("Bono: %f\n",nBono);printf("Salario Total a Pagar: %f\n",nSalTotAPag);printf("Total Neto a Pagar: %f\n",nTotNetoAPagar);

} /* Fin del programa. */

7. - Capturar la codificación.

Esta actividad, consiste en introducir las instrucciones del programa ya codificado, en lacomputadora. Generalmente, cuando ya se tiene un poco de experiencia en la programación, elprogramador captura directamente el código.

En el disquete que acompaña a esta obra, vienen los códigos fuentes del programa de ejemplo,así como los ejecutables del mismo, en su respectivo lenguaje.

8. - Prueba y detección de errores.Se realiza esta actividad, tras terminar la captura del programa.

9. - Depuración del programa.

Es la corrección de los errores detectados durante las pruebas efectuadas en la actividadanterior.


Después de estar probado el programa, y de estar ejecutándolo durante un tiempo, a prueba, concopias de la información original, el programa se incorpora al sistema principal, donde trabajara coninformación original.




5. - Diagramas de flujo.

5.1. - Tipos de diagramas de flujo.

5.1.1. - Diagramas de flujo lineales.

Los diagramas de flujo lineales, son aquellos en los cuales, el conjunto deinstrucciones se ejecutan una sola vez.

5.1.2. - Diagramas de flujo cíclicos.

Los diagramas de flujo cíclicos, son aquellos en los cuales, un conjunto deinstrucciones o todas se ejecutan una cantidad determinada o indeterminada de veces.

5.2. - Estructuras de diagramas de flujo lineales.

5.2.1. - Estructura de secuencia.

Una estructura de secuencia se representa ya sea por medio del símbolo de

proceso o el símbolo de proceso predefinido (subrutinas, procedimientos o funciones).También es posible tener símbolos múltiples de proceso o de proceso predefinido dentrode una sola estructura de secuencia. Sin embargo, existe solo una entrada a unaestructura de secuencia y una salida a partir de ésta; éste es un punto muy importante quese cumple para todas las estructuras. En la siguiente figura se muestra una estructura desecuencia que contiene pasos múltiples.

INICIO

OPERACIÓN 1

OPERACIÓN 3

OPERACIÓN 2

FIN




5.2.2. - Estructura de decisión.

El símbolo de decisión representa una decisión que se efectúa y las rutas lógicasalternativas que deben seguirse como resultado. Existe una entrada a un símbolo de

decisión y dos salidas a partir de él; sin embargo, sigue existiendo solo una entrada a laestructura de decisión y una salida a partir de esta. El símbolo de decisión es solo unaparte de la estructura de decisión. Este punto se muestra en la siguiente figura.

5.2.3. - Ramificaciones.

Un tipo común de decisión en varios sentidos depende de la forma en que elcontenido de una variable cambia, y las diversas opciones que se presenten, este es elcaso de la estructura "EN CASO", en la cual puede tomarse una de varias




ramificaciones, dependiendo del contenido de una variable o del resultado de unaexpresión booleana.

5.3. - Estructuras de diagramas de flujo cíclicos.

5.3.1. - Creación de ciclos, iteraciones o bucles.

En diagramas de flujo en donde se están leyendo registros o datos múltiples (lasmás de las veces) siempre se efectúa una ramificación de regreso a la verificación deBANDERA-FIN después de leer otro registro al final de la rutina PROCESO. Esteproceso de re-utilizar el mismo conjunto de lógica para cada registro que se procesa esun ejemplo de CICLO. La creación de ciclos consta de ejecutar cualquier serie deinstrucciones en forma repetida. Sin embargo, los ciclos no tienen que incluir toda larutina de PROCESO; pueden cubrir solo una pequeña parte de la rutina (PROCESO uotra). En algunas ocasiones a los bucles también se les llama como ANILLOS.

5.3.2. - Pasos de un ciclo o bucle.

En cualquier proceso de ciclo están presentes algunos pasos estándar. Estospasos, excepto el primero, pueden encontrarse en casi cualquier orden que se necesitepara producir el efecto deseado. La principal diferencia es en cuanto a la parte del cicloen que se efectúan la modificación y la prueba, lo que provocara que el ciclo se conozcacomo controlado desde el inicio o controlado desde la salida. Dependiendo del lenguajeque se este utilizando para implantar el diagrama de flujo, el proceso de inicialización,modificación y prueba tal vez requiera dos o más instrucciones reales de programaciónpara lograr las acciones necesarias.

1. Inicialización: Paso en el que se da un valor inicial a los elementos. Estoselementos se utilizaran para determinar cuando puede concluir el ciclo. Estopuede implicar trasladar un valor como UNO a un área.

2. Procesamiento: Paso o pasos en el ciclo en los que el procesamiento realpresente dentro del ciclo se efectúa.

3. Modificación: Paso del ciclo en que efectúa algún tipo de alteración alelemento que se inicializo en el paso 1. Esto podrá ser sumar UNO a uncontador, leer el siguiente registro disponible o modificar el valor de alguna

CONDICION CONDICION CONDICION CONDICIONCONDICION




variable.

4. Prueba: Paso del ciclo en el que se prueba el valor de un elemento (comodeterminar si el registro es de datos o el valor de un contador ha excedido unvalor dado) para determinar si el ciclo debe continuarse o concluirse.

5.3.3. - Ciclos o bucles anidados.

También es posible que un diagrama de flujo contenga múltiples ciclos y que unciclo este dentro de otro más grande. Cuando un ciclo esta dentro de otro más grande, sedice que el que se encuentra en el interior esta anidado.

5.3.4. - Estructura de " para hasta ".

Esta estructura es muy especial ya que el número de ciclos que se efectuaran es,normalmente, fijo; y se basa en la verificación de una variable numérica; ejecutándose elproceso hasta que dicha variable numérica excede el número establecido de ciclos.

En este tipo de bucle, a la VARIABLE (V) numérica se le asigna el valorINICIAL (I) a la cual se le sumara el INCREMENTO (INC) después de cada ejecuciónde las instrucciones del PROCESO hasta que alcance un valor mayor que el valorFINAL (F).

V = I

V > F

INC

PROCESO

VERDADERO

FALSO

ENTRADA

SALIDA




El símbolo aquí presentado, es exclusivo de este tipo de bucle; desglosándolo setendría el siguiente diagrama de flujo:

Como es de notar, el primer diagrama es más compacto, razón por la cual es elmás utilizado cuando se hace necesario diagramar este tipo de bucle.

El algoritmo se escribiría de la siguiente manera:

ESPAÑOL INGLÉS

Entrada EntradaPARA V = I HASTA F INCREMENTO INC FOR V = I TO F STEP INC

PROCESO PROCESOSIGUIENTE NEXT Salida Salida

Donde la sentencia SIGUIENTE (NEXT), implica que automáticamente se sumaINC al valor de la variable V y regresa el flujo del programa a la sentencia PARA (FOR)donde se evalúa la condición.

En este punto, a propósito y de ahora en adelante, se mostrará el algoritmo de lasestructuras básicas, en el idioma inglés, para dar una aproximación a lo que será elcódigo en algún lenguaje de programación, ya que será común el manejo de este idiomaen casi todos los lenguajes de programación.

ENTRADA

V = I

V > F

PROCESO

INC

SALIDA

A

A

VERDADERO

FALSO




5.3.5. - Estructura de " hacer mientras ".

Estas estructuras se utilizan para procesos cíclicos. En la siguiente figura semuestra la estructura "hacer mientras" (do while ó while do), en donde el proceso serealiza mientras la condición en el símbolo de toma de decisión es verdadera; y cuandoresulta ser falsa, se sale del ciclo.

En el segmento de diagrama mostrado, el PROCESO se realizara mientras laCONDICION sea verdadera (SI); cuando sea falsa (NO), se dará por terminado el ciclo obucle y se saldrá de esa línea de lógica.


ESPAÑOL INGLÉS

Entrada EntradaHACER MIENTRAS Condición=Verdadera DO WHILE Condición=Verdadera

PROCESO PROCESOFIN MIENTRAS END WHILESalida Salida

El equivalente al conector A del diagrama es el FIN MIENTRAS (ENDWHILE); y esto implica que dicha sentencia hace que regrese el flujo del programa a lasentencia HACER MIENTRAS (DO WHILE) donde se evalúa la condición.

ENTRADA

CONDICION SALIDA

PROCESO

A

A

SI

NO




5.3.6. - Estructura de " hacer hasta ". (repetir hasta)

Esta estructura es similar a la estructura "hacer mientras", solo que la prueba dela condición se efectúa después de realizar, al menos una vez, el proceso. En la siguientefigura se muestra la estructura "hacer hasta" (repeat until - repetir hasta).

En el segmento de diagrama mostrado, el PROCESO se REPETIRA HASTAque la condición sea verdadera (SI); y si ésta es falsa (NO), se efectuará nuevamente elPROCESO.

Como se puede observar, al estar la evaluación de la condición después delproceso, esto asegura que el PROCESO se realice forzosamente, como mínimo, unavez.


ESPAÑOL INGLÉS

Entrada EntradaREPETIR REPEAT

PROCESO PROCESOHASTA Condición=Verdadera UNTIL Condición=VerdaderaSalida Salida

Otra forma podría ser:

ESPAÑOL INGLÉS

Entrada EntradaHACER DO

PROCESO PROCESO

ENTRADA

PROCESO

CONDICION A

A

SALIDA

NO

SI




VUELTA HASTA Condición=Verdadera LOOP UNTIL Condición=VerdaderaSalida Salida

La sentencia HASTA o VUELTA HASTA, además de evaluar la Condición; encaso de que sea falsa regresara el flujo del programa a la instrucción REPETIR oHACER, si es verdadera, saldrá del bucle.

O bien, como caso especial, y usando lógica inversa:


PROCESO PROCESOMIENTRAS Condición=Falsa WHILE Condición=FalsaSalida Salida

Que también podría quedar como:


PROCESO PROCESOMIENTRAS Condición<>Verdadero WHILE Condición<>VerdaderoSalida Salida

Y como puede observarse, cuando la condición alcance el valor Verdadero,terminará el bucle. En otras palabras, mientras la condición sea falsa, se ejecutará elbucle, y en cuanto sea verdadera, como en los casos anteriores, se saldrá del bucle.




6. - Herramientas de programación.

Las herramientas de programación, como le llamamos algunos programadores, no son otra cosaque aquellos conceptos y operaciones básicas de lógica utilizadas en los programas; las cuales sonfórmulas lógicas muy sencillas, frecuentemente utilizadas en cualquier programa.

6.1. - El contador.

Un contador es una variable numérica cuyo valor se incrementa o decrementa en unacantidad constante en el flujo de un programa, y normalmente se utiliza en los bucles. Suestructura es la siguiente:

VARIABLE CONTADOR = VARIABLE CONTADOR + INCREMENTO

Ejemplos:

nC = nC + 1 Cuenta de uno en uno.nValor = nValor + 2 Cuenta de dos en dos.nNum = nNum + 3 Cuenta de tres en tres.

6.2. - El acumulador o sumador.

Un acumulador o sumador es una variable numérica cuyo valor se incrementa odecrementa en una cantidad variable, representada por otra variable, en el flujo de un programa,y normalmente se utiliza en los bucles. Su estructura es la siguiente:

VARIABLE ACUMULADOR = VARIABLE ACUMULADOR + VARIABLE INCREMENTO

Ejemplos:

nC = nC + nSnValor = nValor + nCant

nNum = nNum + nPar




6.3. - La bandera o indicador.

Es una variable de tipo booleano o, en ocasiones, tipo carácter, la cual solo adquiere unode dos valores, considerándolos como 0 (apagado) ó false, y 1 (encendido) ó true. Dichavariable se utiliza en estructuras de control en una bifurcación condicional, tal y como semuestra en el siguiente ejemplo:

La aplicación práctica de una BANDERA o INDICADOR, es la de condicionar unaacción dentro de nuestro programa, tal y como se muestra en el diagrama. Se dice que laBANDERA se “enciende” (TRUE o 1) cuando se ha logrado una condición o resultado y se“apaga” (FALSE o 0) en caso contrario. Cuando el valor de la BANDERA es modificada, seefectuará o no un proceso alternativo, o bien se sale o no, de un bucle o programa.

En el diagrama del ejemplo, se inicializa la variable BANDERA a un Valor lógico 1(TRUE o FALSE, 1 o 0), posteriormente se realiza el PROCESO A, el cual dentro de su lógicamodifica o no el valor de la variable BANDERA, y al terminar el PROCESO A, se compara elvalor de la variable BANDERA con el Valor lógico 2 (TRUE o FALSE, 1 o 0), y dependiendodel resultado que arroje se ejecutara o no, el PROCESO B alternativo.

ENTRADA

BANDERA = Valor

PROCESO A

BANDERAOperador lógicoValor lógico 2

PROCESO B

A

A

SALIDA

SI ó NO

NO ó SI




6.4. - Salida de un programa por opción.

En este tipo de herramienta, se establece una rutina, que consiste en preguntar al usuariosi desea continuar con un proceso o finalizar, inmediatamente se verifica la respuesta y seejecuta la acción correspondiente, que es continuar con la ejecución del proceso o finalizar.

El siguiente diagrama muestra uno ejemplo de esta salida.

En el despliegue se colocara el mensaje de acuerdo al proceso que se este desarrollando,y en la toma de decisión el carácter puede ser “N”, aunque esto invertiría el orden de las salidas(SI y NO).

ENTRADA

PROCESO

“¿ DeseaContinuar

(S/N) ?

cRespuesta

cRespuesta=

“S”

SI

NO

SALIDA

A

A




6.5. - Salida de un programa por centinela.

Una salida por centinela, se establece cuando una condición o condiciones se cumplen ono, lo cual genera en su caso la finalización del programa o no, dependiendo de la condición queestablezca el programador. A continuación se ilustra un diagrama mostrando la lógica deoperación de una salida por centinela.

En el diagrama, el PROCESO puede solicitar datos por teclado o bien leer datos de un

archivo, y cuando se tome un dato determinado, este se compara en la CONDICIÓN el cualcontendrá un valor determinado, y en función del resultado de la expresión lógica(CONDICION) se saldrá o no del programa.

6.6. – Subrutinas, procedimientos y funciones.

6.6.1.- Subrutinas.

Una Subrutina, es un grupo de instrucciones que efectúa una parte identificable delprograma general. Y normalmente se crean para evitar la codificación repetitiva de grupos deinstrucciones a lo largo del programa. Son ejemplos representativos de elementos que podríanencontrarse en subrutinas:

1. Rutinas de mantenimiento.2. Rutinas de encabezado.3. Rutinas de cálculo.4. Rutinas de procesamiento de tablas.5. Rutinas de edición.6. Inicializar variables o Colocar contadores en cero.

El diagrama que sigue, muestra en líneas discontinuas lo que sería el flujo de un

ENTRADA

PROCESO

CONDICIÓNSI ó NO

NO ó SI

SALIDA

A

A




programa que llama a una subrutina.

Como se puede observar en el diagrama, la llamada a la Subrutina transfiere el flujo delprograma a otro punto donde inicia la Subrutina, y al término de esta, se retornaautomáticamente el flujo a la instrucción que sigue del lugar donde se hizo la llamada.

Las subrutinas pueden ser internas o externas. Las internas, están físicamente en elprograma y este las utiliza en el procesamiento. Las subrutinas externas las usa el programa perono son físicamente parte de él y de alguna forma debe efectuarse el acceso a ella para quepuedan utilizarse.

ENTRADA

PROCESO

SUBRUTINAA

PROCESO

PROCESO C

SUBRUTINAA

SALIDA

SUBRUTINA

PROCESO DE LASUBRUTINA

RETORNO




Las subrutinas internas pueden ser abiertas o cerradas. Las primeras se escriben dentrode la lógica principal del programa, por lo general como parte de la rutina PROCESO, mientrasque las cerradas están fuera de la lógica principal del programa (pero siguen siendo parte deeste) y debe efectuarse una ramificación hacia ellas a fin de ejecutarlas. Las subrutinas cerradasnormalmente se utilizan para las tres subrutinas principales (indicadas en la lista al inicio de estetema) en la lógica de línea principal y cuando la rutina debe ejecutarse en varios puntos del

INICIA CODIGO DEL PROGRAMA.…

CONTINUA CODIGO DEL PROGRAMA.……

LLAMADA A LA SUBRUTINA………

FIN DEL CODIGO DEL PROGRAMA.

Archivo de Código de Programa con llamada a Subrutina Interna.

INICIA CODIGO DE LA SUBRUTINA INTERNA.…

…FIN DEL CODIGO DE LA SUBRUTINA INTERNA.

INICIA CODIGO DEL PROGRAMA.………………




Archivo de Código de Programa con llamada a Subrutina Externa.

INICIA CODIGO DE LA SUBRUTINA EXTERNA.……

FIN DEL CODIGO DE LA SUBRUTINA EXTERNA.

Archivo Independiente de Código que contiene las instrucciones de la Subrutina Externa.




programa para evitar la redundancia. Sin las subrutinas cerradas, el proceso realizado por lasubrutina necesitaría volverse a realizar o a codificar en cualquier parte en que se desearaefectuar la rutina. La forma de representar en diagrama de flujo los dos tipos se muestra en lasiguiente figura:

Y por último, debo mencionar que se pueden pasar o transferir datos del programaprincipal a la subrutina a través de variables, y ésta a su vez puede regresar valores al programaprincipal a través de las mismas u otras variables. También es posible que una subrutina llame aotra subrutina, y ésta a su vez pueda llamar a otra, y así sucesivamente; teniendo como límite lascaracterísticas del lenguaje o de memoria del equipo.

Hasta este punto, hemos visto las subrutinas que fueron el intento de los primerosprogramadores para estructurar los programas; y aunque este comentario haga parecer que éstas

INICIA CODIGO PRINCIPAL DEL PROGRAMA.…


LLAMADA A LA SUBRUTINA…

……FIN DEL CODIGO DEL PROGRAMA.

Archivo de Código de Programa con Subrutina Abierta.

INICIA CODIGO DE LA SUBRUTINA ABIERTA.……

FIN DEL CODIGO DE LA SUBRUTINA ABIERTA.

INICIA CODIGO PRINCIPAL DEL PROGRAMA.……




Archivo de Código de Programa con Subrutina Cerrada.

INICIA CODIGO DE LA SUBRUTINA CERRADA.……

FIN DEL CODIGO DE LA SUBRUTINA CERRADA.




son teorías pasadas, no es así, puesto que los mismos conceptos son aplicables a losprocedimientos y funciones, los cuales veremos a continuación.13

6.6.2.- Procedimientos.

Un Procedimiento, es similar a una subrutina, puesto que también es un

grupo de instrucciones que efectúa una parte identificable del programa general,y normalmente se crean para evitar la codificación repetitiva de grupos deinstrucciones a lo largo del programa, así mismo tienen características parecidasen cuanto al paso o transferencia de datos y las llamadas a otros procedimientos.

Pero a diferencia de las subrutinas, el paso o transferencia de datos se daa través de variables llamadas parámetros. El objetivo de estos parámetros es lade aislar de cierta manera los datos manipulados para evitar errores, confusionesy creación de excesivos nombres de variables, así como permitir la re-usabilidaddel código. Generalmente los procedimientos son llamados para su ejecucióncual si fueran instrucciones del lenguaje y, no retornan o devuelven ningún valor al programa principal o procedimiento que los llama.

6.6.3.- Funciones.

Una Función en un lenguaje de programación realiza una serie deoperaciones automáticamente, al llamarla por su nombre específico. Algunosejemplos de funciones son las funciones trigonométricas, tales como el Seno,Coseno, Tangente, o las funciones matemáticas como el logaritmo natural de unnúmero; entre otras. Una de las características más importantes de las funciones, es que podemos pasarle o transferirle datos, los cuales procesan ynos devuelven uno o más resultados. Los datos que se transfieren son conocidoscomo parámetros, y en algunos casos van encerrados entre paréntesis.

Principalmente se usan cuando se quiere devolver por lo menos un valora la función, programa o procedimiento llamador. En algunos lenguajes,generalmente en una Función, el nombre actual de la Función, es el identificadorde la variable que transmite el valor de vuelta.

En cualquier lenguaje de programación se cuenta con al menos lossiguientes tipos de funciones: Alfanuméricas, de fecha, y matemáticas.

Algunos lenguajes permiten al usuario crear sus propias funciones, a lascuales se les nombra comúnmente como Funciones de Usuario.

Generalmente las funciones pueden ser llamadas desde cualquier puntode un programa e inclusive pueden ser pasadas como parámetros a unainstrucción o función del lenguaje.

13 Antes debo comentar que las subrutinas son utilizadas en algunos lenguajes tales como el BASIC, los cuales no estánplenamente orientados a la programación estructurada, tal como PASCAL por ejemplo.




6.6.3.1.- Funciones Implícitas.

Una función implícita es aquella que ya se encuentra incluida dentro de laestructura del lenguaje de programación, y tiene su nombre definido, por lo tanto,solo es necesario “llamarlas” para que se ejecuten cuando las necesitemos.

6.6.3.2.- Funciones de Usuario.

Una Función de usuario, es similar a una subrutina, puesto que tambiénes un grupo de instrucciones que efectúa una parte identificable del programageneral, y normalmente se crean para evitar la codificación repetitiva de gruposde instrucciones a lo largo del programa, así mismo tienen característicasparecidas en cuanto al paso o transferencia de datos y las llamadas a otrosprocedimientos o funciones.

Pero a diferencia de las subrutinas y al igual que en los procedimientos, elpaso o transferencia de datos se da a través de parámetros.

6.6.4.- Parámetros en procedimientos y funciones.

Los parámetros pueden ser pasados a los procedimientos o funciones porreferencia (por variable) o por valor.

Las variables dadas al procedimiento o función al llamarlo se llaman parámetros actuales. El procedimiento o función se escribe usando nombres devariables, llamadas parámetros formales, listadas en sus cabeceras.

6.6.4.1.- Parámetros por valor.

El paso de un parámetro por valor a un procedimiento o función,

sucede cuando solo se pasa el valor de una variable origen a otra variabledestino, y ésta última puede ser modificada en su contenido, lo cual noafectará al contenido de la variable origen. En otras palabras, le pasamosuna copia del valor, y por tanto, si el procedimiento o función modifica elvalor de la copia, el valor original no se modificará.

A continuación se presenta un diagrama describiendo lo anterior:




Inicio del Código del Programa Principal.………VariableOrigen = 5LlamadaAlProcedimientoA(VariableOrigen)Desplegar Variable Origen…

……Fin del Código del Programa Principal.

LlamadaAlProcedimiento(ParámetroPorValor)

Inicio del Código de un Procedimiento o Función.…

…ParametroPorValor = ParametroPorValor+2……Fin del Código de LlamadaAlProcedimientoRetorno (RETURN) al Programa Principal.

5

VariableOrigenEste cuadro representa el área dememoria donde se almacena evalor de VariableOrigen.

5

ParámetroPorValor

Este cuadro representa el área memoria donde se almacena valor de ParámetroPorValor. cual es una copia del original.

Parámetro Actual

Parámetro FormalCabecera delProcedimiento o Función

7

ParámetroPorValor

Como puedes observar,

modificación del valor se realiza en área de memoria donde se almaceno copia del valor, y no en el área memoria donde tenemos el valoriginal. Esto es útil cuando nqueremos que se modifique el valoriginal o inicial.




6.6.4.2.- Parámetros por referencia (por variable).

El paso de un parámetro por referencia (variable) a unprocedimiento o función, sucede cuando se pasa el valor de una variableorigen a otra variable destino, y ésta última cuando se modifica en sucontenido altera el contenido de la variable origen. En otras palabras, le

pasamos el original del valor, y por tanto, si el procedimiento o funciónmodifica el parámetro o variable destino, el valor original se modificará.También se podría decir que a la misma dirección de memoria en la quese almacena el valor original, se le asigna un segundo nombre devariable, por tanto, al hacer referencia al primer nombre o al segundo,indistintamente se estará usando la misma dirección de memoria.

A continuación se presenta un diagrama describiendo lo anterior:

Inicio del Código del Programa Principal.………VariableOrigen = 5LlamadaAlProcedimientoA(VariableOrigen)Desplegar Variable Origen………Fin del Código del Programa Principal.

LlamadaAlProcedimiento(ParámetroPorVariable)

Inicio del Código de un Procedimiento o Función.……ParametroPorVariable = ParametroPorVariable+2……Fin del Código de LlamadaAlProcedimientoRetorno (RETURN) al Programa Principal.

5

VariableOrigen

Este cuadro representa el área dememoria donde se almacena evalor de la VariableOrigen.

ParámetroPorVariable

Este cuadro representa el área dememoria donde se almacena elvalor del ParámetroPorValor. Elcual es una copia del original.

Parámetro Actual

Parámetro FormalCabecera del

Procedimiento o Función

7

ParámetroPorVariable

Como puedes observar, los dos nombres devariables hacen referencia a la misma posición dememoria, por lo tanto, al modificar el valor deParámetroPorVariable, también se modificara el

valor de VariableOrigen, puesto que ambosnombres de variables apuntan a la misma posiciónde memoria.

VariableOrigen




Como últimas notas con relación a los parámetros, debo comentar que es posible usarlos mismos nombres de variables en los parámetros actuales y los formales, ya que estopor lo general, no creara confusión al interprete del lenguaje, sin embargo, en la vida reales poco práctico pues podría crearnos confusiones a nosotros; y además, creo queresultaría útil usar las siguientes reglas para determinar si un parámetro debe ser porvalor o por referencia (por variable).

1. Si el procedimiento o función lee valores o calcula valores que el procedimiento,función o programa que le llama necesita usar, estos parámetros deben serparámetros por referencia (por variable).

2. Si el procedimiento o función lee valores o calcula valores que el procedimiento,función o programa que le llama necesita para darlo a otro procedimiento o función,estos parámetros tienen que ser parámetros por referencia (por variable).

3. Los nombres de archivo pasados como parámetros deber ser parámetros porreferencia (por variable).

4. Todos los demás parámetros deben ser por valor. (Salvo aquellas excepcionespropias de cada lenguaje de programación).

6.6.5.- Variables en procedimientos y funciones.

Puesto que ya conocemos la definición de variable y todas sus características,solo resta decir, que las variables también cuentan con un ámbito de utilización, es decir,estas pueden ser utilizadas por todo el programa (Variables Globales) o solamente porsegmentos (procedimientos o funciones) de dicho programa (Variables Locales).

6.6.5.1.- Variables Globales.

Cualquier variable declarada en el cuerpo del programa principal es

conocida por cualquier procedimiento o función que no declare una variable conel mismo nombre.

6.6.5.2.- Variables Locales.

Estas variables son las que los procedimientos o funcionesnecesitan para sí mismos. Las variables contadoras son ejemplos devariables que se necesitan frecuentemente dentro de un procedimiento ofunción.

6.6.5.3.- Reglas de ámbito.Cualquier variable o constante definida en un bloque se conoce

(llamada global) en cualquier procedimiento que esté dentro de esebloque. Examinemos el programa TRASPONER en términos de bloquesdefinidos y veamos lo que esto significa.




En este ejemplo Primera es una variable conocida o utilizable encualquier procedimiento puesto que está definida en el PROGRAMAPRINCIPAL (Trasponer). La variable local Ch definida en ImprApellido es

global a EncontrarApellido, SaltarNombre e Imprimir puesto que ImprApellido, SaltarNombre e Imprimir están definidas dentro delprocedimiento ImprApellido. Las reglas que gobiernan dónde se conocen esosidentificadores se llaman reglas de ámbito. El ámbito de la variable Ch definidaen ImprApellido incluye a ImprApellido, SaltarNombre e Imprimir.

¿Por qué entonces usamos la lista de parámetros? Porque una buenapráctica en programación es que la comunicación entre los módulos de nuestrosprogramas debe establecerse explícitamente. Esto limita la posibilidad de que unmódulo interfiera accidentalmente con otro. En otras palabras, a cadaprocedimiento o función se le da sólo lo que necesita saber. Los “buenos”programas se escriben usando este principio. Hay algunos casos en los que escorrecto referenciar globalmente a variables. En ejemplos posteriores veremosalgunos de esos casos en los que es aceptable referenciar a variables globales.

Si se declara el mismo nombre de variable (identificador) en unprocedimiento o función y en el programa principal, no hay confusión. Ladeclaración de una variable local en un procedimiento o función hace que sedesconozca a la variable global del mismo nombre. Llamamos a esto“precedencia de nombre”.

PROGRAMA Trasponer

VARIABLE Primera

PROCEDIMIENTO SaltarBlancos

PROCEDIMIENTO ObtenerPrimera

PROCEDIMIENTO ImprApellido

VARIABLE Ch

VARIABLE Ch

PROCEDIMIENTO EncontrarUltimo

PROCEDIMIENTO Imprimir

PROCEDIMIENTO SaltarNombre

DIAGRAMA DE ÁMBITOS




6.6.5.4.- Efectos laterales.

Puesto que las listas de parámetros de los procedimientos o funcionespueden ser muy complicadas según la elección de parámetros por valor y porreferencias (por variables), se puede tener la tentación de referenciardirectamente variables globales sin pasarlas a través de las listas de parámetros.

¡No hacerlo! Es un mal hábito. Puede conducir a cometer errores que sonextremadamente difíciles de localizar. Si la comunicación entre módulos deprogramas se reduce a las listas de parámetros y todas las variables que no seande salida son parámetros por valor , cada módulo queda aislado de lo que sucedaen otras partes del programa. En otras palabras, el código en un procedimiento nodebe tener efectos laterales a otras partes del programa, excepto a través de unainterfase bien definida en la lista de parámetros.

Otra forma de decir esto es que los procedimientos sólo deben usar lasvariables definidas en su lista de parámetros formales o en su propia sección dedeclaración de variables. Crear módulos independientes con una clara interfasede comunicación.

Se deben evitar los efectos laterales porque normalmente es difícil seguirel flujo de ejecución.

Por otra parte, las funciones se utilizan cuando se va a devolver un valorsimple. Sin embargo, si una función tiene parámetros por referencia (variable) en la lista de parámetros formales, los correspondientes parámetros actuales pueden indudablemente ser cambiados. El enviar o cambiar más de un valor enuna llamada a función se llama un efecto lateral de la función y debe evitarse.

Una buena regla es: No poner nunca parámetros por referencia (variable)en la lista de parámetros formales de una función. Si debe tenerlos, entoncesdebería usar un procedimiento y no una función. De hecho puede usar tantosparámetros por valor como necesite.

Otro ejemplo de un efecto lateral es cuando un procedimiento o función

Programa principalY

Otros procedimientos

Lista de parámetros

Un procedimientotípico

Otros módulos

Módulo

Interface decomunicación

Efectos Laterales

EFECTOS LATERALES




referencia directamente a una variable global y no lo hace a través de su lista deparámetros formales. Recordar, la comunicación entre módulos de un programadebe reducirse a las listas de parámetros formales y actuales.

El siguiente ejemplo ilustra los dos tipos de efectos laterales.

PROGRAMA Inesperado(Entrada, Salida)

VARIABLES A, B

FUNCION Lateral (VARIABLES X, Y)

INICIO (* Lateral *)X = X + YA = X + 1Lado = X + A

FIN (* Lateral *)

INICIO (* Principal *)A = 0B = 1Despliega(Lateral(A,B))Despliega(Lateral(A,B))Despliega(Lateral(B,A))Despliega(Lateral(B,A))

FIN (* Principal *)

Es lógico esperar que las primeras dos sentencias de despliegueproduzcan la misma salida y las segundas dos sentencias de despliegueproduzcan la misma salida también. Es decir, se espera que una función devuelvael mismo resultado cuando tiene la misma entrada. Desdichadamente, la funciónLATERAL tiene efectos laterales y no devuelve el mismo valor para dos

llamadas sucesivas idénticas. Hagamos un recorrido del algoritmo y veamos loque sucede.

Sentencia A B X Y LATERAL(Valores iniciales) 0 1 ? ? ?LATERAL(A,B) (cuando se llama) 0 1 0 1 ?X = X + Y 1 1 1 1 ?A = X + 1 2 1 2 1 ?LATERAL = X + A 2 1 2 1 4 Lo que se

imprime

LATERAL(A,B) (cuando se llama) 2 1 2 1 ?X = X + Y 3 1 3 1 ?A = X + 1 4 1 4 1 ?LATERAL = X + A 4 1 4 1 8 Lo que se

imprime





imprime


imprime

Debido a que el primer parámetro es un parámetro por referencia (por variable), cuando se cambia el parámetro formal también se cambia el parámetroactual. Puesto que A se referencia globalmente, la función está cambiandotambién cada vez. Como puede verse por la salida de la función LATERAL

(valores marcados con negritas), no sólo se devuelven valores diferentes para lamisma entrada, sino que ni siquiera se sigue una pauta.

6.6.6.- Recursividad.

En algunos lenguajes de programación, (p. e. Pascal), se permite que una funcióno procedimiento se llame a sí mismo. La habilidad de una función o procedimiento dellamarse a sí mismo se llama recursividad.

La recursividad es una poderosa característica de los lenguajes que lo permiten yse utilizará en los trabajos más avanzados. Para el principiante, significa sólo que nodebe usarse el nombre de una función en una expresión en el cuerpo de esta función. Portanto se debe definir y usar una variable local y asignar al nombre de la función el valorde la variable local antes de salir de la función.

Por si le pica la curiosidad, se incluye un ejemplo recursivo. Lenguajes como elPascal no tienen un operador de exponenciación, por lo que vamos a escribir unafunción para calcular:

Xn

Donde X y n son enteros positivos no nulos. La fórmula es:

Xn

= X * X*X*…*X n veces

Otra forma de escribir esta relación sería:

Xn = X * (X*X*…*X) (n-1) veces

Si conocemos Xn-1, podemos calcular Xn puesto que Xn = X(Xn-1). De la misma




forma podemos reducir Xn-1 a:

Xn = X*(X*(X*…*X))(n-2) veces

Si conocemos lo que vale Xn-2, podemos calcular Xn-1 y entonces calcular Xn

puesto que Xn

es igual a X(X(Xn-2

)). Podemos continuar este proceso hasta que laexpresión más interior sea X1. Conocemos lo que es X1, su valor es X.Expresamos este razonamiento mediante la siguiente función recursiva

POTENCIA, la cual tiene dos parámetros, nX y nN.

FUNCION Potencia(nX, nN : Enteros) : Enteros

INICIO (* Potencia *)SI nN = 1 ENTONCES

Potencia = nXSINO

Potencia = nX * Potencia(nX, nN-1)FIN DEL SI

FIN.

Cada llamada a la función POTENCIA pone los parámetros actuales en lainterfase de comunicación para la versión a la que se está llamando. El valor para X seráel mismo para cada versión de POTENCIA, pero el valor de N se disminuirá en 1 porcada llamada hasta que N-1 sea igual a 1. La llamada a la función PTENCIA cuando Nes 1 para la cadena de llamadas, porque ahora POTENCIA puede dar un valor. APOTENCIA se le asigna un valor (X para ser exactos) el cual se pasa a la versión de lafunción POTENCIA que hizo la última llamada. El valor de POTENCIA para esa

versión puede ahora calcularse y pasarse a la versión que la llamó a ella. Esto continúahasta que el valor de POTENCIA puede pasarse a la llamada original.

Veamos lo que hace una llamada a POTENCIA con X = 2 y N = 3. La sentencia:

nNum = POTENCIA(2,3)

En el cuerpo del programa asigna el valor devuelto por la llamada a la variablenNum. El valor devuelto por POTENCIA y asignado a nNum debe ser 8 (2 3 es 2 x 2 x2).

Para ilustrar el proceso supongamos que cada llamada a POTENCIA crea unaversión completa de POTENCIA. Cada caja en el siguiente diagrama representa elalgoritmo para POTENCIA listado anteriormente, junto con los valores de losparámetros actuales para esa versión. Use el diagrama y el código para ver por sí mismoque la función POTENCIA hace lo que se supone que debe hacer. Cada versiónPOTNECIA va a la interfase de comunicación para obtener los valores que se le dejanen ella. No hay confusión sobre qué nN se está usando porque nN es un parámetroformal.




NNum = Potencia(2,3)

FUNCIONPotencia

FUNCIONPotencia

FUNCIONPotencia

2 3

nNnX

2 2

nNnX

2 1

nNnX

Llamada a POTENCIA(2,2)



El valor devuelto es 2






Aquellos que encuentren este ejemplo no sólo claro como el cristal, sino ademásobvio, sigan adelante y utilicen la recursividad. Es una técnica poderosa. El resto no sedebe sentir intimidado. El comprender la recursividad no es uno de los objetivos de estetema. Deben continuar en informática, más adelante estudiarán sin ninguna duda larecursividad con detenimiento.

6.7. - Encadenamiento de programas.

El encadenamiento de programas consiste en realizar programas que se "llamen" entresí, y se ejecuten. Esto se realiza creando un archivo que contenga el programa principal y losdemás los programas auxiliares o complementarios. No todos los lenguajes de programaciónpermiten esta característica, pero si permiten la inclusión de archivos, es decir, en un archivo sealmacena el programa principal y en otro u otros los procedimientos o subrutinas adicionales(subrutinas externas), los cuales pueden ser llamados desde el archivo que contiene el programaprincipal al compilar el programa principal, y quedar incluidos en el programa objeto.




7. - Técnica de diseño modular.

Esta técnica de programación es recomendable para el desarrollo de sistemas de informacióncomplejos, ya que podemos combinarla con cualquier otra técnica conocida (p. e. La técnica de diseñoelemental), para facilitar el desarrollo de una aplicación.


TECNICA DE DISEÑO MODULAR

Esta técnica se basa en el principio del "divide y vencerás"; es decir, debemos desglosaro dividir un problema en partes o problemas más pequeños (módulos o bloques); y si alguna(s)de esta(s) parte(s), son aun grandes, trataremos de dividirlo aun más.

Es recomendable desarrollar un diagrama en árbol, colocando en la parte superior elproblema principal, y después colocar en niveles inferiores, las divisiones o módulos de esteproblema.

Después que se ha desglosado un problema, empezaremos a resolverlo desarrollando losprogramas de cada módulo, empezando desde los módulos de nivel más bajo y en un ordenconveniente según nuestro criterio.

Para resolver cada módulo, es recomendable aplicar la técnica general o elemental deprogramación; aunque podemos usar alguna otra técnica particular. Pero siempre debemosevitar el tratar de resolver un módulo o problema codificándolo directamente. En general, lasfases o pasos de resolución de problemas aplicando esta técnica son:

1. Determinar el objetivo o problema.

2. Analizar el problema, describiendo de manera general los pasos para

resolverlo, cada uno de los cuales será un módulo de primer nivel.3. Dividir sucesivamente los módulos, hasta que no se puedan dividir más.

4. Desarrollar un diagrama en árbol, en el cual se indicaran los módulos definidospreviamente.

5. Resolver los módulos de los niveles más bajos hacia los mas altos aplicandocualquier técnica de programación, en un orden conveniente.

6. Agrupar los módulos de acuerdo a cada rama del diagrama en árbol,

codificarlos e integrarlos en un solo programa, o bien, a través de"encadenamientos".

7.2. - Estructuras jerárquicas o en árbol.

El “árbol” es una estructura fundamental en informática, muy utilizada en todos suscampos, porque se adapta a la representación natural de informaciones homogéneas organizadasy de una gran comodidad y rapidez de manipulación. Esta estructura se encuentra en todos los




dominios (campos) de la informática, desde la pura algorítmica14 a la compilación15 o inclusolos dominios de la inteligencia artificial (árboles de juegos, árboles de decisiones, de resolución,etc.).

Las estructuras tipo árbol se usan principalmente para representar información con unarelación jerárquica entre sus elementos, como son árboles genealógicos, tablas, etc.

Un “árbol” es un conjunto finito de uno o más nodos tales que:

1. Existe un nodo especial denominado RAIZ del árbol.

2. Los nodos restantes se dividen en un número mayor o igual que cero, conjuntos;cada uno de los cuales es, a su vez, un árbol. Estos árboles se llaman sub-árbolesdel RAIZ (ramas).

14 Métodos de clasificación y búsqueda.15 Árboles sintácticos para representar las expresiones o producciones posibles de un lenguaje.




A continuación se muestra un diagrama ejemplificando lo anterior.

ESTRUCTURA JERÁRQUICA O EN ÁRBOL.

RAIZ

Sub-árbolO

Nodo

Sub-árbolO

Nodo

Sub-árbolO

Nodo

Sub-árbolO

Nodo

Sub-árbolO

Nodo

Sub-árbolO

Nodo

Sub-árbolO

Nodo

Sub-árbolO

Nodo

Sub-árbolO

Nodo

NIVEL 0

NIVEL 1

NIVEL 2

RAIZ

Sub-árbolO

Nodo

Sub-árbolO

Nodo

Sub-árbolO

Nodo

Sub-árbolO

Nodo

Sub-árbolO

Nodo

Sub-árbolO

Nodo

Sub-árbolO

Nodo

Sub-árbolO

Nodo

Sub-árbolO

Nodo

NIVEL 0

NIVEL 1

NIVEL 2

ESPEJO




7.3. - Resolución de problemas aplicando la Técnica de diseño modular.

1. Determinar el objetivo o problema.(Deberá especificarse por el maestro, es el problema en sí).

- Diseñar un programa que solicite los siguientes datos de un empleado: Ficha, nombre,

puesto, antigüedad, sueldo diario, días trabajados; que calcule y muestre el sueldo total netoa pagar, así como las cuotas por pagar por el patrón por sus prestaciones sobre su sueldototal bruto: un 3 % del Seguro Social, 1 % de Apoyo a la Educación, 5 % de Infonavit, 2 %de I.S.P.T. (Impuesto Sobre Productos del Trabajo; y 3 % del SAR (Sistema de Ahorro parael Retiro. Sí el empleado tiene 5 años o más de antigüedad, se le dará un bono del 5 % sobresu sueldo total bruto.

2. Analizar el problema, describiendo de manera general los pasos para resolverlo, cadauno de los cuales será un módulo de primer nivel.

1. Solicitar los datos del empleado.

2. Calcular el salario total a pagar.3. Calcular las cuotas por pagar.4. Calcular el Total Neto a Pagar.5. Mostrar los importes del sueldo total neto a pagar, sus prestaciones.

3. Dividir sucesivamente los módulos, hasta que no se puedan dividir más.

NIVEL 0

MÓDULO PRINCIPAL

Cálculo del sueldo total neto a pagar a un empleado, así como las cuotas por pagar.

NIVEL 1

1. Solicitar Datos del Empleado.2. Calcular Salario Total a Pagar.3. Calcular Cuotas por pagar.4. Calcular el Total Neto a Pagar.5. Mostrar Resultados.

NIVEL 2

1. Solicitar Datos del Empleado.1.1. Etiquetas de Solicitud de Datos.1.2. Captura de Datos.

2. Calcular Salario Total a Pagar.3. Calcular Cuotas por pagar.

3.1. Calcular Cuota del IMSS.3.2. Calcular Cuota de Apoyo a la Educación.




3.3. Calcular Cuota del Infonavit.3.4. Calcular ISPT.3.5. Calcular SAR.3.6. Calcular el Bono por antigüedad.

4. Calcular el Total Neto a Pagar.5. Mostrar Resultados.

4. Desarrollar un diagrama de árbol, en el cual se indicarán los módulos definidos previamente.

Cálculo del sueldo total neto a pagar a unempleado, así como sus cuotas y retenciones.

Solicitar Datosdel Empleado.

Calcular SalarioTotal a Pagar.

Calcular Cuotas yRetenciones.

Calcular elTotal Neto

a Pagar.

Etiquetas deSolicitud de Datos.

Captura de Datos.

Calcular Cuota del IMSS.

Calcular Cuota de Apoyo a la

Educación.

Calcular Cuota del Infonavit.

Calcular ISPT.

Calcular SAR.

Calcular el Bono porantigüedad.

MostrarResultado

NIVEL 0

NIVEL 1

NIVEL 2




5. Resolver los módulos de los niveles más bajos hacia los más altos aplicando cualquier técnica de programación, en un orden conveniente.

NIVEL 2

PROCEDIMIENTO Etiquetas de Solicitud de Datos.

INICIODesplegar "Dame los siguientes datos:"Desplegar "Nombre:"Desplegar "Puesto:"Desplegar "Antigüedad:"Desplegar "Salario Diario:"Desplegar "Días Trabajados:"

RETORNO

PROCEDIMIENTO Captura de Datos.

INICIOIntroducir cNombreIntroducir cPuestoIntroducir nAntigIntroducir nSalDiaIntroducir nDiasTrab

RETORNO

PROCEDIMIENTO Calcular Cuota del IMSS.

INICIOnImss = nSalTotAPag * 0.03

RETORNO

PROCEDIMIENTO Calcular Cuota de Apoyo a la Educación.

INICIOnApEduc = nSalTotAPag * 0.01

RETORNO

PROCEDIMIENTO Calcular Cuota del Infonavit.

INICIOnInfonavit = nSalTotAPag * 0.05

RETORNO




PROCEDIMIENTO Calcular ISPT.

INICIOnIspt = nSalTotAPag * 0.02

RETORNO

PROCEDIMIENTO Calcular SAR.

INICIOnSar = nSalTotAPag * 0.03

RETORNO

PROCEDIMIENTO Calcular el Bono por antigüedad.

INICIOSí nAntig >= 5 entonces

nBono = nSalTotAPag * 0.05

sinonBono = 0fin sí

RETORNO

NIVEL 1

PROCEDIMIENTO Solicitar Datos del Empleado.

INICIOEtiquetas de Solicitud de Datos.

Captura de Datos.RETORNO

PROCEDIMIENTO Calcular Salario Total a Pagar.

INICIOnSalTotAPag = nDiasTrab * nSalDia

RETORNO

PROCEDIMIENTO Calcular Cuotas Por Pagar.

INICIOCalcular Cuota del IMSS.Calcular Cuota de Apoyo a la Educación.Calcular Cuota del Infonavit.Calcular ISPT.Calcular SAR.Calcular el Bono por antigüedad.

RETORNO




PROCEDIMIENTO Calcular Total Neto a Pagar

INICIOnTotNetoAPagar = nSalTotAPag + nBono

RETORNO

PROCEDIMIENTO Mostrar Resultados.

INICIODesplegar “Resultados:”;Desplegar “IMSS:”; nImssDesplegar “ISPT:”; nIsptDesplegar “SAR:”; nSarDesplegar “Ap. Educ.:”; nApEducDesplegar “Infonavit:”; nInfonavitDesplegar “BONO:”; nBonoDesplegar “Sal. Total a Pagar:”; nSalTotAPag

Desplegar “Tot. Neto a Pagar:”; nTotNetoAPagarRETORNAR

NIVEL 0

PROGRAMA Principal. (Cálculo del sueldo total neto a pagar a un empleado, así comolas cuotas por pagar).

INICIOInicializar variables.Solicitar Datos del Empleado.Calcular Salario Total a Pagar.Calcular Cuotas por pagar.Calcular el Total Neto a Pagar.Mostrar Resultados.

FIN

6. Agrupar los módulos de acuerdo a cada rama del diagrama en el árbol, codificarlos eintegrarlos en un solo programa, o bien, a través de “encadenamientos”.




Lenguaje Basic.

10 REM Programa EJEMGBAS.BAS20 REM Método de Diseño Modular.30 '**************************************************************************40 'Programa Principal. NIVEL 0.50 '**************************************************************************60 CLS 'Borra la pantalla.

70 'Inicializar variables.80 CNOMBRE$ = "": CPUESTO$ = "": NANTIG = 0: NSALDIA = 0: NDIASTRAB = 090 NSALTOTAPAG = 0: NIMSS = 0: NAPEDUC = 0: NINFONAVIT = 0: NSAR = 0100 NISPT = 0: NBONO = 0: NTOTNETOAPAGAR = 0110 GOSUB 230 'Llamada a la subrutina: Solicitar Datos del Empleado.120 GOSUB 290 'Llamada a la subrutina: Calcular Salario Total a Pagar.130 GOSUB 340 'Llamada a la subrutina: Calcular Cuotas Por Pagar.140 GOSUB 440 'Llamada a la subrutina: Calcular el Total Neto a Pagar.150 GOSUB 490 'Llamada a la subrutina: Mostrar Resultados.160 END 'FIN DEL PROGRAMA PRINCIPAL.170 '180 '190 '200 '**************************************************************************

210 'Procedimientos de NIVEL 1.220 '**************************************************************************230 'SUBRUTINA: Solicitar Datos del Empleado.240 '250 GOSUB 680 'Llamada a la subrutina: Desplegar Mensajes de Solicitud de Datos.260 GOSUB 790 'Llamada a la subrutina: Captura de Datos.270 RETURN280 '**************************************************************************290 'SUBRUTINA: Calcular Salario Total a Pagar.300 '310 NSALTOTAPAG = NDIASTRAB * NSALDIA320 RETURN330 '**************************************************************************340 'SUBRUTINA: Calcular Cuotas Por Pagar.

350 '360 GOSUB 880 'Llamada a la subrutina: Calcular Cuota del IMSS.370 GOSUB 930 'Llamada a la subrutina: Calcular Cuota de Apoyo a la Educación.380 GOSUB 980 'Llamada a la subrutina: Calcular Cuota del Infonavit.390 GOSUB 1030 'Llamada a la subrutina: Calcular ISPT.400 GOSUB 1080 'Llamada a la subrutina: Calcular SAR.410 GOSUB 1130 'Llamada a la subrutina: Calcular el Bono por Antigüedad.420 RETURN430 '**************************************************************************440 'SUBRUTINA: Calcular Total Neto a Pagar.450 '460 NTOTNETOAPAGAR = NSALTOTAPAG + NBONO470 RETURN480 '**************************************************************************

490 'SUBRUTINA: Mostrar Resultados.500 '510 CLS 'Borra la pantalla.520 LOCATE 3, 10: PRINT "Resultados:"530 LOCATE 4, 10: PRINT "IMSS: "; NIMSS540 LOCATE 5, 10: PRINT "ISPT: "; NISPT550 LOCATE 6, 10: PRINT "SAR: "; NSAR560 LOCATE 7, 10: PRINT "Apoyo a la Educación: "; NAPEDUC570 LOCATE 8, 10: PRINT "INFONAVIT: "; NINFONAVIT580 LOCATE 9, 10: PRINT "Bono: "; NBONO590 LOCATE 10, 10: PRINT "Salario Total a Pagar: "; NSALTOTAPAG




600 LOCATE 11, 10: PRINT "Total Neto a Pagar: "; NTOTNETOAPAGAR610 RETURN620 '630 '640 '650 '**************************************************************************660 'Procedimientos de NIVEL 2.670 '**************************************************************************680 'SUBRUTINA: Desplegar Mensajes de Solicitud de Datos.690 '700 CLS 'Borra la pantalla.710 LOCATE 3, 10: PRINT "Dame los siguientes datos:"720 LOCATE 4, 10: PRINT "Nombre:";730 LOCATE 5, 10: PRINT "Puesto:";740 LOCATE 6, 10: PRINT "Antigüedad:";750 LOCATE 7, 10: PRINT "Salario Diario:";760 LOCATE 8, 10: PRINT "Dias Trabajados:";770 RETURN780 '**************************************************************************790 'SUBRUTINA: Captura de Datos.800 '810 LOCATE 4, 30: INPUT CNOMBRE$820 LOCATE 5, 30: INPUT CPUESTO$

830 LOCATE 6, 30: INPUT NANTIG840 LOCATE 7, 30: INPUT NSALDIA850 LOCATE 8, 30: INPUT NDIASTRAB860 RETURN870 '**************************************************************************880 'SUBRUTINA: Calcular Cuota del IMSS.890 '900 NIMSS = NSALTOTAPAG * .03910 RETURN920 '**************************************************************************930 'SUBRUTINA: Calcular Cuota de Apoyo a la Educación.940 '950 NAPEDUC = NSALTOTAPAG * .01960 RETURN

970 '**************************************************************************980 'SUBRUTINA: Calcular Cuota de Infonavit.990 '1000 NINFONAVIT = NSALTOTAPAG * .051010 RETURN1020 '**************************************************************************1030 'SUBRUTINA: Calcular ISPT.1040 '1050 NISPT = NSALTOTAPAG * .021060 RETURN1070 '**************************************************************************1080 'SUBRUTINA: Calcular SAR.1090 '1100 NSAR = NSALTOTAPAG * .031110 RETURN1120 '**************************************************************************1130 'SUBRUTINA: Calcular el Bono por Antigüedad.1140 '1150 IF NANTIG >= 5 THEN NBONO = NSALTOTAPAG * .05 ELSE NBONO = 01160 RETURN1170 '**************************************************************************1180 'FIN DEL CODIGO DEL PROGRAMA.

Lenguaje Quick Basic.

REM Programa EJEMQBAS.BAS




REM Método de Diseño Modular.

'Declaración de PROCEDIMIENTOS (Módulos).

'Módulos de NIVEL 2.

DECLARE SUB DesplegarMensajesDeSolicitudDeDatos ()DECLARE SUB CapturaDeDatos (nAntig, nSalDia, nDiasTrab)DECLARE SUB CalcularCuotaDelIMSS (nImss AS SINGLE, nSalTotAPag AS SINGLE)DECLARE SUB CalcularCuotaDeApoyoALaEducacion (nApEduc AS SINGLE, nSalTotAPag ASSINGLE)DECLARE SUB CalcularCuotaDelInfonavit (nInfonavit AS SINGLE, nSalTotAPag AS SINGLE)DECLARE SUB CalcularISPT (nIspt AS SINGLE, nSalTotAPag AS SINGLE)DECLARE SUB CalcularSAR (nSar AS SINGLE, nSalTotAPag AS SINGLE)DECLARE SUB CalcularElBonoPorAntiguedad (nAntig AS SINGLE, nBono AS SINGLE,nSalTotAPag AS SINGLE)

'Módulos de NIVEL 1.'El módulo INICIALIZAR VARIABLES, por ser muy sencillo se codifica'directamente en el PROGRAMA PRINCIPAL (NIVEL 0).

DECLARE SUB SolicitarDatosDelEmpleado (nAntig, nSalDia, nDiasTrab)DECLARE SUB CalcularSalarioTotalAPagar (nSalTotAPag, nDiasTrab, nSalDia)

DECLARE SUB CalcularCuotasPorPagar (nImss AS SINGLE, nApEduc AS SINGLE, nInfonavitAS SINGLE, nIspt AS SINGLE, nSar AS SINGLE, nAntig AS SINGLE, nBono AS SINGLE,nSalTotAPag AS SINGLE)DECLARE SUB CalcularElTotalNetoAPagar (nTotNetoAPagar AS SINGLE, nSalTotAPag ASSINGLE, nBono AS SINGLE)DECLARE SUB MostrarResultados (nImss AS SINGLE, nIspt AS SINGLE, nSar AS SINGLE,nApEduc AS SINGLE, nInfonavit AS SINGLE, nBono AS SINGLE, nSalTotAPag AS SINGLE,nTotNetoAPagar AS SINGLE)

'PROGRAMA PRINCIPAL. NIVEL 0.

'Inicio del programa.


'Inicializar variables.

cNombre$ = "": cPuesto$ = "": nAntig = 0: nSalDia = 0: nDiasTrab = 0nSalTotAPag = 0: nImss = 0: nApEduc = 0: nInfonavit = 0: nSar = 0: nIspt= 0nBono = 0: nTotNetoAPagar = 0

'Llamadas a los procedimientos

CALL SolicitarDatosDelEmpleado(nAntig, nSalDia, nDiasTrab)CALL CalcularSalarioTotalAPagar(nSalTotAPag, nSalDia, nDiasTrab)CALL CalcularCuotasPorPagar(nImss, nApEduc, nInfonavit, nIspt, nSar,

nAntig, nBono, nSalTotAPag)CALL CalcularElTotalNetoAPagar(nTotNetoAPagar, nSalTotAPag, nBono)CALL MostrarResultados(nImss, nIspt, nSar, nApEduc, nInfonavit, nBono,

nSalTotAPag, nTotNetoAPagar)

END 'Fin del programa.

'Módulo de NIVEL 2.SUB CalcularCuotaDeApoyoALaEducacion (nApEduc AS SINGLE, nSalTotAPag AS SINGLE)

nApEduc = nSalTotAPag * .01




END SUB

'Módulo de NIVEL 2.SUB CalcularCuotaDelIMSS (nImss AS SINGLE, nSalTotAPag AS SINGLE)

nImss = nSalTotAPag * .03

END SUB

'Módulo de NIVEL 2.SUB CalcularCuotaDelInfonavit (nInfonavit AS SINGLE, nSalTotAPag AS SINGLE)

nInfonavit = nSalTotAPag * .05

END SUB

'Módulo de NIVEL 1.SUB CalcularCuotasPorPagar (nImss AS SINGLE, nApEduc AS SINGLE, nInfonavit ASSINGLE, nIspt AS SINGLE, nSar AS SINGLE, nAntig AS SINGLE, nBono AS SINGLE,nSalTotAPag AS SINGLE)

CALL CalcularCuotaDelIMSS(nImss, nSalTotAPag)CALL CalcularCuotaDeApoyoALaEducacion(nApEduc, nSalTotAPag)

CALL CalcularCuotaDelInfonavit(nInfonavit, nSalTotAPag)CALL CalcularISPT(nIspt, nSalTotAPag)CALL CalcularSAR(nSar, nSalTotAPag)CALL CalcularElBonoPorAntiguedad(nAntig, nBono, nSalTotAPag)

END SUB

'Módulo de NIVEL 2.SUB CalcularElBonoPorAntiguedad (nAntig AS SINGLE, nBono AS SINGLE, nSalTotAPag ASSINGLE)

IF nAntig >= 5 THENnBono = nSalTotAPag * .05

ELSE

nBono = 0END IF

END SUB

'Módulo de NIVEL 1.SUB CalcularElTotalNetoAPagar (nTotNetoAPagar AS SINGLE, nSalTotAPag AS SINGLE,nBono AS SINGLE)

nTotNetoAPagar = nSalTotAPag + nBono

END SUB

'Módulo de NIVEL 2.SUB CalcularISPT (nIspt AS SINGLE, nSalTotAPag AS SINGLE)

nIspt = nSalTotAPag * .02

END SUB

'Módulo de NIVEL 1.SUB CalcularSalarioTotalAPagar (nSalTotAPag AS SINGLE, nDiasTrab AS SINGLE, nSalDiaAS SINGLE)

nSalTotAPag = nDiasTrab * nSalDia




END SUB

'Módulo de NIVEL 2.SUB CalcularSAR (nSar AS SINGLE, nSalTotAPag AS SINGLE)

nSar = nSalTotAPag * .03

END SUB

'Módulo de NIVEL 2.SUB CapturaDeDatos (nAntig AS SINGLE, nSalDia AS SINGLE, nDiasTrab AS SINGLE)

LOCATE 4, 30: INPUT cNombre$LOCATE 5, 30: INPUT cPuesto$LOCATE 6, 30: INPUT nAntigLOCATE 7, 30: INPUT nSalDiaLOCATE 8, 30: INPUT nDiasTrab

END SUB

'Módulo de NIVEL 2.SUB DesplegarMensajesDeSolicitudDeDatos

CLS 'Borra la pantalla.LOCATE 3, 10: PRINT "Dame los siguientes datos:"LOCATE 4, 10: PRINT "Nombre:";LOCATE 5, 10: PRINT "Puesto:";LOCATE 6, 10: PRINT "Antigüedad:";LOCATE 7, 10: PRINT "Salario Diario:";LOCATE 8, 10: PRINT "Días Trabajados:";

END SUB

'Módulo de NIVEL 1.SUB MostrarResultados (nImss AS SINGLE, nIspt AS SINGLE, nSar AS SINGLE, nApEduc ASSINGLE, nInfonavit AS SINGLE, nBono AS SINGLE, nSalTotAPag AS SINGLE,

nTotNetoAPagar AS SINGLE)

CLS 'Borra la pantalla.LOCATE 3, 10: PRINT "Resultados:"LOCATE 4, 10: PRINT "IMSS: "; nImssLOCATE 5, 10: PRINT "ISPT: "; nIsptLOCATE 6, 10: PRINT "SAR: "; nSarLOCATE 7, 10: PRINT "Apoyo a la Educación: "; nApEducLOCATE 8, 10: PRINT "INFONAVIT: "; nInfonavitLOCATE 9, 10: PRINT "Bono: "; nBonoLOCATE 10, 10: PRINT "Salario Total a Pagar: "; nSalTotAPagLOCATE 11, 10: PRINT "Total Neto a Pagar: "; nTotNetoAPagar

END SUB

'Módulo de NIVEL 1.SUB SolicitarDatosDelEmpleado (nAntig AS SINGLE, nSalDia AS SINGLE, nDiasTrab ASSINGLE)

CALL DesplegarMensajesDeSolicitudDeDatosCALL CapturaDeDatos(nAntig, nSalDia, nDiasTrab)

END SUB




‘ Fin del código del programa.




Lenguaje Pascal.

PROGRAM Ejemplo;

(* Programa EJEMPASC.PAS *)(* Método de Diseño Modular. *)


USES CRT;


VAR nAntig,nSalDia,nDiasTrab,nSalTotAPag,nImss,nApEduc,nInfonavit,nSar,nIspt,

nBono,nTotNetoAPagar : REAL;

(* Módulo de NIVEL 2 *)

PROCEDURE DesplegarMensajesDeSolicitudDeDatos;

BEGIN


GOTOXY(10,3); WRITELN('Dame los siguientes datos:');GOTOXY(10,4); WRITE('Nombre: ');GOTOXY(10,5); WRITE('Puesto: ');GOTOXY(10,6); WRITE('Antigüedad: ');GOTOXY(10,7); WRITE('Salario Diario: ');GOTOXY(10,8); WRITE('Días Trabajados: ');

END;


PROCEDURE CapturaDeDatos(VAR nAntig, nSalDia, nDiasTrab: REAL);

VAR cNombre : STRING[10];cPuesto : STRING[10];

BEGIN

GOTOXY(30,4); READLN(cNombre);GOTOXY(30,5); READLN(cPuesto);GOTOXY(30,6); READLN(nAntig);GOTOXY(30,7); READLN(nSalDia);GOTOXY(30,8); READLN(nDiasTrab);

END;





PROCEDURE CalcularCuotaDelIMSS(VAR nImss: REAL; nSalTotAPag: REAL);

BEGIN

nImss := nSalTotAPag * 0.03;

END;


PROCEDURE CalcularCuotaDeApoyoALaEducacion(VAR nApEduc: REAL; nSalTotAPag: REAL);

BEGIN

nApEduc := nSalTotAPag * 0.01;

END;


PROCEDURE CalcularCuotaDelInfonavit(VAR nInfonavit: REAL; nSalTotAPag: REAL);

BEGIN

nInfonavit := nSalTotAPag * 0.05;

END;


PROCEDURE CalcularISPT(VAR nIspt: REAL; nSalTotAPag: REAL);

BEGIN

nIspt := nSalTotAPag * 0.02;

END;


PROCEDURE CalcularSAR(VAR nSar: REAL; nSalTotAPag: REAL);

BEGIN

nSar := nSalTotAPag * 0.03;

END;


PROCEDURE CalcularElBonoPorAntiguedad(VAR nBono: REAL; nAntig, nSalTotAPag: REAL);

BEGIN

IF nAntig >= 5 THENnBono := nSalTotAPag * 0.05

ELSEnBono = 0;

END;(* Módulo de NIVEL 1 *)

PROCEDURE SolicitarDatosDelEmpleado(VAR nAntig, SalDia, DiasTrab: REAL);




BEGIN

DesplegarMensajesDeSolicitudDeDatos;CapturaDeDatos(nAntig, nSalDia, nDiasTrab);

END;


PROCEDURE CalcularSalarioTotalAPagar(VAR nSalTotAPag: REAL; nDiasTrab, nSalDia:REAL);

BEGIN

nSalTotAPag := nDiasTrab * nSalDia;

END;


PROCEDURE CalcularCuotasPorPagar(VAR nImss, nApEduc, nInfonavit, nIspt, nSar,nBono: REAL; nSalTotAPag, nAntig: REAL);

BEGIN

CalcularCuotaDelIMSS(nImss, nSalTotAPag);CalcularCuotaDeApoyoALaEducacion(nApEduc, nSalTotAPag);CalcularCuotaDelInfonavit(nInfonavit, nSalTotAPag);CalcularISPT(nIspt, nSalTotAPag);CalcularSAR(nSar, nSalTotAPag);CalcularElBonoPorAntiguedad(nBono, nAntig, nSalTotAPag);

END;


PROCEDURE CalcularElTotalNetoAPagar(VAR nTotNetoAPagar: REAL; nSalTotAPag, nBono:

REAL);

BEGIN

nTotNetoAPagar := nSalTotAPag + nBono;END;


PROCEDURE MostrarResultados(nImss, nIspt, nSar, nApEduc, nInfonavit, nBono,nSalTotAPag, nTotNetoAPagar: REAL);

BEGIN

CLRSCR;

GOTOXY(10,3);WRITELN('Resultados:');GOTOXY(10,4);WRITELN('IMSS: ', nImss:6:2);GOTOXY(10,5);WRITELN('ISPT: ', nIspt:6:2);GOTOXY(10,6);WRITELN('SAR: ', nSar:6:2);GOTOXY(10,7);WRITELN('Apoyo a la Educación: ', nApEduc:6:2);GOTOXY(10,8);WRITELN('INFONAVIT: ', nInfonavit:6:2);GOTOXY(10,9);WRITELN('Bono: ', nBono:6:2);GOTOXY(10,10);WRITELN('Salario Total a Pagar: ', nSalTotAPag:6:2);GOTOXY(10,11);WRITELN('Total Neto a Pagar: ', nTotNetoAPagar:6:2);

END;




(* INICIA PROGRAMA PRINCIPAL NIVEL 0 *)

BEGIN (* Inicio *)

(* Inicializar Variables *)nAntig := 0;nSalDia := 0;nDiasTrab := 0;nSalTotAPag := 0;nImss := 0;nApEduc := 0;nInfonavit := 0;nSar := 0;nIspt := 0;nBono := 0;nTotNetoAPagar := 0;

SolicitarDatosDelEmpleado(nAntig, nSalDia, nDiasTrab);CalcularSalarioTotalAPagar(nSalTotAPag, nDiasTrab, nSalDia);CalcularCuotasPorPagar(nImss, nApEduc,nInfonavit, nIspt, nSar, nBono,

nSalTotAPag, nAntig);CalcularElTotalNetoAPagar(nTotNetoAPagar, nSalTotAPag, nBono);

MostrarResultados(nImss, nIspt, nSar, nApEduc, nInfonavit, nBono,nSalTotAPag, nTotNetoAPagar);

END. (* FIN DEL PROGRAMA *)




Lenguaje Clipper.

* Programa EJEMCLIP.PRG* Método de Diseño Modular.

* PROGRAMA PRINCIPAL. NIVEL 0.

Ejemplo()

FUNCTION Ejemplo()

/* Declarando variables */LOCAL nAntig, nSalDia, nDiasTrab, nSalTotAPag, nImss, nApEduc,;

nInfonavit, nSar, nIspt, nBono, nTotNetoAPagar

/* Inicializando variables */nAntig := 0nSalDia := 0nDiasTrab := 0nSalTotAPag := 0

nImss := 0nApEduc := 0nInfonavit := 0nSar := 0nIspt := 0nBono := 0nTotNetoAPagar := 0

CLS //Borra la pantalla. SolicitarDatosDelEmpleado(@nAntig, @nSalDia, @nDiasTrab)CalcularSalarioTotalAPagar(@nSalTotAPag, nDiasTrab, nSalDia)CalcularCuotasPorPagar(@nImss, @nApEduc, @nInfonavit, @nIspt, @nSar,;

@nBono, nSalTotAPag, nAntig)CalcularElTotalNetoAPagar(@nTotNetoAPagar, nSalTotAPag, nBono)MostrarResultados(nImss, nIspt, nSar, nApEduc, nInfonavit, nBono,;


RETURN

* Módulos de NIVEL 1.

FUNCTION SolicitarDatosDelEmpleado(nAntig, nSalDia, nDiasTrab)

DesplegarMensajesDeSolicitudDeDatos()CapturaDeDatos(@nAntig, @nSalDia, @nDiasTrab)

RETURN

FUNCTION CalcularSalarioTotalAPagar(nSalTotAPag, nDiasTrab, nSalDia)

nSalTotAPag := nDiasTrab * nSalDia

RETURN

FUNCTION CalcularCuotasPorPagar(nImss, nApEduc, nInfonavit, nIspt, nSar,;nBono, nSalTotAPag, nAntig)

CuotaDelIMSS(@nImss, nSalTotAPag)CuotaDeApoyoALaEducacion(@nApEduc, nSalTotAPag)CuotaDelInfonavit(@nInfonavit, nSalTotAPag)




CuotaISPT(@nIspt, nSalTotAPag)CuotaSAR(@nSar, nSalTotAPag)CuotaBonoPorAntiguedad(@nBono, nAntig, nSalTotAPag)

RETURN

FUNCTION CalcularElTotalNetoAPagar(nTotNetoAPagar, nSalTotAPag, nBono)


RETURN

FUNCTION MostrarResultados(nImss, nIspt, nSar, nApEduc, nInfonavit, nBono,;nSalTotAPag, nTotNetoAPagar)

@ 8,10 SAY "Resultados:"@ 9,10 SAY "IMSS: "@ 9,35 SAY nImss@ 10,10 SAY "ISPT: "@ 10,35 SAY nIspt@ 11,10 SAY "SAR: "@ 11,35 SAY nSar@ 12,10 SAY "Apoyo a la Educación: "

@ 12,35 SAY nApEduc@ 13,10 SAY "INFONAVIT: "@ 13,35 SAY nInfonavit@ 14,10 SAY "Bono: "@ 14,35 SAY nBono@ 15,10 SAY "Salario Total a Pagar: "@ 15,35 SAY nSalTotAPag@ 16,10 SAY "Total Neto a Pagar: "@ 16,35 SAY nTotNetoAPagar

RETURN

* Módulos de NIVEL 2.

FUNCTION DesplegarMensajesDeSolicitudDeDatos;

@ 1,10 SAY "Dame los siguientes datos:"@ 2,10 SAY "Nombre:"@ 3,10 SAY "Puesto:"@ 4,10 SAY "Antigüedad:"@ 5,10 SAY "Salario Diario:"@ 6,10 SAY "Días Trabajados:"

RETURN

FUNCTION CapturaDeDatos(nAntig, nSalDia, nDiasTrab);

LOCAL cNombre := ' ', cPuesto := ' '

@ 2,30 GET cNombre@ 3,30 GET cPuesto@ 4,30 GET nAntig PICT '9999999.99'@ 5,30 GET nSalDia PICT '9999999.99'@ 6,30 GET nDiasTrab PICT '9999999.99'READ

RETURN

FUNCTION CuotaDelIMSS(nImss, nSalTotAPag)




nImss := nSalTotAPag * 0.03

RETURN

FUNCTION CuotaDeApoyoALaEducacion(nApEduc, nSalTotAPag)

nApEduc := nSalTotAPag * 0.01

RETURN

FUNCTION CuotaDelInfonavit(nInfonavit, nSalTotAPag)

nInfonavit := nSalTotAPag * 0.05RETURN

FUNCTION CuotaISPT(nIspt, nSalTotAPag)

nIspt := nSalTotAPag * 0.02

RETURN

FUNCTION CuotaSAR(nSar, nSalTotAPag)

nSar := nSalTotAPag * 0.03

RETURN

FUNCTION CuotaBonoPorAntiguedad(nBono, nAntig, nSalTotAPag)

IF nAntig >= 5nBono := nSalTotAPag * 0.05

ELSEnBono := 0

END IF

RETURN

* Fin del código del programa.




Lenguaje C++.

/* Programa EJEMMC.C *//* Método de Diseño Modular. */

#include <stdio.h>

/* Módulos de NIVEL 2 */

/* Declaración de funciones */

void DesplegarMensajesDeSolicitudDeDatos(void);void CapturaDeDatos(float *, float *, float *);void CuotaDelIMSS(float *, float);void CuotaDeApoyoALaEducacion(float *, float);void CuotaDelInfonavit(float *, float);void CuotaISPT(float *, float);void CuotaSAR(float *, float);void CuotaBonoPorAntiguedad(float *, float, float);

/* Módulos de NIVEL 1 *//* Declaración de funciones */

void SolicitarDatosDelEmpleado(float *, float *, float *);void CalcularSalarioTotalAPagar(float *, float, float);void CalcularCuotasPorPagar(float *, float *, float *, float *, float *,

float *, float, float);void CalcularElTotalNetoAPagar(float *, float, float);void MostrarResultados(float, float, float, float, float, float, float,

float);

/* Programa Principal. NIVEL 0 */void main () /* Inicio del programa principal */

{/* Declaración e inicialización de variables */float nAntig = 0;float nSalDia = 0;float nDiasTrab = 0;float nSalTotAPag = 0;float nImss = 0;float nApEduc = 0;float nInfonavit = 0;float nIspt = 0;float nSar = 0;float nBono = 0;float nTotNetoAPagar = 0;

clrscr(); /* Borra la pantalla */SolicitarDatosDelEmpleado(&nAntig, &nSalDia, &nDiasTrab);CalcularSalarioTotalAPagar(&nSalTotAPag, nDiasTrab, nSalDia);CalcularCuotasPorPagar(&nImss, &nApEduc, &nInfonavit, &nIspt, &nSar,

&nBono, nSalTotAPag, nAntig);CalcularElTotalNetoAPagar(&nTotNetoAPagar, nSalTotAPag, nBono);MostrarResultados(nImss, nIspt, nSar, nApEduc, nInfonavit, nBono,

nSalTotAPag, nTotNetoAPagar);}

/* Módulos de NIVEL 2 */void DesplegarMensajesDeSolicitudDeDatos(void)

{gotoxy(10,1); printf("Dame los siguientes datos:");




gotoxy(10,2); printf("Nombre:");gotoxy(10,3); printf("Puesto:");gotoxy(10,4); printf("Antigüedad:");gotoxy(10,5); printf("Salario Diario:");gotoxy(10,6); printf("Días Trabajados:");

}

void CapturaDeDatos(float *nAnt, float *nSal, float *nDias)

{/* Declaración de variables locales */char cNombre[10];char cPuesto[10];float nA, nS, nD; /* Variables auxiliares para el

paso de parámetros */

gotoxy(30,2); scanf("%s",&cNombre);gotoxy(30,3); scanf("%s",&cPuesto);gotoxy(30,4); scanf("%f",&nA);gotoxy(30,5); scanf("%f",&nS);gotoxy(30,6); scanf("%f",&nD);

/* Asignación de valores a las variables que son parámetro por

referencia o variable */*nAnt = nA;*nSal = nS;*nDias = nD;

}

void CuotaDelIMSS(float *nIm, float nSalTotAPag)

{*nIm = nSalTotAPag * 0.03;

}

void CuotaDeApoyoALaEducacion(float *nApEd, float nSalTotAPag)

{*nApEd = nSalTotAPag * 0.01;

}

void CuotaDelInfonavit(float *nInfo, float nSalTotAPag)

{*nInfo = nSalTotAPag * 0.05;

}

void CuotaISPT(float *nIs, float nSalTotAPag)

{*nIs = nSalTotAPag * 0.02;

}

void CuotaSAR(float *nSa, float nSalTotAPag)

{*nSa = nSalTotAPag * 0.03;

}

void CuotaBonoPorAntiguedad(float *nBon, float nAntig, float nSalTotAPag)

{if(nAntig >= 5)




*nBon = nSalTotAPag * 0.05;else

*nBon = 0;}

/* Módulos de Nivel 1 */

void SolicitarDatosDelEmpleado(float *nAntig, float *nSalDia, float *nDiasTrab)

{/* Declaración de variables auxiliares para el paso de parámetros */float nAnt,nSal,nDias;

DesplegarMensajesDeSolicitudDeDatos();CapturaDeDatos(&nAnt, &nSal, &nDias);

/* Asignación de valores a las variables que son par metro porreferencia o variable */

*nAntig = nAnt;*nSalDia = nSal;*nDiasTrab = nDias;

}

void CalcularSalarioTotalAPagar(float *nSalTotAPag, float nDiasTrab, float nSalDia)

{*nSalTotAPag = nDiasTrab * nSalDia;

}

void CalcularCuotasPorPagar(float *nImss, float *nApEduc, float *nInfonavit,float *nIspt, float *nSar, float *nBono,float nSalTotAPag, float nAntig)

{/* Declaración de variables auxiliares para el paso de parámetros */float nIm, nApEd, nInfo, nIs, nSa, nBon;

CuotaDelIMSS(&nIm, nSalTotAPag);CuotaDeApoyoALaEducacion(&nApEd, nSalTotAPag);CuotaDelInfonavit(&nInfo, nSalTotAPag);CuotaISPT(&nIs, nSalTotAPag);CuotaSAR(&nSa, nSalTotAPag);CuotaBonoPorAntiguedad(&nBon, nAntig, nSalTotAPag);


*nImss = nIm;*nApEduc = nApEd;*nInfonavit = nInfo;*nIspt = nIs;*nSar = nSa;*nBono = nBon;

}

void CalcularElTotalNetoAPagar(float *nTotNetoAPagar, float nSalTotAPag,float nBono)

{*nTotNetoAPagar = nSalTotAPag + nBono;

}

void MostrarResultados(float nImss, float nIspt, float nSar, float nApEduc,




float nInfonavit, float nBono, float nSalTotAPag,float nTotNetoAPagar)

{gotoxy(10,10); printf("Salario Total a Pagar: %f",nSalTotAPag);gotoxy(10,11); printf("Cuota IMSS: %f",nImss);gotoxy(10,12); printf("Cuota de Apoyo a la Educación: %f",nApEduc);gotoxy(10,13); printf("Cuota del Infonavit: %f",nInfonavit);gotoxy(10,14); printf("Cuota del SAR: %f",nSar);gotoxy(10,15); printf("Bono por antigüedad: %f",nBono);gotoxy(10,16); printf("Total Neto a Pagar: %f",nTotNetoAPagar);

}

/* Fin del código del programa*/




8. - Técnica de diseño descendente.

Esta técnica, como la anterior, es recomendable para el desarrollo de aplicaciones complejas yde gran tamaño; una de sus características principales es que evita la repetición de bloques deinstrucciones, economizando con esto tiempo de programación y captura de la codificación.


TECNICA DE DISEÑO DESCENDENTE

Esta técnica, también conocida como "top-down", nos permite usar una aproximacióndel " divide y vencerás " (no debe confundirse con Diseño Modular, que es similar). En otraspalabras, un problema se divide en sub-problemas que sean manejables. Después de resolvertodos los sub-problemas tendremos una solución del problema global.

Lo que hacemos en el diseño descendente es ir de lo abstracto (nuestra descripción oespecificación del problema) a lo particular (nuestro código en lenguaje de programación).

Si la descripción del problema es una descripción en palabras vagamente establecida,entonces el primer paso es crear una descripción funcional del problema. Es decir, unadescripción que establezca claramente lo que el programa ha de hacer. En muchos casos, estosignifica un dialogo entre la persona que tiene el problema y el programador.

Para resolver los problemas, comenzaremos subdividiendo el problema en un conjuntode sub-problemas. Luego, cada sub-problema se divide a su vez en sub-problemas. Este procesocontinúa hasta que no se puede dividir más cada sub-problema. Estamos creando una estructura jerárquica, también conocida como estructura en árbol, de problemas y sub-problemas llamadosmódulos funcionales. Los módulos de un nivel pueden llamar a los módulos del nivel inferior.Estos módulos son los bloques básicos nuestros programas.

Dividiendo nuestro problema en sub-problemas, o segmentos, podemos resolver cadauno independientemente de los otros.Nuestro árbol de diseño contiene sucesivos niveles de refinamiento (ver figura). En la

cabeza, o nivel 0, esta nuestra descripción funcional del problema, los niveles inferiores sonnuestros sucesivos refinamientos.

Concretamente; las fases o pasos para la resolución de problemas de esta técnica son:

¾Analizar el problema.¾Escribir el módulo principal.¾Escribir los módulos restantes.¾Re-ordenar y revisar lo que sea necesario.

A continuación se describen detalladamente los pasos anteriores:

1. Analizar el problema.

- Comprender el problema. Comprender lo que se da (ENTRADA) y lo que sepide (SALIDA). Especificar los formatos de ENTRADA / SALIDA.

- Pensar. ¿ Cómo se resolvería el problema a mano ? Establecer las estructuras de




datos necesarias (sí las hay).- Desarrollar un algoritmo global o plan general de ataque.- Listar las suposiciones (sí las hay).

2. Escribir el módulo principal.

- Utilizar el castellano o pseudo código para establecer el problema en el móduloprincipal. Usar nombres de módulos para dividir el problema en áreasfuncionales. Si éste módulo es demasiado largo (mas de 10 o 15 sentencias), estaen un nivel demasiado bajo de detalle. Introducir en este punto cualquierestructura de control que se necesite (tal como iteración o selección). Revisar lalógica, sí se necesita. Posponer los detalles a niveles inferiores. El móduloprincipal puede cambiar en futuros refinamientos.

- No preocuparse si no se sabe como resolver un módulo que no este escrito eneste momento. Suponga que tiene un "amigo inteligente" que conoce la respuestay pospóngala hasta que se hagan mas refinamientos. Todo lo que tiene que haceren el módulo principal es dar los nombres de los módulos del nivel inferior que

suministren ciertas funciones.- Utilizar nombres con significado para los módulos.

3. Escribir los módulos restantes.

- No hay un número fijo de niveles. Los módulos de un nivel pueden especificarmas módulos del nivel inferior.

- Cada módulo debe estar completo, aunque los módulos que él refiere estén sinescribir.

- Hacer sucesivos refinamientos en cada módulo hasta que cada sentencia puedatraducirse directamente en una sentencia en lenguaje de programación.

4. Re-ordenar y revisar lo que sea necesario.

- Planificar un cambio.- No preocuparse por comenzar de nuevo. Pueden ser necesarios varios intentos y

refinamientos.- Volver atrás en las decisiones de diseño inapropiadas.- Tratar de mantener la claridad.- Expresarse simple y directamente.

PERFIL DEL DISEÑO DESCENDENTE

- DESCRIPCION DE LA ENTRADA.- DESCRIPCION DE LA SALIDA.- ESTRUCTURAS DE DATOS.- SUPOSICIONES (SÍ LAS HAY)- MÓDULO PRINCIPAL.- MÓDULOS RESTANTES POR NIVELES.




El producto final del diseño es el programa. El programa debe reflejar la estructura deldiseño descendente realizado. El módulo principal debe ser el programa principal.

8.2. - Resolución de problemas aplicando la Técnica de diseño descendente.

- Diseñar un programa que solicite los siguientes datos de un empleado: Ficha, nombre,

puesto, antigüedad, sueldo diario, días trabajados; que calcule y muestre el sueldo total netoa pagar, así como las cuotas por pagar por el patrón por sus prestaciones sobre su sueldototal bruto: un 3 % del Seguro Social, 1 % de Apoyo a la Educación, 5 % de Infonavit, 2 %de I.S.P.T. (Impuesto Sobre Productos del Trabajo; y 3 % del SAR (Sistema de Ahorro parael Retiro. Sí el empleado tiene 5 años o más de antigüedad, se le dará un bono del 5 % sobresu sueldo total bruto.

1. Analizar el problema. El programa deberá pedir los datos del empleado y posteriormente sobre la base de

éstos, deberá calcular las cuotas por pagar por el patrón, así como el bono por antigüedad, encaso de que tenga 5 años o más de antigüedad; todo con base en su sueldo total bruto.

DESCRIPCIÓN DE LA ENTRADA.

Los datos de entrada son:

DATO TIPONombre Alfanumérico (Carácter)Puesto Alfanumérico (Carácter)Antigüedad NuméricoSalario Diario NuméricoDías Trabajados Numérico

DESCRIPCIÓN DE LA SALIDA.

Los datos de salida son:

DATO TIPOCuota del IMSS NuméricoCuota del ISPT NuméricoCuota del SAR NuméricoCuota de Apoyo a la Educación Numérico

Cuota del Infonavit NuméricoBono por antigüedad NuméricoSalario Total a Pagar NuméricoTotal Neto a Pagar Numérico




ESTRUCTURAS DE DATOS.

VARIABLE IDENTIFICADOR(NOMBRE DE VARIABLE)

TIPO

Nombre cNombre Alfanumérico (Carácter)Puesto cPuesto Alfanumérico (Carácter)

Antigüedad nAntig NuméricoSueldo Diario nSalDia NuméricoDías trabajados nDiasTrab NuméricoCuota del IMSS nImss NuméricoCuota del ISPT nIspt NuméricoCuota del SAR nSar NuméricoCuota de Apoyo a la Educación nApEduc NuméricoCuota del Infonavit nInfonavit NuméricoBono por antigüedad nBono NuméricoSalario Total a Pagar nSalTotAPag NuméricoTotal Neto a Pagar nTotNetoAPagar Numérico

SUPOSICIONES (SI LAS HAY).

En este caso supondremos que no habrá ningún error en la captura, y por lo tanto nohabrá días trabajados, antigüedades, y sueldos diarios; negativos. Ni tampoco habrá otrostipos de errores por parte del usuario.

NOTA: En el primer caso es obvio que no debe haber valores negativos, sin embargo,cuando se hace un programa más profesional, se deben considerar todos los valores quepodría tomar una variable, pues nunca sabremos que es lo que puede pensar y/o hacer el

usuario con nuestro programa. Para el segundo caso, en el que supondremos que no habráotro tipo de error por parte del usuario, durante la captura; es para evitar confundirlo yademás, el crearnos una rutina de procesamiento de errores; que en la vida real esconveniente desarrollar para procesar todos aquellos errores que podamos imaginarnos quese podrían generar en nuestros programas, e inclusive aquellos errores impredecibles, paradarles una salida sencilla y elegante a nuestros programas.

2. Escribir el módulo principal.

NIVEL 0Módulo Principal.

Calcular el Salario Total a Pagar, el Total Neto a Pagar y las cuotas por pagar.




3. Escribir los módulos restantes.

NIVEL 1

a. Inicializar variables.

b. Solicitar datos del empleado.c. Calcular el salario total a pagar.d. Calcular las cuotas por pagar.e. Mostrar resultados.

NIVEL 2

a.1. cNombre = “ “a.2. cPuesto = “ “a.3. nAntig = 0a.4. nSalDia = 0

a.5. nDiasTrab = 0a.6. nImss = 0a.7. nIspt = 0a.8. nSar = 0a.9. nApEduc = 0a.10. nInfonavit = 0a.11. nBono = 0a.12. nSalTotAPag = 0a.13. nTotNetoAPagar = 0

b.1. Etiquetas de Solicitud de datos.

b.2. Captura de datos.

c.1. Salario Total a Pagar = Salario Diario * Días Trabajados

d.1. Cuota del Imss = Salario Total a Pagar * 0.03d.2. Cuota de Apoyo a la Educación = Salario Total a Pagar * 0.01d.3. Cuota del Infonavit = Salario Total a Pagar * 0.05d.4. Cuota del ISPT = Salario Total a Pagar * 0.02d.5. Cuota del SAR = Salario Total a Pagar * 0.03d.6. Sí Antigüedad >= 5 entonces Bono por Antigüedad = Salario Total a Pagar * 0.05

e.1. Desplegar “Resultados:”;e.2. Desplegar “IMSS:”; nImsse.3. Desplegar “ISPT:”; nIspte.4. Desplegar “SAR:”; nSare.5. Desplegar “Ap. Educ.:”; nApEduce.6. Desplegar “Infonavit:”; nInfonavite.7. Desplegar “BONO:”; nBonoe.8. Desplegar “Sal. Total a Pagar:”; nSalTotAPag




e.9. Desplegar “Tot. Neto a Pagar:”; nTotNetoAPagar

NIVEL 3

a.1. cNombre = “ “a.2. cPuesto = “ “

a.3. nAntig = 0a.4. nSalDia = 0a.5. nDiasTrab = 0a.6. nImss = 0a.7. nIspt = 0a.8. nSar = 0a.9. nApEduc = 0a.10. nInfonavit = 0a.11. nBono = 0a.12. nSalTotAPag = 0a.13. nTotNetoAPagar = 0

b.1.1. Desplegar "Dame los siguientes datos:"b.1.2. Desplegar "Nombre:"b.1.3. Desplegar "Puesto:"b.1.4. Desplegar "Antigüedad:"b.1.5. Desplegar "Salario Diario:"b.1.6. Desplegar "Días Trabajados:"

b.2.1. Introducir cNombreb.2.2. Introducir cPuestob.2.3. Introducir nAntig

b.2.4. Introducir nSalDiab.2.5. Introducir nDiasTrab

c.1. Salario Total a Pagar = Salario Diario * Días Trabajados

d.1. Cuota del Imss = Salario Total a Pagar * 0.03d.2. Cuota de Apoyo a la Educación = Salario Total a Pagar * 0.01d.3. Cuota del Infonavit = Salario Total a Pagar * 0.05d.4. Cuota del ISPT = Salario Total a Pagar * 0.02d.5. Cuota del SAR = Salario Total a Pagar * 0.03d.6. Sí Antigüedad >= 5 entonces Bono por Antigüedad = Salario Total a Pagar * 0.05 sino

Bono = 0

e.1. Desplegar “Resultados:”;e.2. Desplegar “IMSS:”; nImsse.3. Desplegar “ISPT:”; nIspte.4. Desplegar “SAR:”; nSare.5. Desplegar “Ap. Educ.:”; nApEduce.6. Desplegar “Infonavit:”; nInfonavit




e.7. Desplegar “BONO:”; nBonoe.8. Desplegar “Sal. Total a Pagar:”; nSalTotAPage.9. Desplegar “Tot. Neto a Pagar:”; nTotNetoAPagar

4. Reordenar y revisar lo que sea necesario.

Como se puede observar, ésta técnica es similar a la de diseño modular. Sin embargo,aquí no es necesario crear el diagrama de árbol, y esto resulta ser optativo.También es de notar que al final obtenemos el algoritmo totalmente detallado como en el

caso de la técnica de diseño elemental, pero con la diferencia de que cada segmento estáplenamente identificado, y por lo tanto, si el algoritmo resulta ser demasiado extenso,podemos crear procedimientos, como en el diseño modular, lo cual acortaría el código delprograma principal y lo haría mas legible.

Y por supuesto, ya teniendo el algoritmo en el nivel más bajo, lo único que queda escodificarlo, aunque bien podíamos haberlo hecho desde otros niveles superiores, pero comolo que se pretende es enseñar a programar y no a codificar en algún lenguaje especifico, portal razón se muestra simplemente el algoritmo hasta su mínimo detalle.

Queda para el programador principiante, a su gusto, cuando llegue a niveles muy bajos,el codificar directamente cuando ya domine un lenguaje de programación.

Puesto que el código, para este ejemplo resulta ser muy pequeño, bien podríamosobtener un código como el del diseño elemental, o como el del diseño modular; y ¿por quéno?, una mezcla de ambos como se muestra más adelante; todo dependerá de los gustos yestilos de cada programador.

Lenguaje Basic.

10 REM Programa EJEMDBAS.BAS20 REM Método de Diseño Descendente.30 '**************************************************************************40 'Programa Ejemplo.50 '**************************************************************************60 CLS 'Borra la pantalla.70 '80 'Inicializar variables.90 '100 CNOMBRE$ = "": CPUESTO$ = "": NANTIG = 0: NSALDIA = 0: NDIASTRAB = 0110 NSALTOTAPAG = 0: NIMSS = 0: NAPEDUC = 0: NINFONAVIT = 0: NSAR = 0120 NISPT = 0: NBONO = 0: NTOTNETOAPAGAR = 0130 '140 GOSUB 390 'Llamada a la subrutina: Solicitar Datos del Empleado.150 '160 'Calcular Salario Total a Pagar.170 '

180 NSALTOTAPAG = NDIASTRAB * NSALDIA190 '200 'Calcular Cuotas Por Pagar.210 '220 NIMSS = NSALTOTAPAG * .03230 NAPEDUC = NSALTOTAPAG * .01240 NINFONAVIT = NSALTOTAPAG * .05250 NISPT = NSALTOTAPAG * .02260 NSAR = NSALTOTAPAG * .03270 IF NANTIG >= 5 THEN NBONO = NSALTOTAPAG * .05280 '




290 'Calcular el Total Neto a Pagar.300 '310 NTOTNETOAPAGAR = NSALTOTAPAG + NBONO320 '330 GOSUB 450 'Llamada a la subrutina: Mostrar Resultados.340 '350 END 'FIN DEL PROGRAMA PRINCIPAL.360 '370 '380 '**************************************************************************390 'SUBRUTINA: Solicitar Datos del Empleado.400 '410 GOSUB 600 'Llamada a la subrutina: Desplegar Mensajes de Solicitud de Datos.420 GOSUB 710 'Llamada a la subrutina: Captura de Datos.430 RETURN440 '**************************************************************************450 'SUBRUTINA: Mostrar Resultados.460 '470 CLS 'Borra la pantalla.480 LOCATE 3, 10: PRINT "Resultados:"490 LOCATE 4, 10: PRINT "IMSS: "; NIMSS500 LOCATE 5, 10: PRINT "ISPT: "; NISPT510 LOCATE 6, 10: PRINT "SAR: "; NSAR

520 LOCATE 7, 10: PRINT "Apoyo a la Educación: "; NAPEDUC530 LOCATE 8, 10: PRINT "INFONAVIT: "; NINFONAVIT540 LOCATE 9, 10: PRINT "Bono: "; NBONO550 LOCATE 10, 10: PRINT "Salario Total a Pagar: "; NSALTOTAPAG560 LOCATE 11, 10: PRINT "Total Neto a Pagar: "; NTOTNETOAPAGAR570 RETURN580 '590 '**************************************************************************600 'SUBRUTINA: Desplegar Mensajes de Solicitud de Datos.610 '620 CLS 'Borra la pantalla.630 LOCATE 3, 10: PRINT "Dame los siguientes datos:"640 LOCATE 4, 10: PRINT "Nombre:";650 LOCATE 5, 10: PRINT "Puesto:";

660 LOCATE 6, 10: PRINT "Antigüedad:";670 LOCATE 7, 10: PRINT "Salario Diario:";680 LOCATE 8, 10: PRINT "Dias Trabajados:";690 RETURN700 '**************************************************************************710 'SUBRUTINA: Captura de Datos.720 '730 LOCATE 4, 30: INPUT CNOMBRE$740 LOCATE 5, 30: INPUT CPUESTO$750 LOCATE 6, 30: INPUT NANTIG760 LOCATE 7, 30: INPUT NSALDIA770 LOCATE 8, 30: INPUT NDIASTRAB780 RETURN790 '**************************************************************************800 'FIN DEL CODIGO DEL PROGRAMA.810 '**************************************************************************




Lenguaje Quick Basic.

REM Programa EJEDQBAS.BASREM Método de Diseño Descendente.

'Declaración de PROCEDIMIENTOS.

DECLARE SUB DesplegarMensajesDeSolicitudDeDatos ()

DECLARE SUB CapturaDeDatos (nAntig, nSalDia, nDiasTrab)DECLARE SUB SolicitarDatosDelEmpleado (nAntig, nSalDia, nDiasTrab)DECLARE SUB MostrarResultados (nImss AS SINGLE, nIspt AS SINGLE, nSar AS SINGLE,nApEduc AS SINGLE, nInfonavit AS SINGLE, nBono AS SINGLE, nSalTotAPag AS SINGLE,nTotNetoAPagar AS SINGLE)

'PROGRAMA Ejemplo.

'Inicio del programa.


'Inicializar variables.

cNombre$ = "": cPuesto$ = "": nAntig = 0: nSalDia = 0: nDiasTrab = 0nSalTotAPag = 0: nImss = 0: nApEduc = 0: nInfonavit = 0: nSar = 0: nIspt= 0nBono = 0: nTotNetoAPagar = 0

'Llamadas a los procedimientos

CALL SolicitarDatosDelEmpleado(nAntig, nSalDia, nDiasTrab)

'Calcular Salario Total a Pagar

nSalTotAPag = nDiasTrab * nSalDia

'Calcular Cuotas Por Pagar

nImss = nSalTotAPag * .03nApEduc = nSalTotAPag * .01nInfonavit = nSalTotAPag * .05nIspt = nSalTotAPag * .02nSar = nSalTotAPag * .03IF nAntig >= 5 THEN

nBono = nSalTotAPag * .05ELSE

nBono = 0END IF''Calcular El Total Neto a Pagar'nTotNetoAPagar = nSalTotAPag + nBonoCALL MostrarResultados(nImss, nIspt, nSar, nApEduc, nInfonavit, nBono,


END 'Fin del programa.

SUB CapturaDeDatos (nAntig AS SINGLE, nSalDia AS SINGLE, nDiasTrab AS SINGLE)

LOCATE 4, 30: INPUT cNombre$LOCATE 5, 30: INPUT cPuesto$LOCATE 6, 30: INPUT nAntigLOCATE 7, 30: INPUT nSalDiaLOCATE 8, 30: INPUT nDiasTrab




END SUB

SUB DesplegarMensajesDeSolicitudDeDatos

CLS 'Borra la pantalla.LOCATE 3, 10: PRINT "Dame los siguientes datos:"LOCATE 4, 10: PRINT "Nombre:";LOCATE 5, 10: PRINT "Puesto:";LOCATE 6, 10: PRINT "Antigüedad:";LOCATE 7, 10: PRINT "Salario Diario:";LOCATE 8, 10: PRINT "Días Trabajados:";

END SUB

SUB MostrarResultados (nImss AS SINGLE, nIspt AS SINGLE, nSar AS SINGLE, nApEduc ASSINGLE, nInfonavit AS SINGLE, nBono AS SINGLE, nSalTotAPag AS SINGLE,nTotNetoAPagar AS SINGLE)

CLS 'Borra la pantalla.LOCATE 3, 10: PRINT "Resultados:"LOCATE 4, 10: PRINT "IMSS: "; nImssLOCATE 5, 10: PRINT "ISPT: "; nIspt

LOCATE 6, 10: PRINT "SAR: "; nSarLOCATE 7, 10: PRINT "Apoyo a la Educación: "; nApEducLOCATE 8, 10: PRINT "INFONAVIT: "; nInfonavitLOCATE 9, 10: PRINT "Bono: "; nBonoLOCATE 10, 10: PRINT "Salario Total a Pagar: "; nSalTotAPagLOCATE 11, 10: PRINT "Total Neto a Pagar: "; nTotNetoAPagar

END SUB

SUB SolicitarDatosDelEmpleado (nAntig AS SINGLE, nSalDia AS SINGLE, nDiasTrab ASSINGLE)

CALL DesplegarMensajesDeSolicitudDeDatosCALL CapturaDeDatos(nAntig, nSalDia, nDiasTrab)

END SUB

‘Fin del código del programa.




Lenguaje Pascal.

PROGRAM Ejemplo;

(* Programa EJEDPASC.PAS *)(* Método de Diseño Descendente. *)


USES CRT;


VAR nAntig,nSalDia,nDiasTrab,nSalTotAPag,nImss,nApEduc,nInfonavit,nSar,nIspt,nBono,nTotNetoAPagar : REAL;

PROCEDURE DesplegarMensajesDeSolicitudDeDatos;

BEGIN


GOTOXY(10,3); WRITELN('Dame los siguientes datos:');GOTOXY(10,4); WRITE('Nombre: ');GOTOXY(10,5); WRITE('Puesto: ');GOTOXY(10,6); WRITE('Antigüedad: ');GOTOXY(10,7); WRITE('Salario Diario: ');GOTOXY(10,8); WRITE('Días Trabajados: ');

END;

PROCEDURE CapturaDeDatos(VAR nAntig, nSalDia, nDiasTrab: REAL);

VAR cNombre : STRING[10];cPuesto : STRING[10];

BEGIN

GOTOXY(30,4); READLN(cNombre);GOTOXY(30,5); READLN(cPuesto);GOTOXY(30,6); READLN(nAntig);GOTOXY(30,7); READLN(nSalDia);

GOTOXY(30,8); READLN(nDiasTrab);

END;

PROCEDURE SolicitarDatosDelEmpleado(VAR nAntig, SalDia, DiasTrab: REAL);

BEGIN

DesplegarMensajesDeSolicitudDeDatos;CapturaDeDatos(nAntig, nSalDia, nDiasTrab);




END;

PROCEDURE MostrarResultados(nImss, nIspt, nSar, nApEduc, nInfonavit, nBono,nSalTotAPag, nTotNetoAPagar: REAL);

BEGIN

CLRSCR;GOTOXY(10,3);WRITELN('Resultados:');GOTOXY(10,4);WRITELN('IMSS: ', nImss:6:2);GOTOXY(10,5);WRITELN('ISPT: ', nIspt:6:2);GOTOXY(10,6);WRITELN('SAR: ', nSar:6:2);GOTOXY(10,7);WRITELN('Apoyo a la Educación: ', nApEduc:6:2);GOTOXY(10,8);WRITELN('INFONAVIT: ', nInfonavit:6:2);GOTOXY(10,9);WRITELN('Bono: ', nBono:6:2);GOTOXY(10,10);WRITELN('Salario Total a Pagar: ', nSalTotAPag:6:2);GOTOXY(10,11);WRITELN('Total Neto a Pagar: ', nTotNetoAPagar:6:2);

END;

(* INICIA PROGRAMA PRINCIPAL Ejemplo *)

BEGIN (* Inicio *)

(* Inicializar Variables *)nAntig := 0;nSalDia := 0;nDiasTrab := 0;nSalTotAPag := 0;nImss := 0;nApEduc := 0;nInfonavit := 0;nSar := 0;nIspt := 0;nBono := 0;nTotNetoAPagar := 0;

SolicitarDatosDelEmpleado(nAntig, nSalDia, nDiasTrab);

(* Calcular Salario Total a Pagar *)nSalTotAPag := nDiasTrab * nSalDia;

(* Calcular Cuotas Por Pagar *)nImss := nSalTotAPag * 0.03;nApEduc := nSalTotAPag * 0.01;nInfonavit := nSalTotAPag * 0.05;nIspt := nSalTotAPag * 0.02;nSar := nSalTotAPag * 0.03;IF nAntig >= 5 THEN

nBono := nSalTotAPag * 0.05ELSE

nBono := 0;

(* Calcular El Total Neto a Pagar *)nTotNetoAPagar := nSalTotAPag + nBono;


END. (* FIN DEL PROGRAMA *)

Lenguaje Clipper.




* Programa EJEDCLIP.PRG* Método de Diseño Descendente.

* PROGRAMA PRINCIPAL. NIVEL 0.

Ejemplo()

FUNCTION Ejemplo()

/* Declarando variables */LOCAL nAntig, nSalDia, nDiasTrab, nSalTotAPag, nImss, nApEduc,;

nInfonavit, nSar, nIspt, nBono, nTotNetoAPagar

/* Inicializando variables */nAntig := 0nSalDia := 0nDiasTrab := 0nSalTotAPag := 0nImss := 0nApEduc := 0nInfonavit := 0nSar := 0

nIspt := 0nBono := 0nTotNetoAPagar := 0

CLS //Borra la pantalla. SolicitarDatosDelEmpleado(@nAntig, @nSalDia, @nDiasTrab)

* Calcular Salario Total a Pagar

nSalTotAPag := nDiasTrab * nSalDia

* Calcular Cuotas Por Pagar

nImss := nSalTotAPag * 0.03

nApEduc := nSalTotAPag * 0.01nInfonavit := nSalTotAPag * 0.05nIspt := nSalTotAPag * 0.02nSar := nSalTotAPag * 0.03IF nAntig >= 5

nBono := nSalTotAPag * 0.05ELSE

nBono := 0END IF

* Calcular El Total Neto a Pagar


MostrarResultados(nImss, nIspt, nSar, nApEduc, nInfonavit, nBono,;nSalTotAPag, nTotNetoAPagar)

RETURN

FUNCTION SolicitarDatosDelEmpleado(nAntig, nSalDia, nDiasTrab)

DesplegarMensajesDeSolicitudDeDatos()CapturaDeDatos(@nAntig, @nSalDia, @nDiasTrab)




RETURN

FUNCTION MostrarResultados(nImss, nIspt, nSar, nApEduc, nInfonavit, nBono,;nSalTotAPag, nTotNetoAPagar)

@ 8,10 SAY "Resultados:"@ 9,10 SAY "IMSS: "@ 9,35 SAY nImss@ 10,10 SAY "ISPT: "@ 10,35 SAY nIspt@ 11,10 SAY "SAR: "@ 11,35 SAY nSar@ 12,10 SAY "Apoyo a la Educación: "@ 12,35 SAY nApEduc@ 13,10 SAY "INFONAVIT: "@ 13,35 SAY nInfonavit@ 14,10 SAY "Bono: "@ 14,35 SAY nBono@ 15,10 SAY "Salario Total a Pagar: "@ 15,35 SAY nSalTotAPag@ 16,10 SAY "Total Neto a Pagar: "@ 16,35 SAY nTotNetoAPagar

RETURN

FUNCTION DesplegarMensajesDeSolicitudDeDatos;

@ 1,10 SAY "Dame los siguientes datos:"@ 2,10 SAY "Nombre:"@ 3,10 SAY "Puesto:"@ 4,10 SAY "Antigüedad:"@ 5,10 SAY "Salario Diario:"@ 6,10 SAY "Días Trabajados:"

RETURN

FUNCTION CapturaDeDatos(nAntig, nSalDia, nDiasTrab);

LOCAL cNombre := ' ', cPuesto := ' '

@ 2,30 GET cNombre@ 3,30 GET cPuesto@ 4,30 GET nAntig PICT '9999999.99'@ 5,30 GET nSalDia PICT '9999999.99'@ 6,30 GET nDiasTrab PICT '9999999.99'READ

RETURN

* Fin del código del programa.




Lenguaje C++.

/* Programa EJEMDC.C *//* Método de Diseño Descendente. */

#include <stdio.h>

/* Declaración de funciones */

void DesplegarMensajesDeSolicitudDeDatos(void);void CapturaDeDatos(float *, float *, float *);

void SolicitarDatosDelEmpleado(float *, float *, float *);void MostrarResultados(float, float, float, float, float, float, float, float);

void main () /* Inicio del programa principal Ejemplo */

{/* Declaración e inicialización de variables */float nAntig = 0;float nSalDia = 0;float nDiasTrab = 0;

float nSalTotAPag = 0;float nImss = 0;float nApEduc = 0;float nInfonavit = 0;float nIspt = 0;float nSar = 0;float nBono = 0;float nTotNetoAPagar = 0;

clrscr(); /* Borra la pantalla */ SolicitarDatosDelEmpleado(&nAntig, &nSalDia, &nDiasTrab);

/* Calcular Salario Total a Pagar */

nSalTotAPag = nDiasTrab * nSalDia;

/* Calcular Cuotas Por Pagar */

nImss = nSalTotAPag * 0.03;nApEduc = nSalTotAPag * 0.01;nInfonavit = nSalTotAPag * 0.05;nIspt = nSalTotAPag * 0.02;nSar = nSalTotAPag * 0.03;if(nAntig >= 5)

nBono = nSalTotAPag * 0.05;else

nBono = 0;

/* Calcular El Total Neto a Pagar */

nTotNetoAPagar = nSalTotAPag + nBono;


}

/* Fin del programa principal */




/* Inician las funciones */

void DesplegarMensajesDeSolicitudDeDatos(void)

{gotoxy(10,1); printf("Dame los siguientes datos:");gotoxy(10,2); printf("Nombre:");gotoxy(10,3); printf("Puesto:");gotoxy(10,4); printf("Antigüedad:");gotoxy(10,5); printf("Salario Diario:");gotoxy(10,6); printf("Días Trabajados:");

}

void CapturaDeDatos(float *nAnt, float *nSal, float *nDias)

{/* Declaración de variables locales */char cNombre[10];char cPuesto[10];float nA, nS, nD; /* Variables auxiliares para el

paso de parámetros */

gotoxy(30,2); scanf("%s",&cNombre);

gotoxy(30,3); scanf("%s",&cPuesto);gotoxy(30,4); scanf("%f",&nA);gotoxy(30,5); scanf("%f",&nS);gotoxy(30,6); scanf("%f",&nD);


*nAnt = nA;*nSal = nS;*nDias = nD;

}

void SolicitarDatosDelEmpleado(float *nAntig, float *nSalDia, float *nDiasTrab)

{/* Declaración de variables auxiliares para el paso de parámetros */float nAnt,nSal,nDias;

DesplegarMensajesDeSolicitudDeDatos();CapturaDeDatos(&nAnt, &nSal, &nDias);


*nAntig = nAnt;*nSalDia = nSal;*nDiasTrab = nDias;

}

void MostrarResultados(float nImss, float nIspt, float nSar, float nApEduc,float nInfonavit, float nBono, float nSalTotAPag,float nTotNetoAPagar)

{gotoxy(10,10); printf("Salario Total a Pagar: %f",nSalTotAPag);gotoxy(10,11); printf("Cuota IMSS: %f",nImss);gotoxy(10,12); printf("Cuota de Apoyo a la Educación: %f",nApEduc);gotoxy(10,13); printf("Cuota del Infonavit: %f",nInfonavit);gotoxy(10,14); printf("Cuota del SAR: %f",nSar);gotoxy(10,15); printf("Bono por antigüedad: %f",nBono);gotoxy(10,16); printf("Total Neto a Pagar: %f",nTotNetoAPagar);




}

/* Fin del código del programa*/




9. – Introducción a la programación para gestión de archivos.

9.1. - Conceptos básicos.

En el mundo de la informática existen muchas vertientes para la programación, algunasson los programas para gráficos, programas de paquete o paqueterías (p. e. Hojas de cálculo,

procesadores de texto, manejadores de bases de datos, etc.), programas utilitarios o utilerías(antivirus, mantenimiento de discos, diagnostico de hardware, etc.), programas administrativos(contabilidad, inventarios, nóminas, etc.) e inclusive sistemas operativos y traductores delenguajes de programación.

Y, aunque existen en el mercado un sinnúmero de programas desarrollados por infinidadde empresas de software; siempre es necesario que, para ciertos usuarios se desarrollenprogramas especificos de gestión de información, que manipulen dicha información con laayuda de archivos de datos, equiparables y equivalentes a los archivos físicos documentales,para la agilización de sus procesos administrativos. De ahí que resulta imprescindible para todoprogramador, el conocimiento básico de las operaciones elementales para la gestión deinformación almacenada en archivos. A continuación se verán los conceptos básicos.

9.1.1. - Archivo.

Es un conjunto de información relacionada entre sí.

Normalmente, en informática representamos un archivo como si fuera una tablacompuesta de columnas y filas. También reciben el nombre de ficheros.

Por ejemplo:

Toda la información relacionada con estudiantes de una institución educativa(Nombre, dirección, teléfono, nivel o grado escolar, edad, calificaciones, etc.).

9.1.2. - Campo.

Es un grupo de datos del mismo tipo, pertenecientes a un mismo archivo, y quese relacionan con sus respectivos elementos.

Generalmente representamos los campos de un archivo como las columnas deuna tabla.

Por ejemplo:

Los nombres de cada uno de los estudiantes de una institución educativa.

9.1.3. - Registro.

Son un conjunto de campos relacionados entre sí, los cuales contieneninformación sobre un elemento particular.




Comúnmente se representan los registros de un archivo como filas de una tabla.Por ejemplo:

El registro de inscripción de un alumno, el cual contiene los siguientescampos:Número de control, nombre, grupo, grado o nivel escolar.

Representación de un Archivo de Alumnos.

Campo 1 Campo 2 Campo 3 Campo 4 Campo 5

Número deControl

Nombre Grupo Turno Grado

990701001 Francisco Fernández

Jiménez

990701 Vespertino 1

990602058 Julieta Campos Enríquez

990602 Matutino 2

990503047 Armando Gutiérrez Armas 990503 Matutino 4980402109 Edith Mijangos Lagos 980402 Vespertino 3

9.1.4. - Base de datos.

Una base de datos es un conjunto de información. En sentido amplio, el término

puede aplicarse a cualquier agregado de datos aunque éste no sea tratado de modoinformático. Por tanto, en dicho sentido amplio, son ejemplos de bases de datos nuestraagenda, la guía telefónica, un archivo (o fichero) con recetas de cocina, una biblioteca y,en general, cualquier cosa que podamos designar con el apelativo de conjunto deinformación. No obstante, cuando usamos el término base de datos desde una ópticainformática estamos dándole un significado algo más restrictivo. Desde este nuevo puntode vista podemos definir una base de datos como un sistema de mantenimiento deregistros basado en computadoras, es decir, un sistema cuyo propósito general esregistrar y mantener información16.

Como se ha visto anteriormente, los archivos son el recipiente informático quecontiene la información. Muchas veces se confunde el término base de datos con el

término archivo (o fichero). Realmente son dos cosas distintas. En general, una base dedatos es una colección de archivos, con alguna relación interna entre ellos. Bien escierto que pueden existir bases de datos que estén compuestas de un único archivo, peroesto no es lo más frecuente y, además, en lo que a nuestra definición respecta, esto nomodificaría las cosas.

16 Usamos la definición de C. J. Date, una de las máximas autoridades mundiales en esta materia, en su obra Introducción alos sistemas de bases de datos, publicada en nuestro idioma por Addison-Wesley Iberoamericana, México, 1986.

Registro

Nombredel Campo




9.2. - Tipos de Archivos y accesos.

Aunque en la actualidad se ha optado por el manejo masivo de las bases de datos,(que en conjunto con los sistemas gestores de bases de datos -SGBD- y los lenguajes conla estructura necesaria, nos brindan grandes facilidades y prestaciones); siempre esnecesario conocer los tipos de archivos y sus modos de acceso.

9.2.1. - Archivos secuenciales

Son archivos cuyos registros son almacenados consecutivamente, es decir, unotras otro.

En estos archivos, sus registros solo pueden ser accesados de manera secuencial,es decir, empezando por el primero, y siguiendo de uno en uno hasta el final del archivo.

9.2.2. - Archivos directos.

En este tipo de archivo, la información también se almacena de manera

secuencial, sin embargo, a cada registro se le asigna interna y automáticamente unnúmero al cual llamamos, número de registro; de tal manera que, para accesar lainformación de cualquier registro, simplemente se hace referencia al número de registropara acceder a él.

Por lo tanto, los registros del archivo pueden ser accesados secuencialmente, obien, directamente por su número de registro.

9.2.3. – Archivos indexados.

Los archivos indexados, podríamos decir que son similares a los archivosdirectos, con la diferencia de que, siempre van acompañado de uno o más archivos que

contienen los datos del campo clave de búsqueda, es decir, su índice.Dicho de otra manera, los archivos indexados tienen las mismas características

que los archivos directos, es decir, los registros se almacenan de manera secuencial, y acada uno se le asigna interna y automáticamente un número de registro, peroparalelamente a éstos se pueden crear uno o más índices. Podemos comparar estosíndices con los índices que traen los libros, donde si se observa, por un lado se tiene elnombre del tema en un orden lógico (p. e. alfabético o temático) y por el otro el númerode página donde se encuentra ubicado, y al consultar este índice nos resulta más rápido yfácil localizar el tema que nos interesa. De tal manera, imaginemos los índices como unatabla con dos campos donde se almacenan los datos del campo clave para su búsqueda yel número de registro donde se localiza.

Obviamente, para acceder a los registros de un archivo indexado o mejor dichoindizado (que sería lo correcto pues en español es índice –indizado- y no índex delinglés –indexado-), tenemos tres tipos de acceso que son: secuencia, directo e indizado.




9.2.4. – Otros tipos de archivos.

Así como los archivos anteriormente vistos, existen muchos más tipos dearchivos, que tienen relación al tipo de software que se utilice para crearlos ymodificarlos. Algunos de los más comunes son los archivos de gráficos, los de texto, dehoja de cálculo, de presentaciones, de datos comprimidos, etc.

Desde luego que la manera (o formato) en que se almacena la información en unarchivo depende del software que se este utilizando, aunque sean del mismo tipo, y sepueden identificar por la extensión del mismo.

Ejemplos:De archivos de gráficos las extensiones más comunes son JPG, GIF, PCX y BMP

entre otras. De archivos de texto, lo son; DOC, TXT, WPS.

9.3. – Bases de datos.

En este punto, se tratara con mayor profundidad todo lo relacionado a las Bases de

datos, pues se han difundido tanto debido a su las necesidades de los usuarios y programadores,que se tienen muchas opciones en el mercado para usar o crear un Sistema para la Gestión deBases de Datos (SGBD). Pero…

9.3.1. - ¿ Qué es un SGBD ?

SGBD son las siglas de Sistema para la Gestión de Bases de Datos. Esta fraseproviene de traducir al español Data Base Management System (DBMS). En general,podemos decir que todo aquello a lo que en informática llamamos vulgarmente base dedatos, no es tal sino un SGBD. En sentido estricto el término base de datos hacereferencia sólo al lugar donde está depositada la información (hablando desde la

perspectiva del hardware como del software). En cambio, con SGBD hacemos referenciaa la herramienta informática que usamos para manejar dicha información. Gráficamentepodemos representar un SGBD como vemos en la figura.

BASE DE DATOS

Vista 1

Vista 5

Vista 4

Vista 3

Usuario A

Usuario B

Usuario X

Usuario Y

Usuario Z




Lo que el gráfico nos indica es que el conjunto de información contenida en labase de datos tiene la peculiaridad de hallarse integrado bajo un mismo sistema gestor,pero que, además, dichos datos son accedidos de forma independiente por usuarios yaplicaciones, sólo en la medida en que son necesarios para dichos usuarios y dichasaplicaciones. Es decir, el Usuario A necesita sólo la porción de datos designada como

Vista 1; por tanto la base de datos revestirá ante dicho usuario la peculiaridad de parecerque sólo contiene el trozo de información manejado desde dicha vista. La aplicación Ytrabaja sólo con los datos contenidos en la Vista 4, por tanto, en ningún momentoalcanzará esta aplicación a manejar datos situados fuera de esa vista.

9.3.2. – La independencia de los datos.

Podemos preguntarnos qué ventajas presenta la implantación de un SGBD frentea la más convencional gestión de archivos que podemos realizar desde cualquierlenguaje de programación. La respuesta a esta pregunta es múltiple, ya que múltiples sonlas ventajas que un método de trabajo posee sobre otro:

a) En general un SGBD nos permite tener un control centralizado de toda lainformación que poseemos, independientemente de que cada aplicación gestione unsolo segmento de dicha información.

b) Los archivos gestionados por diversas aplicaciones y no agrupados bajo una filosofíade una base de datos tienden a la redundancia, ya que en la construcción de cadaprograma tendemos a diseñarnos la estructura de datos necesarios para el mismo sintener demasiado en cuenta los requerimientos de otras aplicaciones. De esta forma,cuando queremos darnos cuenta, tenemos un mismo dato repetido en diversosarchivos, claves multiplicadas, etc.

c) La existencia de un SGBD nos permite crear un sistema global y único de seguridad,

tanto para controlar los accesos al sistema, como para garantizar la salvaguarda de lainformación ante posibles deterioros de la misma.

En general, podemos decir que aquello que diferencia a un SGBD de un sistemade archivos controlados de forma autónoma por diversas aplicaciones es que con elprimero debemos garantizar la independencia de los datos. En general, las aplicacionesque construimos son dependientes de la información que manejan. Esto quiere decir quela aplicación debe estar al tanto del sistema de almacenamiento empleado, de las clavesde acceso a la información, etc. Un cambio en la ubicación de ciertos datos o en laestructura de índices no puede llevarse a cabo sin modificar igualmente las aplicacionesque gestionan los datos afectados por dichos cambios.

No obstante, la independencia de los datos es, aún, un objetivo a cubrir por losSGBD más que una realidad, ya que la mayor parte de los sistemas gestores de bases dedatos no han conseguido todavía garantizar en su totalidad esta independencia.




9.3.3. – Lenguajes y Bases de Datos.

Cada SGBD debe poseer la necesaria estructura de lenguajes que permitaefectuar tanto las labores de diseño de la base de datos, como las de actualización,consulta y mantenimiento de la misma.

En general, las labores de desarrollo de aplicaciones que realizan losprogramadores sobre el soporte de un SGBD, son efectuadas en uno o más lenguajesanfitriones (host) de la base de datos. Estos son lenguajes convencionales comoCOBOL, C, PL/1, DBASE, CLIPPER, FOX BASE, VISUAL BASIC, VISUAL FOXPRO, VISUAL C++, etc. No obstante, estas herramientas deben poseer un sub-lenguajede datos adecuado para tratar los objetos propios de la base de datos. De dicho sub-lenguaje se dice que está inmerso en el lenguaje anfitrión. En el sub-lenguaje de datos(DSL –Data Sublanguage-) hemos de distinguir dos partes: El lenguaje para ladefinición de datos (DDL –Data Definition Language-) y el lenguaje para lamanipulación de datos (DML –Data Manipulation Language-).

Lenguajes de un SGBD.

9.3.4. – Los tres enfoques.

Los sistemas gestores de bases de datos se dividen según el tipo de estructura dedatos soportado por cada uno de ellos. En la actualidad los tres enfoques más difundidosson el jerárquico, el de red y el relacional.

9.3.4.1. – Enfoque jerárquico.

Se parte de que la estructura de datos necesaria es un conjunto deregistros diferentes, guardados en un único archivo, y jerarquizados entre sí mediante ligas. Supongamos el siguiente modelo para comprender mejor esteenfoque:

La empresa X posee una base de datos que contiene información de susempleados y de los departamentos a los que están adscritos. De cadadepartamento se guarda su código , al que denominaremos COD y su nombre , alque denominaremos NOMBRE. De cada empleado se guarda su código , al que

Lenguajesen un SGBD

Anfitrión

Sublenguajede datos

Lenguaje para ladefinición de datos

Lenguaje para lamanipulación dedatos




denominaremos COD_EMP, su nombre , al que denominaremos NOM_EMP ysu ciudad , a la que denominaremos CIUDAD.

De este modo, el formato de los dos registros existentes será:

Supongamos ahora que nuestra empresa ficticia posee tres departamentosy ocho empleados. Estos datos se verían en un archivo jerárquico del siguientemodo:

Como vemos hay dos formatos de registro distintos, uno para losdepartamentos y otro para los empleados. El conjunto de registro de losempleados de un departamento se encuentra ligado jerárquicamente al registrocorrespondiente a dicho departamento. No obstante, ambos registros seencuentran contenidos en un mismo archivo.

Este es un ejemplo muy simple de estructura jerárquica. No obstante, elárbol de ligas establecido entre los datos puede crecer mucho más. Supongamosque definimos otra porción de nuestro archivo donde anotamos los pagosmensuales que la empresa X da a sus empleados. El registro que definamos para

Departamento: COD NOMBRE

Empleados: COD_E NOM_EMP CIUDAD

DEP PRODUCCION

01 JUAN BERMUDEZ CADIZ

07

LUISA ALCAZAR CORDOBA

03 JOSE PRIETO LOGROÑO

04 ANTONIO GARCIA MADRID

DEP ADMINISTRACION

05

06

02

LUCIA CASTILLO

ROBERTO GIMBERNAT

MARIA CIFUENTES

MURCIA

BARCELONA

GUADALAJARA

DEP

VENTAS

08 LUIS GARCIA MADRID




contener esta información estaría ligado al registro de empleado definidopreviamente.

Las bases de datos jerárquicas están muy difundidas en el mercado, sobretodo en grandes equipos. No obstante, dada la gran complejidad que presenta sumanejo van siendo sustituidas cada vez más por bases de datos tipo relacional.

Incluso muchos sistemas concebidos desde el enfoque jerárquico son gestionadoshoy de modo semirrelacional.

9.3.4.2. – Enfoque de red (Codasyl).

El enfoque de red es muy similar al jerárquico. Partimos también de lasnociones de registro y enlace. La diferencia radica en que un elemento de inferior jerarquía puede tener varios elementos situados a un nivel superior del mismo.Esto no sucedía así en las bases de datos jerárquicas donde la estructura de árbolimpone que un elemento padre puede tener varios elementos hijo, pero no a lainversa.

En las bases de datos gestionadas bajo el enfoque de red existen lo que sedenominan registros conectores que son estructuras de datos que sirven paraasociar otras dos diferentes estructuras dentro de un archivo. Siguiendo nuestroejemplo anterior, supongamos que el pago de nómina a los empleados se realizaa través de los departamentos. Supongamos también que el registro dondeguardamos el importe de la nómina hace las funciones de uno de estos registrosconectores y que en él registramos solamente el importe del pago que realiza eldepartamento a cada empleado.

La red de los pagos efectuados por DEP1 se vería según el gráfico de la

figura siguiente:

La estructura de registros en una Base de Datos Codasyl.

Al igual que decíamos con el enfoque jerárquico, el ejemplo aquí

DEP1

150 187 362 521

01 02 03 04




propuesto es el más simple posible. Podemos comprender fácilmente la grancantidad de tiempo que los diseñadores de bases de datos, según el enfoque dered, han de perder en construir la estructura de conectores y ligas necesarios parael buen manejo de los datos. Esta gran cantidad de tiempo, junto con la que se hade gastar cuando han de hacerse modificaciones en el diseño de los registros, sonlos principales problemas que presentan este tipo de bases de datos.

9.3.4.3. – Enfoque relacional.

Aunque es posible que todavía el enfoque relacional no sea el másdifundido en el mercado, sí está claro que es el más aceptado a un nivel teórico,siendo también, casi sin duda, el modelo hacia el que caminan los SGBD. Bienes cierto que resulta muy difícil asegurar que un SGBD sea relacional al cientopor ciento, no obstante esto no es un obstáculo para que las bases de datosgestionadas según este enfoque sean las que más fuerte pisan actualmente en elmundo de la informática.

El enfoque relacional se caracteriza porque la presentación de los datos al

usuario se produce en forma de tablas. En dichas tablas las filas o registrossiempre deben tener un formato fijo y una idéntica estructura. El enfoquerelacional en bases de datos parte del modelo relacional en matemáticas y, portanto, son susceptibles de aplicar al mismo todas las formulaciones teóricas queeste último presenta. Veamos a continuación una tabla de equivalencias entre tresconceptos sinónimos y las diferentes maneras con que cada uno de ellos en sudominio nombra las realidades sobre las que trata.

RELACION ARCHIVO TABLA

Tupla Registro FilaAtributo Campo Columna

Cardinalidad No. de Registro No. de FilaGrado No. de Campo No. de Columna

Es muy importante reseñar que en el enfoque relacional no existe ningúnotro componente que no sean tablas, contrariamente a lo que sucedía en las basesde datos de tipo jerárquico o de red donde hemos encontrado otros componentes:ligas y conectores. Un principio científico ampliamente aceptado es que unsistema que puede explicar los mismos hechos con menos componentes es másplausible que otro que lo haga con más. Esto da ya algunas ventajas al enfoquerelacional.

La siguiente figura muestra el aspecto que presentará nuestra base dedatos de ejemplo siguiendo una notación de tipo relacional.




EMPLEADOS

COD_EMP NOM_EMP CIUDAD COD

01 JUAN BERMUDEZ CADIZ DEP102 LUISA ALCAZAR CORDOBA DEP103 JOSE PRIETO LOGROÑO DEP1

04 ANTONIO GARCIA MADRID DEP105 LUCIA CASTILLO MURCIA DEP206 ROBERTO

GIMBERNATBARCELONA DEP2

07 MARIA CIFUENTES GUADALAJARA

DEP2

08 LUIS GARCIA MADRID DEP2

DEPARTAMENTOS

COD NOMBRE

DEP1 PRODUCCIONDEP2 ADMINISTRACIONDEP2 VENTAS

NOMINAS

MES COD_EMP IMPORTE

11 01 1,500.0011 02 1,875.0011 03 3,623.0011 04 5,213.0012 07 8,253.0007 08 10,215.00

Nuestra Base de Datos de ejemplo según el Modelo Relacional.

Como podemos observar, las tres tablas anteriores contienen la mismainformación que hemos manejado en el capítulo anterior para explicar losenfoques jerárquicos y de red. La información contenida en estas tablas estáplenamente normalizada; esto quiere decir que no hay ambigüedad en lasdefiniciones de las columnas y que, además, no existe ningún tipo de registro delongitud variable.

Piénsese lo que sucedería si se intentase guardar el importe de la nóminaen el archivo de empleados. Si reservamos un campo para introducir este dato,sólo podremos guardar un importe, con lo que perderemos la riqueza de lainformación que nos supondría almacenar todos los pagos que se produjeran. Porotro lado, si tratamos de definir el registro de cada empleado con diversoscampos para guardar cada uno de los pagos: IMPORTE1, IMPORTE2,IMPORTE3, etc. Difícilmente podríamos prever de antemano el número de




pagos posibles a realizar a cada empleado, por lo que la definición de laestructura de columnas de nuestra base de datos quedaría incompleta. Otrasolución crearía una gran redundancia de información, ya que en cada registrograbado quedarían duplicados COD_EMP, NOM_EMP, CIUDAD y COD.

Las tres tablas de nuestro ejemplo salvan estos escollos usando archivos

independientes para cada parcela de la información que pueda ser susceptible deun tratamiento individualizado. Si posteriormente quisiéramos obtener datos,producto de cruzar dos o más tablas, bastaría con relacionarlas por el campocomún que poseen: EMPLEADOS puede ser relacionada conDEPARTAMENTOS a través del campo COD; NOMINA puede relacionarsecon EMPLEADOS a través del campo COD_EMP.

Esto lo podemos ver en la siguiente figura:

Relaciones entre archivos de la base de datos de ejemplo.

Supongamos que, llegado un momento, necesitásemos saber los pagosrealizados a los empleados del departamento DEP2. Relacionando NOMINAScon EMPLEADOS a través de COD_EMP podemos ver fácilmente que el únicoempleado de DEP2 que tiene un registro de NOMINAS es el que posee un

COD_EMP=07, siendo el importe del único pago efectuado $8,253.

9.3.5. – Diseño de Bases de Datos.

La labor primera y fundamental con la que nos encontramos ante una base dedatos es la de su diseño. Este parte de la observación de la parcela del mundo real quedeseamos informatizar para abstraer de ella el modelo de datos que necesitamos paraformalizar el sistema de información que deseemos realizar. Para realizar esta labor demodelización se dispone de varias técnicas. Nosotros vamos a explicar brevemente aquí dos de las más usadas. El modelo entidad-relación y el proceso de normalización.

Antes de llevar a efecto la explicación de estas dos técnicas conviene quedefinamos algunos conceptos nuevos:

ENTIDAD Es cada elemento u objeto del mundo real que debe pasar a formarparte del sistema de información que abordamos. Por ejemplo, losclientes, las facturas, etc. El Instituto Americano deNormalización ANSI/SPARC define a la entidad como unapersona, lugar, cosa, concepto o suceso, real o abstracto, de

COD_EMPNOM_EMPCIUDADCOD

EMPLEADOS

CODNOMBRE

DEPARTAMENTOS

MESCOD_EMPIMPORTE

NOMINAS




interés para la empresa. Las entidades suelen correspondersecon los nombres de una oración.

ATRIBUTO Es cada una de las características de que consta una entidad y queson de utilidad para el proceso de informatización. Así, un clientetiene como atributos su código, su nombre, el total facturado, el

porcentaje de descuento que le hacemos habitualmente, etc.

VALOR Es un caso concreto de un atributo. Así, por ejemplo, el valor0017 para el atributo CODIGO DE CLIENTE, el valor28/1287162 para el atributo NÚMERO DE SEGURIDADSOCIAL.

El diseño de una base de datos es un proceso de abstracción sucesiva de modoque partiendo del mundo real lleguemos a un diseño físico pasando por un modelo dedatos y un diseño lógico de los mismos.

9.3.6. – El modelo Entidad-Relación..

Este modelo engloba una serie de técnicas para llevar adelante el proceso dediseño de una base de datos. Con él realizamos el paso que va desde la determinación delas entidades del mundo real hasta la formalización del modelo de datos y una primeraaproximación al diseño lógico de la base de datos resultante. El método empleado tienedos fases claramente diferenciadas:

1) Consiste en representar, mediante un determinado conjunto de símbolos, lasentidades, los atributos de las mismas y las interrelaciones que entre ellasexisten. Con ello tenemos lo que venimos denominando modelo de datos.

2) Consiste en determinar el diseño de la base de datos basándonos en elmodelo de datos hallado en el proceso anterior.

Los símbolos empleados pueden verse en las siguientes figuras.

Los símbolos del modelo entidad-relación.

ENTIDAD

RELACION

ATRIBUTO




En general, con ellos poseemos una buena herramienta para efectuar el diseño deuna base de datos. La primera labor a efectuar para ello es tomar papel y lápiz (o algunaherramienta informática, si la poseemos) y tratar de representar todas las entidades quedescubramos en la parcela del mundo real que debamos formalizar. A continuacióndeberemos determinar las relaciones entre estas entidades y las restricciones que llevan

consigo.

Lo veremos mejor con un problema práctico. Veamos el siguiente enunciado deaplicación:

La empresa X desea gestionar la información relativa a sus empleados ydepartamentos. Un departamento normalmente consta de varios empleados y éstossiempre están adscritos a un solo departamento. Se desea mantener información sobrelos datos de identificación básicos de los empleados: código identificador, nombre,domicilio, fecha de ingreso y salario anual, así como el nombre literal de cadadepartamento y la planta en que se ubica en la empresa.

Con este enunciado ya tenemos claramente diferenciadas dos entidades:EMPLEADO y DEPARTAMENTO. Entre ambas existe una relación: Los empleados pertenecen a los departamentos. Así, pues, a las don entidades hemos de añadirle unarelación, a la cual denominaremos Pertenece_a. Veamos ahora las restricciones de estarelación.

• Un empleado pertenece como mínimo y como máximo a un departamento.• Un departamento lo forman como mínimo 0 empleados y como máximo N

empleados.

Con estos dos enunciados anteriores hemos descubierto lo que denominaremos laCardinalidad en el modelo entidad-relación. Esta se representa en el primer caso como(1,1) y en el segundo como (0,N). Cuando la N aparece sólo asociada a una de las dosentidades relacionadas decimos que el grado de la relación es de 1 a N. Esto serepresenta 1:N. Si la N hubiera aparecido en ambas entidades, la relación sería N:M; loque querría decir que para 1 ocurrencia de la primera entidad habría N ocurrencias de lasegunda y viceversa. Cuando la N no aparece en ninguna de las dos entidades la relaciónes 1:1. Así pues, ya tenemos los tres tipos posibles de grado en una relación.

1:1 Para un elemento de una entidad existe 1 elemento de la otra y viceversa.

1:N Para un elemento de una entidad existen N elementos de la otra.

N:M Para N elementos de una entidad existen M elementos de la otra yviceversa.

La representación gráfica final del modelo de datos de nuestra aplicación puedeverse en la siguiente figura.




El modelo de datos de la aplicación propuesta.

El siguiente paso consiste en formar las tablas que necesitamos construir para

gestionar la aplicación que se nos demanda. Las reglas son:

• Una entidad se corresponde con una tabla.• En las relaciones 1:N la entidad de la N ocurrencias hereda la clave de la

entidad de la ocurrencia única. (Este es nuestro caso. La regla a lo que noslleva es a que la clave identificadora del departamento –el código-, hayamosde llevarlo a la tabla del empleado, de modo que podamos relacionar a ambosa través de él).

• Las relaciones N:M se convierten en una tabla cuyos atributos son comomínimo las claves de las dos entidades relacionadas. Piénsese por ejemplo enla relación entre las entidades AULA y PROFESOR. Un profesor puede darclase simultáneamente en varias aulas y un aula puede esta ocupada a lo largodel día por varios profesores. Esta es una relación N:M que se resuelve conuna tabla donde guardamos las aulas, otra donde guardamos los profesores yuna tercera (la proveniente de la relación N:M donde guardamos la clave delaula, la del profesor así como cualquier otro atributo de interés para larelación, como por ejemplo, el día y la hora en que se da una clase).

EMPLEADO DEPARTAMENTOPertenece_a

CODIGO

NOMBRE

DOMICILIO

F. INGRESO

SALARIO

CODIGO

NOMBRE

UBICACION




CANDIDATO A CLAVE.

Candidato a clave es un atributo o conjunto de atributos que identifica de formaunívoca un registro. Uno de los candidatos a clave es utilizado como clave principal oprimaria.

ATRIBUTO NO CLAVE.

Es aquel que no forma parte de la clave o de un candidato a clave.

DETERMINANTE.

Es un atributo o un conjunto de atributos del que dependen otros atributos.

Decimos que una relación está normalizada cuando para cada fila de unadeterminada columna sólo existe un valor individualizado y no un conjunto de valores.En nuestro ejemplo anterior vemos que en el fichero EMPLEADOS sólo podemos

asignar un valor a la columna CIUDAD para cada fila, es decir, para cada registro de unempleado distinto. La normalización nos permite estructurar los datos en relaciones yademás evita que los archivos de las bases de datos tengan redundancias, incoherenciaso inconsistencias.

9.3.7.1. – Formas normales.

NO NORMALIZADO.

Decimos que una relación o archivo no está normalizada cuando susdiferentes atributos se encuentran en un formato ambiguo, sin distinción

funcional y con longitud variable. Por ejemplo, si en una base de datos bancariaguardamos en el mismo registro los datos del titular de la cuenta y todos losmovimientos asociados.

1ª. FORMA NORMAL (1NF).

Una relación esta en 1NF si y sólo si sus atributos son nodescomponibles, es decir, si dentro de un mismo campo guardamos informaciónque no puede ser susceptible de una ulterior subdivisión.


Una relación esta en 2NF cuando está en 1NF y cada atributo no clavetiene Dependencia Funcional Completa de la clave primaria. Una relación queesté en 1NF puede descomponerse en un conjunto de relaciones que estén en2NF.





Una relación está en 3NF cuando está en 2NF y cada atributo no clavetiene dependencia no transitiva de la clave principal. O dicho de otra manera,cada atributo tiene dependencia únicamente de la clave, no existiendodependencias entre atributos no clave.

Veamos un ejemplo17:

Tenemos una empresa con una lista de proveedores con los siguientes datos:

CODIGO Código del proveedor.

NOMBRE Nombre del proveedor.

ESTADO Coeficiente numérico que se asigna a cada proveedor en funcióndel volumen de negocio con éste.

CIUDAD Ciudad donde vive el proveedor.

PEDIDO Pedido que se hace al proveedor (sólo uno por cada pieza).

PIEZA Pieza que se le pide al proveedor.

NOMPIEZ Nombre de la pieza.

COLOR Color de la pieza.

PESO Peso de la pieza.

CIUPED Ciudad a la que se envía la pieza.

17 Los archivos del ejemplo están tomados de la obra citada:C.J. Date. Op. Cit.




El formato de la ficha que recoge esta información sería el siguiente:

Código: S1Proveedor: Francisco Hernández y FernándezEstado: 20Ciudad: Londres

Pedidos:

Pieza Cantidad Nombre Color Peso CiudadP1 300 N1 Rojo 12 ParísP2 150 N2 Verde 20 MadridP3 200 N3 Azul 14 Madrid

. . . . . .

. . . . . .

. . . . . .

La relación estaría formada por:

CODIGO NOMBRE ESTADO CIUDAD PIEZA CANTIDAD NOMPIEZ COLOR PESO CIUPED

PEDIDO

Uno de los problemas que puede traer esta estructura de relación es que aldar de ALTA a un proveedor, forzosamente tendremos que dar de alta a unpedido, de la misma manera que si damos de baja a un pedido corremos el riesgode perder la información relativa a un proveedor, si éste tiene un solo pedido.

Además el atributo PEDIDO puede repetirse si un proveedor tiene más deun pedido, con lo que tendríamos que utilizar registros de longitud variable.

No está en 1NF (1ª Forma Normal) porque tiene el atributo PEDIDO quees descomponible.

La falta de normalización de esta estructura puede corregirse usando elsiguiente método:

REL 1ACODIGO NOMBRE ESTADO CIUDAD

REL 1BCODIGO PIEZA CANT NOMPIEZ COLOR PESO CIUPED

La clave de REL 1A es CODIGO y la de REL 1B es CODIGO+PIEZA.

Estas dos relaciones ya están en 1NF con lo que eliminamos losproblemas anteriores, aunque todavía posee otros no menos serios.




Cuando damos de ALTA a una pieza, también tenemos que dar de alta aun pedido. Esto nos obliga a rellenar en blanco los atributos CODIGO, CANT,CIUPED. Al igual que si damos de baja un pedido perderemos la informaciónrelativa a esa pieza. A la hora de la modificación de los datos de una pieza nosvemos en la obligación de modificarlo tantas veces como pedidos de ésta existan.

REL 2ACODIGO NOMBRE ESTADO CIUDAD

REL 2BCODIGO PIEZA CANT CIUPED

REL 2CPIEZA NOMPIEZ COLOR PESO

La clave de REL 2A es CODIGO, la de REL 2B es CODIGO+PIEZA, yla de REL 2C es PIEZA.

La relación REL 2ª ya estaba en 2NF porque no tenía clave compuesta.Las otras dos relaciones han surgido de la REL 1B que sí tenía clave compuesta ysin embargo no todos sus atributos dependían totalmente de ella. Los que sólodependían de PIEZA, y no de CODIGO, han dado lugar a la relación REL 2C.

Las tres relaciones están también en 3NF pues no hay dependencias deatributos no clave entre sí. Todos dependen únicamente de su clave principal.

Las relaciones resultantes son sin duda mucho más óptimas para elmovimiento de datos. La potencia de un Gestor de Bases de Datos Relaciónales

estriba en la posibilidad de relacionar de forma automática los diferentesarchivos que sean producto de situar en Tercera Forma Normal una estructura deinformación no normalizada.

9.3.8. – Índices y ordenaciones.

La información que se guarda en los archivos de una base de datos se almacenade forma secuencial en los diferentes archivos de la misma, es decir, que cada registro seescribe físicamente en un lugar posterior al último escrito.

Si nuestra base de datos es muy grande, la localización de un caso particular

puede ser larga y tediosa, ya que tendríamos que recorrernos desde el principio todos losregistros de la misma hasta localizar aquel que estamos buscando. Los índices estánpensados para solucionar este problema. Cada índice suele guardarse en una tablaauxiliar donde se guarda el número de registro correspondiente a cada caso y el valor delíndice para ese caso. Para comprender esto mejor veamos un ejemplo:




EMPLEADOS

No.Reg.

COD_EMP NOM_EMP CIUDAD COD

1 01 JUAN BERMUDEZ CADIZ DEP12 02 LUISA ALCAZAR CORDOBA DEP1

3 03 JOSE PRIETO LOGROÑO DEP14 04 ANTONIO GARCIA MADRID DEP15 05 LUCIA CASTILLO MURCIA DEP26 06 ROBERTO

GIMBERNATBARCELONA DEP2

7 07 MARIA CIFUENTES GUADALAJARA

DEP2

8 08 LUIS GARCIA MADRID DEP2

INDICE POR NOMBRE

NOM_EMP No. Reg.

ANTONIO GARCIA 4JOSE PRIETO 3JUAN BERMUDEZ 1LUCIA CASTILLO 5LUISA ALCAZAR 2LUIS GARCIA 8MARIA CIFUENTES 7ROBERTOGIMBERNAT

6

ORDENACION POR INDICES

En la figura anterior se nos muestra el archivo de empleados que ya hemos vistocon anterioridad. Como puede verse, este archivo está ordenado por el código de cadaempleado. Para una mayor claridad, hemos anotado en él también el número de registrocorrespondiente a cada caso. Si nos interesara hacer búsquedas alfabéticas por el nombrede cada empleado tendríamos alguna dificultad, ya que no existe una ordenación por estecampo.

En la figura podemos ver también qué aspecto tendría un índice por nombre.Como podemos observar, este índice lo concebimos como un archivo independiente

donde guardamos solamente el valor de cada nombre y el número del registro que cadauno de ellos tiene en el archivo principal. Al estar alfabetizado el índice las búsquedasson muy rápidas y si queremos acceder al caso completo bastará con dirigirnos alarchivo principal por el número de registro contenido en la tabla índice.

Los índices deben mantenerse de forma automática por el SGBD o mediante lasinstrucciones pertinentes del sub-lenguaje de datos. Es decir, cada vez que actualicemosla información de la tabla principal debe existir algún sistema para que se produzca una




actualización de la tabla índice.Existen también otro tipo de ordenaciones provisionales que se realizan sobre

archivos de trabajo, pero que no son mantenidas por el sistema sino que se realizan en elmomento en que han de ser usadas sin ninguna implicación posterior. Supongamos quela ordenación alfabética descrita no es frecuentemente usada por la aplicación quegestiona los archivos ya vistos. No obstante, en un determinado momento necesitamos

obtener un listado alfabético de todos los empleados de la empresa, dicho listadodifícilmente volverá a ser necesario. En este caso habría que proceder a una de estasordenaciones temporales que quedaría destruida una vez emitido el correspondientelistado.

Una de las labores preeminentes a la hora de realizar el diseño de una base dedatos relacional es fijar por qué campos habrán de ser indexados los archivos. Unarchivo índice nos garantiza una enorme rapidez en el acceso a la información, por elloparece que podría ser interesante que todos los campos de nuestros archivos fueraníndices. Sin embargo los índices ocupan también espacio en disco y han de sercontrolados por el sistema como un archivo más, esto puede crear ciertas limitaciones.Por ello han de fijarse como índices sólo aquellos campos que más frecuentemente

hayan de ser accedidos por sus correspondientes valores, dejando el resto sin indexarcomo campos susceptibles de ser ordenados de manera temporal por el segundo sistemadescrito.

Las ordenaciones también pueden realizarse por campos múltiples o porexpresiones que contengan valores de campos. Por ejemplo, la tabla de empleadospodría ordenarse por NOM_EMP+CIUDAD de modo que los empleados aparecieranpor orden alfabético para cada ciudad, o bien por los 20 primeros caracteres deNOM_EMP.

9.3.9. – Lenguajes de cuarta generación (4GL).

Uno de los elementos típicos que suelen incorporar los Gestores de Bases deDatos es lo que denominamos Lenguaje de Cuarta Generación. Estos lenguajes estándiseñados para facilitar el diseño rápido de aplicaciones y el fácil acceso a lainformación contenida en las bases de datos. Un lenguaje de cuarta generación es unlenguaje anfitrión más de entre los soportados por un SGBD, junto con los de tercerageneración: COBOL, etc. Sus características fundamentales son:

• Poseer un elevado nivel de ayudas a la programación, lo que le hace accesiblea usuarios o programadores no experimentados.

• Poseer generadores automáticos de informes, pantallas, gráficos e inclusoaplicaciones completas.

• Estar basado en las pautas de la programación estructurada.• Poseer dos niveles de uso, uno avanzado para programadores basado en una

estructura de mandatos similar a la de cualquier lenguaje convencional yotro, más simple, enfocado a usuarios donde la mayoría de las labores sedesarrollan por menús o por la cumplimentación de pantallas predefinidas.

• A veces es también una característica la posesión de una interfaz de lenguajenatural para las consultas simples de los usuarios del sistema.




Como ejemplos tenemos los lenguajes llamados, Visuales, de los cuales, algunos tienen origen en losviejos lenguajes de programación y conservan varias de sus características, tales como:

Lenguaje Visual Lenguaje OrigenVisual Basic Basic

Visual C++ C++Delphi PascalVisual Fox Pro Fox Pro (o Fox Base), Dbase, Clipper

9.4. – Gestión de archivos de datos.

Antes de iniciar con el estudio de los diagramas y algoritmos para la gestión de archivos,debes saber que las operaciones de un sistema básico de gestión de archivos (Sistema ABC) sonAltas de registros, Bajas de registros, Consultas de registros y Cambios o Modificaciones deregistros (sin olvidar la Creación del Archivo, que se verá mas adelante); siendo cada operaciónun módulo del sistema. Este sistema básico (que también algunos llamamos: de mantenimiento

de registros) lo podemos representar en una estructura jerárquica como sigue:

Dependiendo de los gustos de cada programador, cada módulo puede ser independientey presentar su propia pantalla de despliegue de datos, o bien, englobar en un solo módulo dos omás operaciones básicas, por ejemplo: Consultas y Cambios. O bien, presentar en una pantalla,un listado de los registros y mediante teclas de funciones bien definidas, accesar a cadaoperación básica de mantenimiento de registros; con el propio estilo del programador.

Una nota muy importante es el hecho de que existen dos tipos de Bajas de registros; unala llamaremos Baja Lógica y la otra Baja Física18.

La Baja Lógica consiste en marcar el registro que se desea eliminar, para que el sistemalo considere como borrado, pero sin que los datos desaparezcan o se pierdan. Esto lo puedehacer el SGBD mediante una marca interna, o bien nosotros a través de un campo al cualpodríamos llamar STATUS o CONDICION, el cual puede contener un tipo de dato Carácter oLógico, según sea posible o necesario. Una de las ventajas de la Baja Lógica, es la de poder

recuperar registros que fueron borrados por error o bien aquellos que son necesarios reactivarpor necesidades propias del proceso de información, y por el contra parte tenemos que unadesventaja es el espacio en disco que ocupa.

La Baja Física, como es de esperarse, consiste en eliminar totalmente el registro, esdecir, borrar todos los datos de los campos relativos al registro deseado. La ventaja de hacer lo

18 La frase Baja Física es relativa, dado que la información en sí, se maneja como si fuera un objeto en un plano conceptual,sin embargo, en el plano real, estos objetos al ser datos únicamente, no tienen volumen, peso o color, sino mas bien, losdescriben o representan.

Menu ABC

Altas Bajas Consultas Modificacioneso

Cambios




anterior es que economiza espacio en disco, sin embargo, una de sus peores desventajas es queresulta prácticamente imposible recuperar la información del registro.

Normalmente en la gran mayoría de los sistemas de gestión de archivos, se consideranlos dos tipos de Bajas, y por lo general el procedimiento para dar de baja a uno o mas registrosconsiste en realizar primero una Baja Lógica de aquel o aquellos registros que se deseaneliminar, y posteriormente, pasado un tiempo considerable, ejecutar un procedimiento de Baja

Física para todos aquellos registros marcados como Baja Lógica. En otras palabras, primero semarcan los registros deseados para su borrado, y pasado un tiempo se eliminan definitivamente,uno por uno o por lote, todos los registros marcados como borrados.

Como observación primordial, debemos tener presente que todo Sistema ABC, debeincluir una rutina o instrucción de creación del archivo.

La operación para crear un archivo lleva aparejada tanto la acción de dar nombre almismo, a fin de que el sistema lo reconozca, como la de dotarlo con la necesaria estructura deregistro según nuestras conveniencias. Todo esto podemos dividirlo en las siguientes secuenciaslógicas:

1. Identificar cada archivo mediante un nombre y el camino (ruta de acceso) necesariopara su localización en el disco.

2. Indicar el nombre de cada campo.3. Indicar el tipo de cada campo.4. Indicar el tamaño de cada campo.

Una vez que tenemos pensado el nombre y la información que contendrá nuestroarchivo, debemos indicar cómo se va a guardar dicha información. La unión de todos estoscampos dará como resultado un registro, de tal forma que podremos decir que un registrocontiene toda la información referente a un objeto (objeto desde el punto de vista informáticopuede ser una persona, una cosa, etc.).

Un campo va a estar formado por una serie de especificaciones. Estas serán:

- Nombre de Campo- Tipo de Campo- Ancho de Campo- Número de decimales del Campo

Nombre de Campo Es el nombre que le daremos a cada campo. Un nombre de campo estalimitado por las normas del traductor que usemos. Sin embargo, deberáforzosamente empezar por una letra y podrá contener letras, números y elcarácter especial “_”. Es aconsejable que el nombre sea significativo(descriptivo) respecto al dato que almacenará, para que así nos sea fácilde identificar a la hora de manipularlo.

Tipo de Campo Deberemos indicar el tipo de dato que vamos a utilizar. Recordemos queen los traductores de los lenguajes de programación se dispone por lomenos de dos tipos de campos:




• CARÁCTER. Los campos definidos con este tipo podráncontener todo tipo de caracteres, letras, números, caracteres especialesy espacios en blanco.

• NUMERICO. Sólo pueden contener números, punto decimal y elsigno negativo. Pueden ser números enteros o decimales.

Sin embargo, deberemos especificar claramente los tipos de datos autilizar en la estructura del archivo, de tal manera que, sepamos queformato utilizaremos para mostrar los datos. De ahí tenemos que otrostipos de datos que debemos usar y que también son aceptados por algunostraductores, son:

• FECHA. Acepta valores de fecha. Su longitud es normalmente de 8caracteres. Debemos tener cuidado, para el caso de que el traductor noreconozca este tipo de dato, de crearnos las rutinas necesarias paraque este tipo solamente acepte fechas válidas. Los formatos utilizados

generalmente son: dd/mm/aa ó mm/dd/aa, según la configuración deltraductor o bien que así lo desee el programador.

• LOGICO. Este tipo de campo tiene posibilidad de tomar dos valores,verdadero o falso. Para verdadero se introducirá T, Y o S (True, Yes oSi) y para falso F o N (False, Falso o No). Su longitud es de 1carácter.

• MEMO. Se utiliza para guardar textos de longitud variable. Losdatos que introducimos en este campo, no se guardan en el archivo enel que definimos el campo, sino en otro de igual nombre por logeneral. En el archivo donde se define el campo, se almacena unaclave que relacionará el registro con el texto correspondiente en elarchivo de texto.

Ancho de Campo En este concepto se determinará la longitud que tendrá el campo, nopudiendo sobrepasar los límites según su tipo, de acuerdo al traductorutilizado.Deberemos tener en cuenta que si un campo de tipo NUMERICO tienedecimales, al especificar el ancho, deberemos sumarle a los dígitos delnúmero entero, el punto decimal y el número de decimales que llevaráasociado. Supongamos que queremos guardar números de la forma999999.9999, para ello indicaremos que el ancho de este campo será 11,

ya que tenemos 6 dígitos para la parte entera, 1 para el punto decimal y 4dígitos como parte decimal.

Como última aclaración a la hora de especificar el ancho de los campos,deberemos pensar siempre en el dato de mayor longitud que seráintroducido en el archivo, y que no deberemos ni quedarnos cortos niponer mayor longitud de la prevista. Por ejemplo supongamos quetendremos un campo Mes donde guardaremos los nombres de losdistintos meses del año, pues bien no deberemos asignar un ancho de 7




caracteres, ya que ni Septiembre, ni Noviembre, ni Diciembre quedaránguardados completamente, y por el contrario tampoco diremos que tendráun ancho de 25 ya que el mes de nombre más largo, Septiembre,solamente tiene 10 caracteres.

Decimal de Campo Indicaremos aquí los decimales que contendrá un campo de tipo

numérico.

Todas las especificaciones antes descritas podríamos anotarlas en forma de una tabla como laque se muestra a continuación.

Nombre delCampo

Tipo Ancho Decimales

Y como nota final, siempre deberemos crear un campo clave, por medio del cual accesaremos lainformación a un registro, de una manera rápida y precisa, por ejemplo: Número de Control (deun alumno), Número de Referencia (de una cuenta contable), Número económico o Número deplacas (de una unidad de transporte), Número de modelo o de serie (de aparatos diversos),Número de código de barras (de artículos diversos), etc.

Y por fin, después de todo este mundo de conceptos, veremos los diagramas yalgoritmos típicos para la gestión de archivos.

Para el lector que ha seguido paso a paso este manual notará que, los primerosdiagramas así como sus algoritmos, tienen un diseño “no estructurado”, es decir, no usan unalógica lineal, la cual haría uso de bucles y no de saltos de una línea a otra.

Los segundos diagramas, como los algoritmos tienen un diseño “estructurado”, es decir,utilizan una lógica lineal, usando las instrucciones de bucles, en lugar de saltos de una línea aotra.

Esto se hizo así con el fin de presentar, lo más simple posible, la lógica de gestión dearchivos, desde los dos tipos de programación, para que compare las diferencias, y desde luego,se tomen como base para iniciar la codificación de programas para la gestión de archivos,puesto que tanto los diagramas como los algoritmos presentados a continuación, sonsusceptibles de optimizaciones y adecuaciones al estilo de cada programador, aunque, la lógica

general sea básicamente la misma.Debo recordarle amable lector que es preferible el modelo “estructurado”.




9.4.1. – Gestión de archivos secuenciales.

DISEÑO “NO ESTRUCTURADO”

Diagrama de flujo: ALTAS.

InicializarVariables

¿Existe elarchivo?

NO

SI

Creacióndel

archivo.

A

A

Solicitar clavey datos.

Clave y datos

Leerregistro.

Abrir archivo

Respuesta=‘S’

FIN

NO

SIB

Cerrar archivo

¿ Clave del Registro= Clave Capturada?

SI

“La Clave

YA existe.”

B

NO

Grabar elnuevo registro

C

C

‘¿Más datos?(S/N)’

Respuesta

INICIO

¿Fin deArchivo?

NO

SI

D

D

Ir al Principiodel archivo

E

E

Ir al siguienteregistro




DISEÑO “ESTRUCTURADO”


¿ No Existe elarchivo?

NO

SI

Creacióndel

archivo.

A

A


Clave y datos

Leerregistro.

Abrir archivo

Respuesta=‘S’

FIN

NO

SI

B

Cerrar archivo

¿ Clave del Registro= Clave Capturada?

SI

“La Clave

YA existe.”

B

NO

Grabar elnuevo registro

C

C


Respuesta

INICIO

¿No es Finde Archivo?

NO

SI

D

D

Ir alPrincipio

del archivo

E

E


Respuesta=‘S’Encontrado=Falso

Encontrado = Verdadero

¿No fueencontrado?

SI

NO

F

F




DISEÑO “NO ESTRUCTURADO”.

Algoritmo: ALTAS.

1. Inicializar Variables.2. Sí Existe el archivo entonces

Ir al paso 3.SinoCrear el archivo.

3. Abrir el archivo.4. Desplegar solicitud de clave y datos.5. Introducir clave y datos.6. Sí es Fin de Archivo entonces

- Grabar el nuevo registro- Ir al paso 11.

7. Leer registro8. Sí Clave del Registro = Clave Capturada entonces

- Desplegar ‘La Clave YA existe.’- Ir al paso 11.9. Ir al siguiente registro.10. Ir al paso 611. Ir al principio del archivo.12. Desplegar ‘¿ Más datos ?’13. Introducir Respuesta14. Sí Respuesta=’S’ entonces

Ir al paso 4.15. Cerrar el archivo.16. FIN.




DISEÑO “ESTRUCTURADO”.

Algoritmo: ALTAS.

1. Inicializar Variables.2. Sí No Existe el archivo entonces

a. Crear el archivo.3. Fin del Sí 4. Abrir el archivo.5. Respuesta = ‘S’6. Encontrado = Falso7. Mientras Respuesta = ‘S’

a. Desplegar solicitud de clave y datos.b. Introducir clave y datos.c. Mientras No sea Fin de archivo

i. Leer registro.ii. Sí Clave del Registro = Clave Capturada entonces

1. Encontrado = Verdadero.2. Desplegar ‘La Clave YA existe.’3. Salida (del Mientras no sea Fin de archivo).

iii. Fin del Sí.iv. Ir al siguiente registro.

d. Fin del Mientras No sea Fin de archivo. e. Sí No fue Encontrado entonces

i. Grabar el nuevo registro.f. Fin del Sí.g. Ir al Principio del archivo.h. Desplegar ‘¿Más datos? (S/N)’.

i. Introducir Respuesta.8. Fin del Mientras Respuesta = ‘S’9. Cerrar Archivo.10. FIN.





Diagrama de flujo: BAJAS. (Baja Lógica).


¿Existe elarchivo?

NO

SI

Creacióndel

archivo.

A

A

Solicitar laclave.

Clave.

Leerregistro.

Abrir archivo

Respuesta=‘S’

FIN

NO

SIB

Cerrar archivo

¿ Clave del registro= Clave Capturada?

SI

Datos delregistro.

‘¿Dar de bajael registro?’

B

NO

C

C

‘¿Otra Baja?(S/N)’

Respuesta

INICIO

¿Fin deArchivo?

NO

SI

D

D


E

E


Respuesta

Respuesta=‘S’

SI

NO

Marcar y grabar elregistro

E

‘El registro

NO existe’

‘El archivoesta vacio’





Diagrama de flujo: BAJAS. (Baja Lógica).


¿Existe elarchivo?

NO

SI

Creacióndel

archivo.

AA

Solicitar laclave.

Clave.

Leerregistro.

Abrir archivo

Respuesta=‘S’

FIN

NO

SI

B

Cerrar archivo


SI

Datos del

registro.‘¿Dar de baja el

registro?’

B

NO

C

C

‘¿Otra Baja?(S/N)’

Respuesta

INICIO

¿No es Fin

de Archivo?

NO

SI

D

D


E

E


Respuesta

Respuesta=‘S’

SI

NO


E

‘El registro

NO existe’


Respuesta = ‘S’Encontrado = Falso


¿No fueencontrado?

SI

F

F

G

GNO

Encontrado = Falso





Algoritmo: BAJAS. (Baja Lógica).


Ir al paso 3.Sino- Crear el archivo- Desplegar ‘El archivo esta vacío’- Ir al paso 20.

3. Abrir el archivo.4. Solicitar la Clave.5. Introducir la Clave.6. Sí es Fin de Archivo entonces

- Desplegar ‘El registro NO existe’- Ir al paso 14.

7. Leer registro8. Sí Clave del Registro = Clave Capturada entoncesIr al paso 11.

9. Ir al siguiente registro.10. Ir al paso 6.11. Desplegar los datos del registro.12. Desplegar ‘¿Dar de baja el registro?’13. Introducir Respuesta.14. Sí Respuesta = ‘S’ entonces

Marcar y grabar el registro.15. Ir al principio del archivo.

16. Desplegar ‘¿ Otra Baja ?’17. Introducir Respuesta18. Sí Respuesta=’S’ entonces






Algoritmo: BAJAS. (Baja Lógica).

i. Inicializar Variables.ii. Sí Existe el archivo entonces

1. Abrir el archivo.2. Respuesta = ‘S’3. Encontrado = Falso4. Mientras Respuesta = ‘S’

a. Solicitar la Clave.b. Introducir la Clave.c. Mientras No sea Fin de Archivo

i. Leer registroii. Sí Clave del Registro = Clave Capturada entonces

1. Encontrado = Verdadero.2. Desplegar los datos del registro.

3. Desplegar ‘¿Dar de baja el registro?’4. Introducir Respuesta5. Sí Respuesta = ‘S’ entonces

a. Marcar y grabar el registro.6. Fin del Sí.7. Salir (del Mientras No sea Fin de Archivo)

iii. Fin del Sí.iv. Ir al siguiente registro.

d. Fin del Mientras No sea Fin de Archivo.e. Sí No fue Encontrado entonces

i. Desplegar ‘El registro NO existe.’.

f. Fin del Sí.g. Ir al principio del archivo.h. Desplegar ‘¿ Otra Baja ?’i. Introducir Respuesta j. Encontrado = Falso.

5. Fin del Mientras Respuesta = ‘S’iii. Sino

1. Crear el archivo2. Desplegar ‘El archivo esta vacío’

iv. Fin del Sí.v. Cerrar el archivo.

vi. FIN.





Diagrama de flujo: CONSULTAS.


¿Existe elarchivo?

NO

SI

Creacióndel

archivo.

A

A

Solicitar laclave.

Capturar la

Clave.

Leer

registro.

Abrir archivo

Respuesta=‘S’

FIN

NO

SIB

Cerrar archivo


SI

Datos delregistro.

B

NO

C

C

‘¿Otra consulta?(S/N)’

Respuesta

INICIO

¿Fin deArchivo?

NO

SI

D

D


E

E


‘El registro

NO existe’








¿Existe elarchivo?

NO

SI

Creacióndel

archivo.

AA

Solicitar laclave.

Clave.

Leerregistro.

Abrir archivo

Respuesta=‘S’

FIN

NO

SI

B

Cerrar archivo


SI

Datos delregistro.

B

NO

C

C

‘¿Otra Consulta?(S/N)’

Respuesta

INICIO


NO

SI

D

D


E


‘El registro

NO existe’




¿No fueencontrado?

SI

F

FNO

E

Encontrado = Falso





Algoritmo: CONSULTAS.






9. Ir al siguiente registro.10. Ir al paso 6.11. Desplegar los datos del registro.12. Ir al principio del archivo.13. Desplegar ‘¿ Más datos ?’14. Introducir Respuesta15. Sí Respuesta=’S’ entonces

Ir al paso 4.

16. Cerrar el archivo.17. FIN.







a. Abrir el archivo.b. Respuesta = ‘S’c. Encontrado = Falsod. Mientras Respuesta = ‘S’

i. Solicitar la Clave.ii. Introducir la Clave.

iii. Mientras No sea Fin de Archivo 1. Leer registro2. Sí Clave del Registro = Clave Capturada entonces

a. Encontrado = Verdadero.b. Desplegar los datos del registro.

c. Salir (del Mientras No sea Fin de Archivo)3. Fin del Sí.4. Ir al siguiente registro.

iv. Fin del Mientras No sea Fin de Archivo.v. Sí No fue Encontrado entonces

1. Desplegar ‘El registro NO existe.’.vi. Fin del Sí.

vii. Ir al principio del archivo.viii. Desplegar ‘¿ Otra Consulta ?’

ix. Introducir Respuestax. Encontrado = Falso.

e. Fin del Mientras Respuesta = ‘S’3. Sino

a. Crear el archivob. Desplegar ‘El archivo esta vacío’

4. Fin del Sí.5. Cerrar el archivo.6. FIN.





Diagrama de flujo: CAMBIOS. (Modificaciones).


¿Existe elarchivo?

NO

SI

Creacióndel

archivo.

A

A

Solicitar laclave.

Capturar laClave.

Leerregistro.

Abrir archivo

Respuesta=‘S’

FIN

NO

SIB

Cerrar archivo


SI

Datos delregistro.

‘¿Modificar elregistro?’

B

NO

C

C


Respuesta

INICIO

¿Fin deArchivo?

NO

SI

D

D Ir al Principiodel archivo

E

E


Respuesta

Respuesta=‘S’

SI

NO

Grabar el registro

E

‘El registro

NO existe’

‘El archivoesta vacio’ Solicitar los

datos delregistro.

Datos del registro.




DISEÑO “ ESTRUCTURADO”

Diagrama de flujo: CAMBIOS. (Modificaciones).


¿Existe elarchivo?

NO

SI

Creacióndel

archivo.

AA

Solicitar laclave.

Clave.

Leerregistro.

Abrir archivo

Respuesta=‘S’

FIN

NO

SI

Cerrar archivo


SI

Datos delregistro.


NO

C

CINICIO


NO

SI

D

D

E

E


Respuesta

Respuesta=‘S’

SI

NO

Grabar el registro

E

‘El archivo

esta vacio’



¿No fue

encontrado?

SI

NO

Solicitardatos delregistro.

F

B

G




‘¿Otra modificación?(S/N)’

Respuesta


‘El registroNO existe’

Encontrado = Falso

F

B

G





Algoritmo: CAMBIOS. (Modificaciones).






9. Ir al siguiente registro.10. Ir al paso 6.11. Desplegar los datos del Registro.12. Desplegar ‘¿Modificar el registro?’13. Introducir Respuesta.14. Sí Respuesta = ‘S’ entonces

- Desplegar Solicitud de datos del registro.- Introducir los datos del registro.

- Grabar el registro.15. Ir al principio del archivo.16. Desplegar ‘¿ Más datos ?’17. Introducir Respuesta18. Sí Respuesta=’S’ entonces






Algoritmo: CAMBIOS. (Modificaciones).


a. Abrir el archivo.b. Respuesta = ‘S’c. Encontrado = Falsod. Mientras Respuesta = ‘S’

i. Solicitar la Clave.ii. Introducir la Clave.

iii. Mientras No sea Fin de Archivo 1. Leer registro2. Sí Clave del Registro = Clave Capturada entonces

a. Encontrado = Verdadero.b. Desplegar los datos del registro.

c. Desplegar ‘¿Modificar el registro?’d. Introducir Respuestae. Sí Respuesta = ‘S’ entonces

i. Desplegar Solicitud de datos del registro.ii. Introducir los datos del registro.

iii. Grabar el registro.f. Fin del Sí.g. Salir (del Mientras No sea Fin de Archivo)

3. Fin del Sí.4. Ir al siguiente registro.

iv. Fin del Mientras No sea Fin de Archivo.

v. Sí No fue Encontrado entonces1. Desplegar ‘El registro NO existe.’.

vi. Fin del Sí.vii. Ir al principio del archivo.

viii. Desplegar ‘¿ Otra Modificación ?’ix. Introducir Respuestax. Encontrado = Falso.

e. Fin del Mientras Respuesta = ‘S’3. Sino

a. Crear el archivob. Desplegar ‘El archivo esta vacío’

4. Fin del Sí.5. Cerrar el archivo.6. FIN.




9.4.2. – Gestión de archivos directos.

DISEÑO “NO ESTRUCTURADO” Diagrama de flujo: ALTAS.


¿Existe elarchivo?

NO

SI

Creacióndel

archivo.

A

A

Solicitar el Númerode registro y datos.

Número de

registro y datos

Ir al registroy leerlo.

Abrir archivo

Respuesta=‘S’

FIN

NO

SIB

Cerrar archivo

SI

‘El registroYA esta

ocupado.’

B

NO

Grabar losdatos en el

registro

C

C


Respuesta

INICIO

¿Registrovacío?

D

E

E




DISEÑO “ESTRUCTURADO” Diagrama de flujo: ALTAS.


¿Existe elarchivo?

NO

SI

Creacióndel

archivo.

A

A

Solicitar el Númerode registro y datos.

Número deregistro y datos


Abrir archivo

Respuesta=‘S’

FIN

NO

SI

B

Cerrar archivoSI

‘El registroYA esta

ocupado.’

B

NO

Grabar losdatos en el

registro

C

C


Respuesta

INICIO

¿Registrovacío?

D

E

E

Respuesta = ‘S’





Algoritmo: ALTAS.



3. Abrir el archivo.4. Desplegar Solicitud del Número de registro y datos.5. Introducir Número de registro y datos.6. Grabar el nuevo registro7. Ir al registro y leerlo.8. Sí el Registro está Vacío entonces

- Grabar los datos en el registro.- Ir al paso 10.

9. Desplegar ‘El registro YA esta ocupado.’10. Desplegar ‘¿ Más datos ?’11. Introducir Respuesta12. Sí Respuesta=’S’ entonces






Algoritmo: ALTAS.


a. Abrir el archivo.b. Respuesta = ‘S’c. Mientras Respuesta = ‘S’

i. Desplegar Solicitud del Número de registro y datos.ii. Introducir Número de registro y datos.

iii. Ir al registro y leerlo.iv. Sí el Registro está Vacío entonces

1. Grabar los datos en el registro.v. Sino

1. Desplegar ‘El registro YA esta ocupado.’vi. Fín de Sí.

vii. Desplegar ‘¿ Más datos ?’viii. Introducir Respuestad. Fin del Mientras.





DISEÑO “NO ESTRUCTURADO” Diagrama de flujo: BAJAS. (Baja Lógica).

Número deregistro


¿Existe elarchivo?

NO

SI

Creacióndel

archivo.

Solicitar el Númerode registro.


Abrir archivoRespuesta=‘S’

FIN

NO

SIC

Cerrar archivo

Datos delregistro.

‘¿Dar de baja elregistro?’

C

A


Respuesta

INICIO

B

‘Elarchivo

Respuesta

Respuesta=‘S’SI

NO

B

A





DISEÑO “ESTRUCTURADO” Diagrama de flujo: BAJAS. (Baja Lógica).


¿Existe elarchivo?

NO

SI

Creacióndel

archivo.


Número deregistro


Abrir archivo

Respuesta=‘S’

FIN

NO

SI

C

Cerrar archivo

Datos delregistro.

‘¿Dar de baja elregistro?’

C

A


Respuesta

INICIO

B

‘El archivoesta vacío.’

Respuesta

Respuesta=‘S’

SI

NOB

A


Respuesta = ‘S’




DISEÑO “NO ESTRUCTURADO” Algoritmo: BAJAS. (Baja Lógica).


Ir al paso 3.

Sino- Crear el archivo.- Desplegar ‘El archivo esta vacío’.- Ir al paso 14.

3. Abrir el archivo.4. Desplegar Solicitud del Número de registro.5. Introducir Número de registro.6. Ir al registro y leerlo.7. Desplegar los datos del registro.8. Desplegar ‘¿Dar de baja el registro?’9. Introducir Respuesta.

10. Sí Respuesta = ‘S’ entonces- Marcar y grabar los datos en el registro.11. Desplegar ‘¿ Más datos ?’12. Introducir Respuesta13. Sí Respuesta=’S’ entonces





DISEÑO “ESTRUCTURADO” Algoritmo: BAJAS. (Baja Lógica).


a. Abrir el archivo.

b. Respuesta = ‘S’c. Mientras Respuesta = ‘S’i. Desplegar Solicitud del Número de registro.

ii. Introducir Número de registro.iii. Ir al registro y leerlo.iv. Desplegar los datos del registro.v. Desplegar ‘¿Dar de baja el registro?’

vi. Introducir Respuesta.vii. Sí Respuesta = ‘S’ entonces

1. Marcar y grabar los datos en el registro.viii. Fin del Sí

ix. Desplegar ‘¿ Más datos ?’x. Introducir Respuestad. Fin del Mientras

3. Sinoa. Crear el archivo.b. Desplegar ‘El archivo esta vacío’.

4. Fin del Sí 5. Cerrar el archivo.6. FIN.




DISEÑO “NO ESTRUCTURADO” Diagrama de flujo: CONSULTAS.


¿Existe elarchivo?

NO

SI

Creacióndel

archivo.


Número deregistro


Abrir archivoRespuesta=‘S’

FIN

NO

SIB

Cerrar archivo

Datos delregistro.

B

A

‘¿Mas datos?(S/N)’

Respuesta

INICIO


A




DISEÑO “ESTRUCTURADO” Diagrama de flujo: CONSULTAS.

B


¿Existe elarchivo?

NO

SI

Creacióndel

archivo.


Número deregistro


Respuesta=‘S’

FIN

NO

SI Cerrar archivo

Datos delregistro.

B

A


Respuesta

INICIO


A

Respuesta = ‘S’

Abrir archivo




DISEÑO “NO ESTRUCTURADO” Algoritmo: CONSULTAS.


Ir al paso 3.

Sino- Crear el archivo.- Desplegar ‘El archivo esta vacío’.- Ir al paso 12.

3. Abrir el archivo.4. Desplegar Solicitud del Número de registro.5. Introducir Número de registro.6. Ir al registro y leerlo.7. Desplegar los datos del registro.8. Desplegar ‘¿ Más datos ?’9. Introducir Respuesta

10. Sí Respuesta=’S’ entoncesIr al paso 4.11. Cerrar el archivo.12. FIN.




DISEÑO “ESTRUCTURADO” Algoritmo: CONSULTAS.


a. Abrir el archivo.

b. Respuesta = ‘S’c. Mientras Respuesta = ‘S’i. Desplegar Solicitud del Número de registro.

ii. Introducir Número de registro.iii. Ir al registro y leerlo.iv. Desplegar los datos del registro.v. Desplegar ‘¿ Más datos ?’

vi. Introducir Respuestad. Fin del Mientras.

3. Sinoa. Crear el archivo.

b. Desplegar ‘El archivo esta vacío’.4. Fin del Sí.5. Cerrar el archivo.6. FIN.




DISEÑO “NO ESTRUCTURADO” Diagrama de flujo: MODIFICACIONES (Cambios).

Número deregistro


¿Existe elarchivo?

NO

SI

Creacióndel

archivo.



Abrir archivo

Respuesta=‘S’

FIN

NO

SIB

Cerrar archivoDatos delregistro.


B

A


Respuesta

INICIO


A

Respuesta

Res uesta=‘S’

SI

NO

Grabar el registro

E

Solicitar losdatos delregistro.

Datos del registro.




DISEÑO “ESTRUCTURADO” Diagrama de flujo: MODIFICACIONES (Cambios).


¿Existe elarchivo?

NO

SI

Creacióndel

archivo.


Número deregistro


Abrir archivo

Respuesta=‘S’

FIN

NO

SI

B

Cerrar archivo

Datos delregistro.


B

A


Respuesta

INICIO


A

Respuesta

Res uesta=‘S’

SI

NO

Grabar el registro

E

Solicitar losdatos delregistro.

Datos del registro.

Respuesta = ‘S’

E




DISEÑO “ESTRUCTURADO” Algoritmo: MODIFICACIONES (Cambios).

1. Inicializar variables.2. Sí existe el archivo entonces

a. Abrir el archivo

b. Respuesta = ‘S’c. Mientras Respuesta = ‘S’i. Solicitar el número de registro

ii. Introducir el número de registroiii. Ir al registro y leerloiv. Desplegar los datos del registrov. Desplegar “¿Modificar el registro?

vi. Introducir Respuestavii. Sí Respuesta = “S” entonces

1. Solicitar los datos del registro2. Introducir los datos del registro

3. Grabar el registroviii. Fin del Sí ix. Desplegar “¿Más datos (S/N)?”x. Introducir Respuesta

d. Fin del mientras3. sino

a. Creación del archivob. Desplegar “El archivo esta vacío.”c. Cerrar el archivo.

4. Fin del Sí 5. FIN




9.4.3. – Gestión de archivos indexados.



Capturar clave y

datos


¿Existe elarchivo?

NO

SI

Creacióndel

archivo.

AA


Buscar elregistro por

la clave.

Abrir archivo

Respuesta=‘S

FIN

NO

SI

B

Cerrar archivo

¿ Se encontroel registro ?

SI “El registro

YA existe.”

C

B

NO

Grabar elre istro

C

C

¿Más datos?(S/N)

Respuesta

INICIO





Algoritmo: ALTAS.



3. Abrir el archivo.4. Solicitar clave y datos.5. Introducir clave y datos.6. Buscar el registro por la clave.7. Sí Se encontró el registro entonces

Ir al Paso 8.Sino

Desplegar ‘El registro YA existe’.

Ir al Paso 9.8. Grabar registro.9. Desplegar ‘¿ Más datos ?’10. Introducir Respuesta11. Sí Respuesta=’S’ entonces







INICIO

Inicializar variables

¿Existe elarchivo?

NO

SI

Creacióndel archivo

Abrir archivo

AA

Respuesta = “S”

¿Respuesta= “S”?

B

SI

NO

Solicitar clavey datos

Capturar clavey datos

C

C

Buscar el registropor la clave

¿Se encontroel registro?

NO

SI

“El registro

YA existe.”

Grabar elregistro

“¿Más datos?(S/N)”

B

Respuesta

Cerrar archivo

FIN





Algoritmo: ALTAS.

1. Inicializar variables2. Sí NO existe el archivo entonces

a. Creación del archivo3. sinoa. Abrir archivob. Respuesta =”S”c. Mientras Respuesta = “S”

i. Solicitar clave y datosii. Introducir clave y datos

iii. Buscar el registro por la claveiv. Sí NO se encontro el registro entonces

1. Grabar el registrov. Sino

1. Desplegar “El registro YA existe”vi. Fin del Sí vii. Desplegar “¿Más datos (S/N)”

viii. Introducir Respuestad. Fin del Mientrase. Cerrar archivo

4. Fin del Sí





Diagrama de flujo: BAJAS.


¿ Existe elarchivo ?

NO

SI

Creacióndel

archivo.

“Elarchivo

estavacio.”

Abrir archivo

Solicitarclave.

Capturar clave

A

A

Buscar el

registro porla clave.


NO

SI

“El registroNO existe.”

B

C

Marcar oeliminar elregistro.

Datos delRegistro.

¿Dar de bajael registro?

Respuesta

Res uesta=‘S

NO

SI

C

¿Buscar otro

registro?

Respuesta

Respuesta=‘S

NO

SI

D

D

Cerrar archivo

FIN

INICIO

B

C





Algoritmo: BAJAS.


Ir al paso 3.Sino- Crear el archivo.- Desplegar “El archivo esta vacío”.- Ir al paso 15.

3. Abrir el archivo.4. Solicitar clave.5. Introducir clave.6. Buscar el registro por la clave.7. Sí Se encontró el registro entonces

Desplegar Datos del Registro.

Sino- Desplegar ‘El registro NO existe’.- Ir al Paso 11

8. Desplegar ‘¿Dar de baja el registro?’9. Introducir Respuesta10. Sí Respuesta=’S’ entonces

Marcar o eliminar el registro11. Desplegar ‘¿ Buscar otro registro ?’12. Introducir Respuesta13. Sí Respuesta=’S’ entonces

Ir al paso 4.





DISEÑO “ESTRUCTURADO” Diagrama de flujo: BAJAS.

INICIO


¿Existe elarchivo?

SI

NO

Abrir archivo

Respuesta = “S”

¿Respuesta =“S”?

NO


Datos del registro.“¿Dar de baja elregistro? (S/N)”

Respuesta


B

Creacióndel archivo

“El archivoestá vacio.”

Marcar oeliminar el

registro

B

A

SI

NO

Solicitarclave.

Capturar clave

Buscar el registropor la clave.

¿Se encontro elregistro?

A

SI

SI

NO

B

“¿Buscar otroregistro?”

Respuesta

C

C

Cerrararchivo

FIN

D

D





Algoritmo: BAJAS.


a. Creación del archivob. Desplegar “El archivo está vacío”3. sino

a. Abrir archivob. Respuesta = “S”c. Mientras Respuesta = “S”

i. Solicitar claveii. Introducir Clave

iii. Buscar el registro por claveiv. Sí se encontro el registro entonces

1. Desplegar datos del registro

2. Desplegar “¿Dar de baja el registro? (S/N)”3. Introducir Respuesta4. Sí Respuesta = “S” entonces

a. Marcar o eliminar el registro5. Fin del Sí

v. Fin del Sí vi. Desplegar “¿Buscar otro registro?”

vii. Introducir Respuestad. Fin del Mientrase. Cerrar archivo

4. Fin del Sí

5. FIN






INICIO



Creacióndel

archivo.

“Elarchivo

estavacio.”

NO

Abrir archivo

A

Solicitarclave.

A

Clave

Buscar el

registro porla clave.


SI

SI

NO “El registro

NO existe.”

Datos del

Registro.

¿Buscarotro

Respuesta

Respuesta=‘S

Cerrar archivo

FIN

SI

NO

C

B

B

C







Ir al paso 3.Sino- Crear el archivo.- Desplegar “El archivo esta vacío”- Ir al paso 12.



Sino- Desplegar ‘El registro NO existe’.8. Desplegar ‘¿ Buscar otro registro ?’9. Introducir Respuesta10. Sí Respuesta=’S’ entonces





DISEÑO “ESTRUCTURADO” Diagrama de flujo: CONSULTAS.

INICIO

Inicializar Variables

¿Existe elarchivo?

SI

NO

Abrir archivo

Respuesta = “S”


Creacióndel

archivo

“El archivo

está vacío”

SI

NO

Solicitarclave

Clave

Buscar el re istro or la clave

¿Se encontro el registro?

SI

NO

Cerrar archivo

A

FIN

A

B


C

B

Datos delregistro

C

“¿Otra consulta?(S/N)”

Respuesta

D

D







a. Creación del archivob. Desplegar “El archivo está vacío.”3. sino


i. Desplegar Solicitar Claveii. Introducir Clave

iii. Buscar el registro por la Claveiv. Sí se encontro el registro entonces

1. Desplegar datos del registro

v. Sino1. Desplegar “El registro NO existe.”vi. Fin del Sí

vii. Desplegar “¿Otra consulta? (S/N)”viii. Introducir Respuesta

d. Fin del Mientrase. Cerrar Archivo





DISEÑO “NO ESTRUCTURADO” Diagrama de flujo: MODIFICACIONES (Cambios).

INICIO



Creacióndel

archivo.

“Elarchivo

esta

vacio.”

NO

Abrir archivo

A

Solicitarclave.

Capturar clave

Buscar elregistro por

la clave.


SI

SI

NO “El registro

NO existe.”

Datos del Registro.

¿Buscar otroregistro?

Respuesta

Respuesta=‘S

Cerrar archivo

FIN

SI

NO

B

B

C

C

A

¿Modificar registro?

Respuesta

Res uesta=‘SSI Solicitar

datos delregistro.

Capturar datosdel registro.

Grabar elre istro

NO

C





Algoritmo: MODIFICACIONES (Cambios).


Ir al paso 3.Sino- Crear el archivo.- Desplegar “El archivo esta vacío”- Ir al paso 16.



Sino- Desplegar ‘El registro NO existe’.- Ir al paso 11.

8. Desplegar ‘¿Modificar registro?9. Introducir Respuesta10. Sí Respuesta =’S’ entonces

- Desplegar solicitud de datos del registro.- Capturar datos del registro.- Grabar el registro.

11. Desplegar ‘¿ Buscar otro registro ?’12. Introducir Respuesta

13. Sí Respuesta=’S’ entonces14. Ir al paso 4.15. Cerrar el archivo.16. FIN.





Algoritmo: MODIFICACIONES (Cambios).


a. Creación del archivob. Desplegar “El archivo está vacío”3. Sino


i. Desplegar Solicitar Claveii. Introducir Clave

iii. Buscar el registro por la Claveiv. Sí se encontro el registro entonces

1. Desplegar Datos del registro

2. Desplegar “¿Modificar el registro? (S/N)”3. Introducir Respuesta4. Sí Respuesta = “S” entonces

a. Desplegar Solicitar Datos del registrob. Introducir Datos del registroc. Grabar Registro

5. Fin del Sí v. Sino

1. Desplegar “El registro NO existe”vi. Fin del Sí

vii. Desplegar “¿Buscar otro registro? (S/N)”

viii. Introducir Respuestad. Fin del Mientrase. Cerrar archivo





9.4.4. – Gestión de una base de datos relacional constituida por dos archivos.

Para las bases de datos relacionales, lo óptimo es utilizar archivos indexados y undiseño estructurado. Otro punto importante es definir cual es el archivo principal y cual esel complementario. Para nuestro ejemplo, el archivo principal será nombrado como A y elcomplementario como B.

La lógica del sistema ABC, básicamente es la misma, la única diferencia es en elmomento de capturar o buscar los datos complementarios en un segundo archivo.Se debe recordar que en el archivo complementario (B) se almacenan grupos de

registros relacionados a un registro del archivo principal (A), por lo tanto, los datos delcampo Clave pueden estar repetidos, no así en el archivo principal.

Algoritmo: ALTAS.

1. Inicializar variables.2. Sí NO Existe el archivo A entonces

a. Creación del archivo A

b. Creación del archivo B3. Sinoa. Sí NO Existe el archivo B entonces

i. Creación del archivo B.b. Fin del Sí

4. Fin del Sí.5. Abrir los archivos.6. Clave = “”7. Mientras Clave <> “SALIR”

a. Desplegar solicitud de la Clave.b. Introducir Clave

c. Sí Clave = “SALIR” entoncesi. Vuelta al Mientras

d. Fin del Sí e. Buscar el registro por la Clave en el archivo A.f. Sí se encontró el registro entonces

i. Desplegar “El registro YA existe”g. Sino

i. Solicitar datos del archivo Aii. Introducir datos del archivo A

iii. Desplegar “¿Los datos estan correctos? (S/N)”iv. Introducir Respuestav. Sí Respuesta = “S” entonces

1. Grabar registro en archivo A2. Mientras Respuesta = “S”

a. Solicitar datos para archivo B.b. Introducir datos del archivo B.c. Desplegar “¿Los datos están correctos? (S/N)?”d. Introducir Respuestae. Sí Respuesta = “S” entonces




i. Grabar registro en archivo Bf. Fin del Sí g. Desplegar “¿Más datos? (S/N)”h. Introducir Respuesta

3. Fin del Mientrasvi. Fin del Sí

h. Fin del Sí 8. Fin del Mientras9. Cerrar archivos10. FIN




Algoritmo: BAJAS.

1. Inicializar variables.2. Sí NO Existe el archivo A entonces

a. Creación del archivo Ab. Creación del archivo B

c. Desplegar “Los archivos estan vacíos.”3. Sinoa. Sí NO Existe el archivo B entonces

i. Creación del archivo Bb. Fin del Sí c. Abrir los archivos.d. Clave = “”e. Mientras Clave <> “SALIR”

i. Desplegar solicitud de la Claveii. Introducir Clave

iii. Sí Clave = “SALIR” entonces

1. Vuelta al Mientrasiv. Fin del Sí v. Buscar el registro por la Clave en el archivo A

vi. Sí NO se encontró el registro entonces1. Desplegar “El registro NO existe”

vii. Sino1. Desplegar los datos del archivo A2. Encontrado = FALSO3. Ir al principio del archivo B4. Mientras NO sea FIN DE ARCHIVO en B

a. Localizar registro relacionado por la Clave.

b. Sí se encontro registro relacionado entoncesi. Desplegar datos del registro localizado.

ii. Encontrado = VERDADEROc. Fin del Sí

5. Fin del Mientras6. Sí Encontrado = FALSO entonces

a. Desplegar “La clave no tiene registros relacionados”b. Desplegar “PUEDE BORRAR EL REGISTRO

PRINCIPAL, SI LO DESEA.”c. Desplegar “¿Dar de baja el registro principal? (S/N)?d. Introducir Respuestae. Sí Respuesta = “S” entonces

i. Marcar o eliminar el registro principalf. Fin del Sí

7. Sinoa. Desplegar “NO PUEDE BORRAR EL REGISTRO

PRINCIPAL, PUES TIENE REGISTROSRELACIONADOS. ES NECESARIO QUE PRIMEROBORRE LOS REGISTROS DEL ARCHIVO B.”




b. Desplegar “¿Desea borrar registros relacionados delarchivo B? (S/N)”

c. Introducir Respuestad. Mientras Respuesta = “S”

i. Desplegar “Teclee la referencia del registrosecudario a borrar”

ii. Introducir Referenciaiii. Localizar registro a borrar del archivo Biv. Sí se encontro el registro entonces

1. Desplegar “¿Dar de baja el registrosecundario? (S/N)”

2. Introducir Respuesta3. Sí Respuesta = “S” entonces

a. Marcar o eliminar el registrosecundario

4. Fin del Sí v. Sino

1. Desplegar “No existe el registro”vi. Fin del Sí vii. Desplegar “¿Borrar otro registro secundario?

(S/N)”viii. Introducir Respuesta

e. Fin del Mientras8. Fin del Sí

viii. Fin del Sí f. Fin del Mientras

4. Fin del Sí 5. Cerrar archivos

6. FIN.




Algoritmo: CONSULTAS

1. Inicializar variables.2. Sí NO Existe el Archivo A entonces

a. Creación del archivo Ab. Creación del archivo B

c. Desplegar “Los archivos están vacíos.”3. Sinoa. Sí NO Existe el archivo B entonces

i. Creación del archivo Bb. Fin del Sí c. Abrir los archivosd. Clave = “”e. Mientras Clave <> “SALIR”

i. Desplegar solicitud de la Claveii. Introducir Clave

iii. Sí Clave = “SALIR” entonces

1. Vuelta al Mientrasiv. Fin del Sí v. Buscar el registro por la Clave en el archivo A

vi. Sí NO se encontró el registro entonces1. Desplegar “El registro NO existe.”

vii. Sino1. Desplegar los datos del archivo A2. Encontrado = FALSO3. Ir al principio del archivo B4. Mientras NO sea FIN DE ARCHIVO en B

a. Localizar registro relacionado por la Clave

b. Sí se encontro registro relacionado entoncesi. Desplegar datos del registro localizado

ii. Encontrado = VERDADEROc. Fin del Sí

5. Fin del Mientras6. Sí Encontrado = FALSO entonces

a. Desplegar “La clave no tiene registros relacionados”7. Fin del Sí

viii. Fin del Sí f. Fin del Mientras

4. Fin del Sí 5. Cerrar archivos6. FIN




iv. Introducir Respuestav. Sí Respuestas = “S” entonces

1. Mientras VERDADEROa. Desplegar solicitud de datos del

registro secundario encontrado.b. Introducir datos del registro

secundario encontrado.c. Desplegar “¿Están correctos losdatos? (S/N)”

d. Introducir Respuestae. Sí Respuesta = “S” entonces

i. Grabar los datos del registroii. Salir del Mientras

f. Fin del Sí 2. Fin del Mientras

vi. Fin del Sí c. Fin del Sí

9. Fin del Mientras10. Sí Encontrado = FALSO entoncesa. Desplegar “La clave no tiene registros relacionados.”

11. Fin del Sí viii. Fin del Sí

f. Fin del Mientras4. Fin del Sí 5. Cerrar archivos6. FIN




10. – Introducción a la Programación Dirigida por los Datos.

El término data-driven programming, en una traducción literal, puede traducirse como programación dirigida por los datos. Mediante la programación dirigida por los datos, usted puedeahorrar mucho tiempo en el desarrollo y mantenimiento de sus aplicaciones.

10.1. – Programación Código-Fijo (Hard-Code).

Este término puede ser nuevo para usted; no obstante, en su estilo de programación debeintentar que sus programas sean hard-coded , es decir, que estén escritos de manera literal,fáciles de entender y de programar.

Vea el ejemplo siguiente, escrito en lenguaje Clipper:

USE Func *** Usar o abrir el archivo Func.DO WHILE .T. *** Bucle infinito: Hacer mientras VERDADERO.

mCodEmpl = CodEmpl *** \ mNombreEmpl = NombreEmpl *** \ mCodSet = CodSet *** \ mCodCar = CodCar *** Asignación de valores de campos a variables.mFechaEnt = FechaEnt *** / mSalario = Salario *** / mGremio = Gremio *** / ** ORDENES *** Lógica de gestión del archivo.

ENDDO *** Terminación del bucle infinito.

En este ejemplo son inicializadas las variables de memoria (identificadas con la m antepuesta) con el contenido de los campos de un archivo para utilizarlas después. Cada nombre

de campo y de variable ha sido explícitamente especificado. Si tuviéramos cinco campos,tendríamos cinco líneas de asignación. Si tuviéramos treinta campos, serían necesarias treintalíneas de asignación. Como norma se acepta que cada variable de memoria tenga el mismonombre de campo, precedido por la letra <m>.

Con este estilo de programación tiene que preocuparse con cada nombre y saber cómo sellama exactamente cada nombre del campo del archivo para poder teclearlo.

Veamos ahora la misma tarea realizada en esta ocasión por una rutina que utiliza elconcepto <<dirigida por los datos>>.

USE Func *** Usar o abrir el archivo Func.FOR I = 1 TO FCOUNT() /*** Bucle PARA-HASTA desde 1 hasta la

cantidad total de campos en el archivo(FCOUNT – devuelve la cantidad de camposen el archivo). ***/

Var = “m”+FIELDNAME(I) /*** Con la función FIELDNAME, se toma elnombre del campo I; y se le antepone la letra“m” para que éste sea el nombre de la variableque se almacene en la variable Var ***/

&Var = &(FIELDNAME(I))/*** El uso del carácter & -ampersand- antes del




nombre Var indica al Clipper que utilice elcontenido de la variable Var como nombre devariable. Lo mismo sucede con el & antes dela función FIELDNAME que esta entreparéntesis, el cual toma el valor del campo I

***/

NEXT /*** Siguiente. (Terminación del buclePARA-HASTA) ***/

De tal manera que:

1. En el primer bucle, donde la variable I tiene el valor de 1, FIELDNAME devolverá el nombrede dicho campo, por ejemplo; Clave, y al realizar la operación “m”+”Clave” tendremos“mClave“, que será la cadena string que se almacenara en la variable Var .

2. Acto seguido, el carácter & -ampersand- en la función &(FIELDNAME(I)), le indica a Clipperque devuelva el nombre del campo I, que en el primer bucle es 1, y que lo tome como si fueraun nombre de variable o campo, siendo en nuestro caso Clave, y no como cadena de caracteres;

de la misma manera, el mismo carácter &, hace lo propio con el contenido de la variable Var ,indicándole a Clipper que tome el contenido de dicha variable, que para nuestro ejemplo es“mClave” y lo utilice como un nombre de variable, siendo mClave, la variable.

3. De ahí tendríamos que se tomaría el valor del campo Clave, por ejemplo, la cadena, “a123x” yse almacenará en la variable mClave.

4. Por último, para el resto de los campos, se realizará la misma operación de creación yasignación de variables descrita en los tres puntos anteriores.

En este ejemplo se utiliza un bucle FOR NEXT (PARA-HASTA) para crear unavariable por cada campo del archivo. Observe cómo con sólo dos líneas, todas las variables dememoria son inicializadas. Tanto si existen 5 campos o 40, estas mismas dos líneas hacen esafunción.

Inicializando las variables de esa forma no es necesario preocuparse de teclear el nombrede los campos y de las variables, evitando de esa forma los errores cometidos al teclearprogramas.

PROS Y CONTRAS.

Programación CODIGO-FIJO (HARD-CODE)

• Es más sencilla de programar.•

Es más fácil leer el programa.• El tamaño del código aumenta con el número de elementos manipulados.

10.2. – Programación Dirigida por los Datos (Data-Driven).

• Es más difícil de programar (aparentemente).• Es más difícil de leer.• El tamaño del código no aumenta con el número de elementos.




• Por su estructura, está indicada para crear procedimientos y funciones.

El ejemplo expuesto utiliza los datos de una base de datos. Si la estructura delarchivo fuera modificada, en la programación dirigida por los datos no sería necesarianinguna modificación del código, mientras que en el estilo tradicional es necesario re-escribir el código.

Si considera que en una aplicación puede haber varias situaciones como ésa, lapérdida de tiempo dedicado al mantenimiento disminuye de forma considerable.Programar en el estilo dirigido por los datos requiere siempre un estudio previo de loselementos que serán manipulados. Exige el uso efectivo de variables de memoria,matrices y otras estructuras de datos.

La mayor ventaja de ese estilo puede estar en la parametrización del estilo deprogramación y la obtención de un código eficiente y altamente profesional. Para utilizarese estilo de programación es necesario que el lector conozca muy bien los recursos deprogramación del lenguaje que se utilice y, obviamente, tener también una buena lógicade programación.

Esta técnica es normalmente adoptada por los programadores expertos. Para los

programadores que empiezan es recomendable que utilicen, para comenzar, el estilo deprogramación tradicional y después usar éste estilo.

NOTA: Sería conveniente invertir mucho tiempo elaborando funciones yprocedimientos que, una vez tecleados, economizan gran cantidad de tiempo en eldesarrollo de programas y sistemas. Así cada vez que se tenga que desarrollar algunarutina para una aplicación específica, analiza si ésta puede ser <<generalizada>>, y portanto, usada en otras aplicaciones. Muchas veces la respuesta es no. No obstante, otrasveces se puede realizar un magnífico procedimiento o función.

En el primer ejemplo mostrado usamos sólo el bucle FOR NEXT y la macrosustitución (&) de Clipper. Estos dos elementos u otros similares, aparecen

constantemente en las aplicaciones dirigidas por los datos, en éste lenguaje o cualquierotro.

Observe el programa mostrado a continuación, el cual está codificado en Clipper. Esun programa típico de introducción de datos.

Programa CP10PR01.PRG (Hard Code).

*** Programa CP10PR01.PRG Altas.* Estructura base de datos: PERSONAL.DBF* Campo Nombre Campo Tipo Tamaño Dec Indice* 1 CodEmpl Caracter 3 N* 2 NombreEmpl Caracter 30 N* 3 CodSet Caracter 1 N

* 4 CodCar Caracter 1 N* 5 FechaEnt Fecha 8 N* 6 Salario Num‚rico 9 2 N* 7 Gremio L¢gico 1 N* 8 Coment Memo 10 N** Total 64

PROCEDURE Principal() // Inicio del programa

CLEAR ALL // Elimina variables en memoria y cierra cualquier archivo abierto

IF FILE("IndCodC.NTX") // S¡ existe el archivo IndCodC.NTXUSE Personal INDEX IndCodC // Abre el archivo Personal y su ¡ndice IndCodC

ELSE // SinoUSE Personal // Abre el archivo Personal




INDEX ON CodEmpl TO IndCodC // Indexa seg£n CodEmpl Al archivo IndCodCENDIF // Fin del S¡WHILE .T. // Mientras VERDADERO (Bucle Infinito)

Clear // Limpia (la pantalla)mCodEmpl = SPACE(3) // MCodEmpl = 3 espacios (en blanco)mNombrEmpl = SPACE(30) // MNombrEmpl = 30 espacios (en blanco)mCodSet = SPACE(1) // MCodSet = 1 espacio (en blanco)mCodCar = SPACE(1) // MCodCar = 1 espacio (en blanco)mFechaEnt = CTOD("") // MFechaEnt = Convierte Cadena Nula a Fecha NulamSalario = 0 // MSalario = 0mGremio = .F. // MGremio = Falso

@ 1,1 SAY "Código Empleado o;<INTRO> para salir";GET mCodEmpl // Despliega mensaje e Introduce el valor de MCodEmpl

READ // Lee los datos del teclado despu‚s del <INTRO>IF VAL(mCodEmpl) = 0 // S¡ el valor num‚rico de MCodEmpl = 0

EXIT // Salir del MientrasENDIF // Fin del S¡SEEK mCodEmpl // Busca (el valor de) MCodEmpl (en el archivo)IF FOUND() // S¡ se encontr¢

@ 23,01 SAY "Código ya;encontrado...;Teclee <INTRO>" // Despliega mensaje

INKEY(0) // Introducir Tecla (Detiene el programa hasta que se presiona una tecla.

LOOP // Lazo (Vuelta al Mientras)ENDIF // Fin del S¡@ 3,1 SAY "Nombre:";

GET mNombrEmpl // Despliega mensaje e Introduce el valor de MNombrEmpl

@ 4,1 SAY Sector:" GET mCodSet // Despliega mensaje e Introduce el valor de MCodSet

@ 5,1 SAY "Cargo:" GET mCodCar // Despliega mensaje e Introduce el valor de MCodCar@ 6,1 SAY "Fecha:";

GET mFechaEnt // Despliega mensaje e Introduce el valor de MFechaEnt

@ 7,1 SAY "Salario:";GET mSalario // Despliega mensaje e Introduce el valor de MSalario

READ // Lee los datos del teclado despu‚s del <INTRO>Ok = ""@ 8,1 SAY "¨Datos Ok? (S/N)"; // Despliega mensaje

GET Ok PICTURE "!"; // Introduce el valor de Ok y lo convierte a mayusculas

VALID Ok $ "SN" // Restringe los valores de Ok a "S" o "N"READ // Lee los datos del teclado despu‚s del <INTRO>IF Ok = "S" // S¡ Ok = "S"

APPEND BLANK // Agrega un registro vac¡o al archivoREPLACE CodEmpl WITH mCodEmpl,; // Reemplaza (Graba el valor del campo) CodEmpl con (el valor de la variable) MCodEmpl

NombrEmpl WITH mNombrEmpl,; // (Reemplaza) NombreEmpl con mNombrEmplCodSet WITH mCodSet,; // (Reemplaza) CodSet con mCodSetCodCar WITH mCodCar,; // (Reemplaza) CodCar con mCodCarFechaEnt WITH mFechaEnt,; // (Reemplaza) FechaEnt con mFechaEntSalario WITH mSalario,; // (Reemplaza) Salario con mSalarioGremio WITH mGremio // (Reemplaza) Gremio con mGremio

ENIF // Fin del S¡END // Fin del MientrasCLOSE ALL // Cierra todos los archivos

RETURN // Fin del programa

En el programa mostrado a continuación, se crean funciones para asignar lasvariables con el contenido de los campos del archivo, para sustituir el contenido de loscampos por el contenido de las variables y para inicializar variables de memoria con elmismo tipo de dato que el de los campos.

Programa CP10PR02.PRG (Data Driven).*** Programa CP6PR01.PRG Altas.* Estructura base de datos: PERSONAL.DBF* Campo Nombre Campo Tipo Tama¤o Dec Indice* 1 CodEmpl Caracter 3 N* 2 NombreEmpl Caracter 30 N* 3 CodSet Caracter 1 N* 4 CodCar Caracter 1 N* 5 FechaEnt Fecha 8 N* 6 Salario Num‚rico 9 2 N* 7 Gremio L¢gico 1 N* 8 Coment Memo 10 N




** Total 64

PROCEDURE Principal() // Inicio del programa

CLEAR ALL // Elimina variables en memoria y cierra cualquier archivo abierto

IF FILE("IndCodC.NTX") // S¡ existe el archivo IndCodC.NTXUSE Personal INDEX IndCodC // Abre el archivo Personal y su ¡ndice IndCodC

ELSE // SinoUSE Personal // Abre el archivo PersonalINDEX ON CodEmpl TO IndCodC // Indexa seg£n CodEmpl Al archivo IndCodC

ENDIF // Fin del S¡

WHILE .T. // Mientras VERDADERO (Bucle Infinito)Clear // Limpia (la pantalla)DO Inic_Var // Llama al procedimiento de inicializaci¢n de variables

@ 1,1 SAY "Código Empleado o;<INTRO> para salir";GET mCodEmpl // Despliega mensaje e Introduce el valor de MCodEmpl

READ // Lee los datos del teclado despu‚s del <INTRO>IF VAL(mCodEmpl) = 0 // S¡ el valor num‚rico de MCodEmpl = 0

EXIT // Salir del MientrasENDIF // Fin del S¡SEEK mCodEmpl // Busca (el valor de) MCodEmpl (en el archivo)IF FOUND() // S¡ se encontr¢

@ 23,01 SAY "Código ya;encontrado...;Teclee <INTRO>" // Despliega mensaje

INKEY(0) // Introducir Tecla (Detiene el programa hasta que se presiona una tecla.

LOOP // Lazo (Vuelta al Mientras)ENDIF // Fin del S¡

@ 3,1 SAY "Nombre:";GET mNombrEmpl // Despliega mensaje e Introduce el valor de MNombrEmpl

@ 4,1 SAY Sector:" GET mCodSet // Despliega mensaje e Introduce el valor de MCodSet

@ 5,1 SAY "Cargo:" GET mCodCar // Despliega mensaje e Introduce el valor de MCodCar

@ 6,1 SAY "Fecha:";GET mFechaEnt // Despliega mensaje e Introduce el valor de MFechaEnt

@ 7,1 SAY "Salario:";GET mSalario // Despliega mensaje e Introduce el valor de MSalario

READ // Lee los datos del teclado despu‚s del <INTRO>Ok = ""@ 8,1 SAY "¨Datos Ok? (S/N)"; // Despliega mensaje

GET Ok PICTURE "!"; // Introduce el valor de Ok y lo convierte a mayusculas

VALID Ok $ "SN" // Restringe los valores de Ok a "S" o "N"READ // Lee los datos del teclado despu‚s del <INTRO>IF Ok = "S" // S¡ Ok = "S"

APPEND BLANK // Agrega un registro vac¡o al archivoDO Repl_Var // Llamada al procedimiento para grabar o reemplazar los datos en el archivo

ENIF // Fin del S¡END // Fin del MientrasCLOSE ALL // Cierra todos los archivos

RETURN // Fin del programa

PROCEDURE Inic_Var() // Inicio del procedimiento de inicializaci¢n de variables

FOR N = 1 TO FCOUNT() // Para I = 1 hasta Cantidad de camposIF TYPE(FIELD(N)) <> "M" // S¡ el tipo del campo N es diferente de "M" (Memo)

NombCampo = FIELDNAME(N) // NombCampo = Nombre del campo N NombVar = "m"+NombCampo // NombVar = "m" + Valor de NombCampo

(concatena cadenas de caracteres)PUBLIC &NombVar // Declara como p£blico el nombre de variable contenido en la variable NombVar

DO CASE // Hacer en CasoCASE TYPE(FIELD(I)) = "C" // Caso de que el tipo del campo = "C" (Caracter)

&NombVar = SPACE(LEN(&NombCampo)) // Variable en NombVar = Cantidad de espacios de la longitud del campo en NombCampo

CASE TYPE(FIELD(I)) = "N" // Caso de que el tipo del campo = "N" (Num‚rico)

&NombVar = 0 // Variable en NombVar = 0CASE TYPE(FIELD(I)) = "D" // Caso de que el tipo del campo = "D" (Fecha)

&NombVar = CTOD("") // Variable en NombVar = Nulo convertido a formato de fecha

CASE TYPE(FIELD(I)) = "L" // Caso de que el tipo del campo = "L" (L¢gico)

&NombVar = .F. // Variable en NombVar = FALSOENDCASE // Fin del Caso

ENDIF // Fin del S¡ NEXT // Siguiente (I)

RETURN // Retorna a la l¡nea siguiente de donde fue llamado el procedimiento

PROCEDURE Repl_Var() // Inicio del procedimiento de grabado o reemplazo de los valores de las variables al archivo




<< Un buen programador no usa generadores de programas.>>

¿Será cierta esta afirmación?Después de crear varios programas, comenzará a crear un modelo propio de

programación, es decir, cualquier aplicación que desarrolle tendrá algunas característicasen común con todos los demás que ya ha desarrollado. Por ejemplo, siempre colocará la

fecha en la esquina superior derecha de la pantalla, sus mensajes de error aparecensiempre en la línea 23, columna 10, y así lo demás.Y entonces, no se resistirá a la idea de obtener una copia del programa anterior

en su editor y realizar sólo algunas modificaciones para generar un nuevo programa.

10.4.2. – Ventajas de una plantilla.

1. Ahorro de tiempo.

Una plantilla puede generar un sistema completo en menos de dos minutos;bastará con suministrarle los datos específicos del nuevo sistema, pulsar <Intro> y

centenares de líneas de programa serán escritas en pocos minutos. Todo esto nos libra delos detestables errores al teclear que siempre terminamos cometiendo.

2. Modelado del código fuente.

Cada programador tiene su propia forma de programar. Ahora bien, si trabajapara una empresa que tiene su propio modelo particular para la generación de pantallas,informes u otras rutinas, tendrá que seguir ese modelo en buena parte de su programa.Imagínese el gasto que supone el mantenimiento de un programa de otro programadorque posee una forma de programar totalmente distinta a la suya.

3. Facilidad de modificación.

Si quiere cambiar un determinado elemento que afecta a todos los módulos delsistema, la modificación de la plantilla realizará todos los cambios en el sistema.

10.4.3. – Cuando utilizar una plantilla.

La creación de una plantilla requiere un análisis previo del programa que deseagenerar. Si va a crear una rutina que será específica de una única aplicación o quenecesitará modificaciones profundas para que sea utilizada en otro programa, ésa, concerteza, no será la rutina del programa ideal para crear una plantilla.

Las plantillas utilizan el concepto de programación orientada o dirigida por losdatos, es decir, son rutinas que trabajarán con objetos previamente preparados generandoel código definitivo.

10.4.4. – Generadores de Código.




En el mercado, dispone de varios programas generadores de código. Los másconocidos son el UI2 y el GENNIFER. Estos programas permiten la generación decódigos fuente en varios dialectos Dbase, C y otros lenguajes. Esos programasnormalmente disponen de plantillas listas para ser usadas, donde usted simplemente lesdebe informar de los objetos que deben actuar.

Estos programas permiten también que usted, utilizando órdenes del programa,

cree sus propias plantillas, es decir, aquellas que tengan su forma de programar.Discutiremos cómo crear plantillas con las propias órdenes de Clipper.Una plantilla está básicamente formada por textos literales y órdenes de

generación. En el CD que acompaña a ésta obra se presenta un generador de códigodesarrollado en Clipper, el cual genera un programa, también en Clipper, para elmantenimiento de una base de datos.




11. – Introducción a la Programación Orientada al Objeto.

11.1. – Introducción.

Hace años la programación se realizaba mediante el modelo lineal, es decir, losprogramas evolucionaban línea a línea sin que la descomposición modular de los mismos

tuviese la menor importancia a la hora de estructurar el código. Esta situación fue superada porel método de la programación estructurada donde la simple linealidad del código desaparecíapara dejar paso a la noción de estructura modular, descomposición top-down, etc. Hoy vivimosotra nueva revolución en las técnicas de ingeniería del software. Es lo que se ha dado en llamarla Programación Orientada a Objetos.

Pero, ¿En qué consiste esta innovación? ¿Qué es realmente un objeto?. Trataremos, conla brevedad que una corta introducción debe aportar, de responder estas cuestiones. El diseño desoftware orientado a objetos pretende ser una técnica de construcción de aplicaciones quefuncione de acorde a como lo hace la mente humana en su ubicación en la realidad. El hombreconoce mediante un proceso de abstracción en el que de lo real vamos tomando sus aspectosmás comunes para construir formas inteligibles por nuestro pensamiento, éstas son los objetos.Los objetos deben poseer un conjunto de propiedades que los definan y distingan, algo que lesde la individualidad necesaria como para que el conocimiento del hombre pueda tratar con ellos.Sólo conocemos objetos.

Los objetos son la formalización de lo real que hace la mente del hombre.

Por tanto, si la noción de objeto posee tanta importancia a la hora de explicar losmecanismos cognoscitivos del ser humano, parece lógico que una de las actividadesintelectuales del hombre, como es el diseño de software, se trate de aprovechar todo lo que estanoción pueda dar de sí.

Deberíamos también contestar a la pregunta ¿Qué se pretende obtener con laincorporación de la noción de objeto al universo informático? Fundamentalmente se deseareducir los tiempos de desarrollo. Un objeto es una parte de una aplicación totalmente terminaday transportable, de forma que pueda usarse de forma similar por otras aplicaciones. La labor deensamblar objetos se pretende como más reducida en cuanto a esfuerzo que la de desarrollarprogramas partiendo sólo de un lenguaje de programación.

Continuar con una exposición teórica de la Programación Orientada al Objeto (OOPabreviado en Inglés), resultaría larga, tediosa e inútil teniendo en cuenta la finalidad de estelibro. Situándonos en el justo contexto de una breve introducción, el tratamiento dado al tema

sólo puede ser eminentemente práctico, y ceñirse lo mas posible a la generalización delconcepto. Esa es la pretensión inicial de este capítulo, en el que por razones obvias decomodidad abreviaremos las palabras “Programación Orientada al Objeto”, sustituyéndolas porla ya conocida expresión anglosajona: OOPS.




11.2. – Vocabulario OOPS.

Cualquier tecnología, (programación, fontanería, pastelería, etc.), por regla general eineludible, requiere un vocabulario técnico propio, el cual cumple dos cometidos diferentes:

1º. Especificar de modo claro y conciso cada una de las peculiaridades e

implementaciones del proceso técnico en cuestión (Los profesionales se sirven de él para elintercambio de información).

2º. Alejar a los intrusos, aficionado y otros posibles merodeadores. Como todos sabemoslas jergas profesionales complejas e ininteligibles, crean una barrera de incomprensión entreiniciados y neófitos. Algunos profesionales (que no todos, por supuesto) tienden a refugiarse enel oscurantismo del lenguaje para encubrir su ineficiencia.

Como era de esperar OOPS no podía resultar ajeno a esta regla universal. Eso explica elincontrolado florecimiento de infinidad de palabrejas, a cuál más rara e inútil, cuya inmensamayoría son fruto de bárbaras traducciones anglosajonas. De todos modos, ya que existe ese

vocabulario (absolutamente necesario por cierto), usémoslo; pero sin renunciar a explicacionesen lenguaje llano, que son de agradecer. La experiencia indica que existen excelentesprogramadores que manifiestan su total incapacidad de entendimiento a la hora de trabajar conobjetos. En la mayoría de los casos ese aparente bloqueo es motivado por un exceso devocabulario inconexo y mal digerido.

11.3. – Conceptos básicos.

NOCIONES BASICAS.

En este apartado vamos a tratar de definir algunas cuestiones básicas de la programación

orientada a objetos20. Nos centraremos ya en definiciones técnicas olvidándonos de los aspectosmás filosóficos planteados anteriormente.

Objeto Un objeto es un conjunto de código asociado con los datos operados pordicho código. Los objetos están encapsulados. Esto supone que tanto el códigocomo los datos que contienen son inaccesibles por otros objetos. Desde estepunto de vista, un objeto es bastante similar a una función o a una subrutina (o procedimiento) en general. La diferencia fundamental estriba en la encapsulaciónde datos. En una subrutina los datos pueden ser accedidos por otra subrutina.Esto no puede suceder nunca en un objeto. (Es decir, podemos tomar copias delos datos del objeto y manipular estas copias, pero nunca podremos accesar a losdatos originales).

20 Entre otra bibliografía pueden consultarse los siguientes libros:• Rebeca Wirfs-Brocks, Brian Wilkerson y Lauren Wiener, Designing Object-Oriented, publicado por

Prentice Hall en 1990.• Peter Coad/Edward Yourdon, Object-Oriented Analysis, publicado por Prentice Hall.• Gordon Blair et al (editores), Object-Oriented Languages, System and Aplications, Pitman en 1991.




Mensaje Es el modo que tenemos de comunicarnos con un objeto. Los mensajesson enviados por un objeto y recibidos por otro. Los mensajes determinan elcomportamiento de un objeto. Por ejemplo, puedo tener un objeto que gestione lacola de impresión de mi sistema. Un mensaje para este objeto sería comienza laimpresión.(Podríamos decir que son palabras o claves que representaninstrucciones u ordenes para que se active un procedimiento o función interna

del objeto, y que con esto dicho objeto se comporte o haga lo que nosotrosdeseamos).

Método Es un algoritmo que contiene los pasos necesarios que han de ejecutarsecomo respuesta a un mensaje. Si ya dijimos que un objeto es similar a unafunción, igualmente hemos de decir ahora que un método también lo es. Yadijimos que los objetos están compuestos de código y datos, pues bien, el códigono es más que un conjunto de métodos. Algo así como un grupo de procedimientos dentro de otro principal.

Clase Una clase es un objeto que tiene como propiedad la de poder crear otros

objetos, dotándoles de una peculiar herencia. Todos los objetos de una clasereciben de ésta sus rasgos comunes. (Se puede decir que podemos obtener copiasde un objeto y agregarle nuevos métodos y mensajes, tal y como lo hacemosalgunos programadores, con los procedimientos que creamos. Los copiamos yles agregamos más parámetros y procedimientos internos.).

De lo anterior, y en mi, quizás, parco conocimiento del tema; podriamos decir (y perdóneme los programadores de alto nivel), que los objetos no son otra cosa que procedimientos o funciones que contienen otros procedimientos o funciones (llamados métodos)los cuales podemos hacer que se comporten de la manera que necesitamos a través del paso deciertos parámetros (llamados mensajes); y que, además, fueron desarrollados por otros

programadores, los cuales, para proteger su código y funcionamiento nos los entregancompilados (entiendase encapsulados), y pese a ello, podemos copiarlos y agregarles en suentorno, nuevos procedimientos (lease métodos) propios, así como nuevos pasos de parámetros(lease mensajes), para enriquecerlos. Es de notar que también dichos objetos nos devuelvenmensajes, lo que en mi idea llamaría parámetros de retorno.

Contrariamente a la creencia generalizada, la programación orientada al objeto eseminentemente práctica y sencilla. El desarrollo profesional de aplicaciones, planteado comoactividad económica plenamente rentable se han visto afectado de manera muy positiva por laaparición de OOPS. Antes de continuar, vamos a apuntar cuales son las dos líneas maestras deesas mejoras:

1º. ENCAPSULACIÓN: La definición de variables y procedimientos Locales(LOCAL) y Estáticos (STATIC), dentro de los lenguajes de programación (comoClipper o Pascal), permite procesar datos de manera mucho más autónoma ycerrada. A la hora de reutilizar código, se tiene que prestar especial atención aposibles declaraciones duplicadas de variables Privadas o Públicas, y porsupuesto a los nombres de las funciones o procedimientos (Siempre transparentedesde cualquier parte de una aplicación). Casi siempre, se inicia la búsqueda




desesperada de nuevos “apellidos” para nuestras funciones, cuando se hacenmódulos de gran tamaño. A partir de los lenguajes de programación orientados alobjeto, se permite una mayor autonomía de datos y funciones graciasprecisamente a los dos nuevos conceptos. El calificativo de Local (LOCAL) soloafecta a variables, sin embargo el de Estático (STATIC) se refiere a variables yfunciones (o procedimientos). Tal como se verá más adelante, OOPs apunta

claramente en la misma dirección.

2º. REUSABILIDAD: El sueño de todo programador responde a la imagen de unpersonaje montando aplicaciones a base de cortar trozos de código existente,pegándolos en el menor tiempo posible, y convirtiendo el resultado en algovendible (a poder ser, caro). Aunque la cruda y diaria realidad sigue alejada deesa utopía, OOPS es sin duda el mejor camino hacia ella. De momento, lasventajas de reutilizar código son básicamente dos:

• Un ahorro considerable de tiempo: Todos los procesos básicos se escribenuna sola vez.

• Una mayor seguridad ante posibles errores: Los módulos que se reutilizanhan sido probados y depurados con anterioridad en otras aplicaciones.

Prácticamente todo lo dicho hasta el momento, es sobradamente conocido por cualquierprogramador experimentado. Llegados pues a este punto, es necesario hacer un mínimo esfuerzode desmitificación, ya que muchos han exagerado hasta el punto de hablar de técnicasrevolucionarias cuando citan OOPS. ¡Nada mas lejos de la realidad! Programar en un lenguajede programación con orientación al objeto, es dar un paso mas, no un salto al vacío, como quizáalgunos temen.

De momento, las clases que traen consigo los lenguajes orientados al objeto, nospermiten realizar programas eficientes y en poco tiempo, a pesar de ello, los fabricantes nos hanahorrado la molestia de estudiar sus fuentes, ya que los mismos no aparecen en ningunadocumentación. Un experto puede imaginarse cómo funcionan, pero al programador de a piesólo le queda el consuelo de conducirlas sin poder abrir el capó y ver el motor. Lógicamenteestas clases que se pueden llamar estándar , llaman a funciones, generalmente, indocumentadasde algún enigmático módulo interno.

Debo reconocer, que todo esto nos ha ahorrado un mundo de trabajo a los viejos programadores; y a los nuevos, un sinnumero de desvelos para comprender los intrincados y torcidos caminos de la programación, en aquellos viejos lenguajes y formas de programar. 21

11.4. – Clarificando conceptos.

11.4.1. - ¿ Qué es una clase ?

El concepto de CLASE es siempre abstracto. Dentro de un programa, no

21 Nota del autor.




manipulamos clases, utilizamos objetos derivados de ellas. Se hubiesen podido llamarfamilias o especies, pero como no hemos sido invitados al bautizo, es inútil perder eltiempo discutiendo sobre el acierto del nombre. Usándolas tales como fueronpresentadas al mundo, es decir sin posibilidad de manipulación posterior, debemos tenerbien claro lo siguiente: todos los objetos de una misma clase tienen los mismos métodos,y por consiguiente responden de manera similar a los mismos requerimientos. Se

diferencian por el contenido de sus variables de instancia, es decir de sus datos.

11.4.2. - ¿ Qué es un objeto ?

Un objeto es un conjunto de datos y métodos. Se da el caso de algunas clases deobjetos que excepcionalmente no tienen métodos (la clase error por ejemplo, solocontiene datos). Debemos aclarar que los datos de un objeto han sido bautizados comovariables de instancia exportadas (Ver Guías Norton de Clipper 5.01 en castellano).Este no nos parece un nombre excesivamente acertado, pero no tenemos más remedioque usarlo a fin de compatibilizar conceptos.

Las variables de instancia pueden ser de tres tipos:

• Lectura – Escritura. En este caso estarían los campos que pueden ser leídos yasignados.

• Solo lectura. Son variables internas como por ejemplo en este caso el númerode registro, que sólo puede ser leída por nosotros, y cambia su estado enfunción de los desplazamientos del puntero a través de la base de datos.

• Ocultas (de uso interno). Son todas aquellas que no vemos, y que el objetoutiliza para sus procesos internos. Este sería el caso del número demanipulador de archivos(handle) que el Sistema Operativo asigna al área encurso, el array que contiene los nombres de los campos, etc.

Los métodos, tal como ha quedado dicho, determinan los procesos propios de suclase.

11.4.3.- El concepto de herencia.

Las clases serían muy poca cosa, si se limitaran a lo visto. Ahora por fin, vamosa ver no solo algo nuevo, sino lo mejor y mas interesante de OOPS: la herencia. Graciasa ella, podemos tomar una clase y derivar hacia otra que hereda sistemáticamente susdatos y métodos. La nueva clase puede añadir nuevos datos y métodos a la existente, osencillamente sustituir los actuales por otros.

Un simil de esto, es cuando creamos una función para mostrar datos en pantalla,y creamos una nueva función en donde llamamos la función primaria, a la cual leagregamos nuevas características funcionales.

11.4.4.- El concepto de jerarquía.

Si hemos comprendido la herencia como relación PADRE<->HIJO, poco costaráentender la posibilidad de ampliar esta estructura a más de dos niveles. En la práctica se




puede crear una estructura jerárquica de clases, donde unas heredan de otras que ya hanheredado.

11.5. – Conclusiones.11.5.1. – Lo mejor.

Esta técnica de programación nos permite agilizar nuestro trabajo, partiendo declases y objetos hechos por otros programadores, lo cual nos permite ahorrar muchotiempo de programación, y con esto se incrementa nuestra productividad. Y aunque noresuelve todas nuestras expectativas, de crear soluciones rápidas y eficientes; sinembargo nos abre un poco los ojos sobre la infinita capacidad de esta nueva técnica. Laherencia nos permite ir complicando las cosas hasta alcanzar clases muy completaspartiendo de otras llamadas básicas. Una buena estructura jerárquica es una potentísimaherramienta de desarrollo.

11.5.2. – Lo peor.

Puesto que, cualquier implementación seria, basada en herencias múltiples,requiere infinidad de punteros, y consume grandes recursos de hardware (velocidad ymemoria). Quienes han intentado desarrollar aplicaciones completas totalmente basadasen OOPs, han debido desistir ante la evidencia de un fracaso anunciado. Los constantesSwapps a disco y memoria enlentecen considerablemente los módulos, y ademáslentitud y consumo de memoria son enemigos mortales de las redes, etc. Sin embargo,los grandes avances tecnológicos en el hardware y algunos de software, nos estanpermitiendo salvar de una manera o de otra estos problemas.

11.5.3. – Posibles soluciones.

La mayoría de las desilusiones de los seres humanos son debidas a susexageradas expectativas. La programación orientada al objeto, es lo que es, y no tiene laculpa de que muchos de nosotros hayamos sido lo suficientemente insensatos como paraelevarla al rango de panacea universal. El único camino para rentabilizarla pasa por unprofundo conocimiento de su potencia y de sus debilidades. Partiendo de una basesólida, y armándonos de paciencia, podremos optimizar nuestro trabajo mezclandoprogramación convencional y OOPS, lo que sin duda nos permitirá estar preparados paralo que se nos viene encima.




12. - Introducción a la Programación dirigida por eventos.

Nadie duda ya a estas alturas, que hacerle la vida más fácil al usuario ha dejado de ser uncapricho del programador para ser una exigencia de aquél. Nuestros programas han de tener, dentro delo posible, una interfaz de usuario agradable a la vista, intuitivo y sencillo de manejar. Una de esascosas que hacen la vida más fácil al usuario es el RATON (MOUSE –en inglés-). Generalmente se

utilizan, una serie de funciones que llaman a algunos de los servicios de la interrupción 33H22,encargada del control del ratón. Con ellas podemos saber que está ocurriendo con ese animalejo quetenemos encima de la mesa pillado por el rabo, y actuar en consecuencia. Afortunadamente, en laactualidad, dichas funciones ya estan provistas en los presentes sistemas operativos, lo cual nos facilitala vida como programadores, teniendo solo que preocuparnos de activar o desactivar y programar lasacciones que se deben realizar cuando se mueva el ratón o se pulse alguno de sus botones.

El término <<programación conducida por eventos>> será algo frecuente cuandoprogramemos en Microsoft –Windows- u otro sistema operativo visual23. En la programaciónconducida por eventos, es el usuario quien decide cómo será ejecutado el programa; este tipo deprogramación difiere de la programación por lotes, donde un programa es ejecutado desde arriba haciaabajo.

¿Qué beneficios nos ofrece la programación conducida por eventos como desarrollador y comosuministrador de soluciones? Primero, hace que las aplicaciones sean más fáciles de crear y depurar,porque sólo desarrollamos pequeñas porciones. En segundo lugar, ofrece consistencia, porque se utilizaen todos los entornos de programación Windows o visuales, especialmente en aplicaciones VBA(Visual Basic para Aplicaciones). A lo largo de todo este capitulo, presentaremos ejemplos que siguenel acercamiento a la programación conducida por eventos (el mejor acercamiento para crearaplicaciones basadas en Windows, que es lo más común).

Para poder entender la diferencia entre la programación por lotes y la programación conducidapor eventos, pensemos en una aplicación como si se tratase del menú de un restaurante. Elacercamiento a la programación por lotes nos sirve cada elemento en cada página del menú en unasecuencia, uno a uno, hasta que se nos haya servido toda la lista del menú. La programación conducidapor eventos nos permite elegir únicamente los <<elementos de menú>> que queramos –es decir, sólo seejecutarán las partes de programa que queramos-. Este tipo de acercamiento habitualmente se presentaal usuario con una selección de botones de órdenes, elementos de menú y botones de barra deherramientas.

En la programación conducida por eventos, nuestra aplicación responde únicamente a lasacciones del usuario. Más adelante en este tema, cuando empecemos a estudiar los objetos más

comunes (por ejemplo, formularios e informes) en los lenguajes visuales, veremos varios eventos paracada objeto. Cada uno de los eventos para un objeto concreto cubrirá casi cualquier acción del usuarioque se pueda aplicar a ese objeto. Por ejemplo, en el entorno Windows el usuario podrá ejecutar

22 Se les llama interrupción, a algunos procedimientos que realiza el microprocesador al activarse algun bit dentro de unaregión especifica de memoria, tal como la 33H, en hexadecimal.23 Comúnmente, se les llama Visuales, a todos aquellos sistemas operativos, lenguajes de programación, o programas, quenos dan una presentación gráfica de la información. Tales como los productos de Microsoft, cuyo ejemplo ineludible es, suahora, sistema operativo Windows.




múltiples eventos utilizando únicamente el ratón, como se muestra en la siguiente tabla.




Evento de Ratón Acción del usuarioClick El usuario pulsa el botón izquierdo del ratón una sola vez.DoubleClick El usuario pulsa el botón izquierdo del ratón dos veces en una rápida sucesión.MouseMove El usuario mueve el ratón mientas que éste está sobre un objeto.MouseDown y

MouseUp

El usuario pulsa o libera un botón del ratón. Un programa en lenguaje visual puede

atrapar esto para el botón izquierdo o para el botón derecho (contexto secundario)del ratón.

NOTA: El ratón esta habitualmente configurado para ser operado con la mano derecha. En estaconfiguración, el botón de la izquierda es el botón de selección y el botón de la derecha es el botón decontexto secundario. Podremos cambiar la orientación del botón utilizando el Panel de Control, para elcaso de Microsoft Windows. Los lenguajes visuales y los programas desarrollados en estos, reciben laspropiedades de ratón de Windows. Como resultado, no se necesita ninguna codificación especial de loseventos de ratón para usuarios diestros o zurdos.

La mayoría de los usuarios en un entorno Windows utilizan el ratón para ejecutar la mayoría delas acciones. Pero para acomodarse a aquellos que prefieran utilizar el teclado, Microsoft en sus

diversos productos de programación y paqueterías, nos permite reconocer, o atrapar , eventos deteclado. La siguiente tabla lista algunos de los eventos de teclado más comunes.

Evento de teclado Acción del usuarioKeyPress El usuario pulsa una tecla del teclado y un

programa en lenguaje visual puede determinar quétecla ha sido pulsada. El evento KeyPresscapturará únicamente los caracteres ANSIestándar, tales como letras del alfabeto inglés.

KeyDown y KeyUp El usuario pulsa o libera una tecla sobre el teclado.Estos eventos de teclado pueden atrapar laspulsaciones de teclado no capturadas por el eventoKeyPress, tales como las teclas de función y las denavegación.

Observe que los nombres de los eventos de ratón y teclado son simples y realmente descriptivosdel evento. Esta intuitividad hace que la programación en el entorno de programación conducida poreventos de los lenguajes visuales resulte lógica y fácil. El desafío consiste en anticipar qué eventosestará ejecutando el usuario sobre un objeto concreto.

En el entorno de los lenguajes visuales, estaremos escribiendo la mayor parte de nuestro códigoorientado a eventos para los formularios y para los controles que estos contengan. El evento Click es el

más comúnmente usado por el objeto botón de orden, pero no sería el único permitido. Algunos de loseventos disponibles para el objeto botón de orden, en los diversos lenguajes visuales, podremosencontrar los que se listan a continuación.




Eventos.1. Al entrar2. Al salir3. Al recibir el enfoque4. Al perder el enfoque5. Al hacer click

6. Al hacer doble click7. Al bajar el mouse8. Al mover el mouse9. Al subir el mouse10. Al bajar una tecla11. Al subir una tecla12. Al presionar una tecla

Ahora es cuando comienza el desafío. Desde esta lista de ejemplo, ¿qué eventos utilizaremos? Porejemplo, la ilustración anterior lista los eventos para un objeto Botón de orden, de un lenguaje visual. Siescribiésemos código para el evento DoubleClick de un Botón de orden, puede que el usuario jamás

active el evento, debido a que el procedimiento convencional de un Botón de orden es siempre unaúnica pulsación.

¿Y cómo escribiremos código para múltiples eventos? Tendremos que conocer el orden en el que seproducen estos eventos. Por ejemplo, si tenemos código en el evento Click y en el evento DoubleClick,cuando el usuario pulse dos veces sobre el Botón de orden, el evento Click siempre se producirá antesque el evento DoubleClick, debido a que la primera pulsación de un doble click se detecta como unasola pulsación o como un evento Click. ¿Qué ocurrirá entonces si escribimos código adicional para loseventos MouseUp y MouseDown del Botón de orden? ¿Qué evento se activaría primero? Conocer elorden de los eventos es algo crucial en la programación conducida por eventos. Si no conocemos elorden en el que se producen los eventos, nuestro código nos podrá devolver unos resultadosimpredecibles.

Una forma de obtener una lista completa con explicaciones sobre el funcionamiento o el orden delos eventos, es consulta el tem <<Orden de eventos>> en la Ayuda interactiva del lenguaje visual, porejemplo VBA24 (Visual Basic para Aplicaciones).

Por ahora, creo que es todo lo que podemos tratar, a manera de una simple introducción. Si ustedquerido lector desea profundizar en esta técnica de programación que, por cierto, actualmente es muypopular y está ampliamente difundida, le recomiendo, iniciarse con Microsoft Access; que si bien, no esun lenguaje de programación, si es un potente gestor de bases de datos, que incluye el VBA, que lepermite realizar aplicaciones altamente profesionales.

24 El lenguaje Visual Basic para Aplicaciones, normalmente es suministrado por Microsoft en sus productos, tales comoMS Office.




13. - Documentación de programas.

Generalmente, un programa es parte de un proyecto mucho más grande, al cual normalmente sele conoce como sistema de información, o simplemente sistema.

Aunque es esencial la creación de diagramas de flujo para la planeación de un sistema oprograma, solo es parte de la documentación que se requiere en una compañía. En cada compañía

existen estándares propios para la documentación y las formas que se emplean varían hasta cierto puntode una compañía a otra. No importa cual sea el formato, el concepto fundamental es el deseo decomunicar información acerca de un programa o de todo un sistema en la forma mas completa yeficiente posible.

Dentro de una organización los programadores y analistas de sistemas cambian de puesto o loabandonan, pero los proyectos en que trabajan permanecen como parte del sistema de procesamiento dedatos de la compañía. Conforme se realizan modificaciones dentro de la compañía, estos sistemas yprogramas requieren revisión. Si el programa o sistema no se ha documentado, entonces lasmodificaciones necesitaran una cantidad excesiva de tiempo. Este tiempo extra se necesita paralocalizar y seguir todos los detalles del proyecto.

Dentro de la documentación básica de un sistema o programa, se deben elaborar tres tipos demanuales:

a) Manual del sistema. Dirigido al lider del proyecto de sistematización.b) Manual del programa. Dirigido al programador.c) Manual del usuario. Dirigido, como su nombre lo indica, al usuario final.

13.1.- Manual del Sistema.

El manual de un sistema siempre se desarrolla, mucho antes que los manuales de losprogramas, dado que para el desarrollo u optimización de un sistema, se requiere un trabajoprevio llamado Análisis y Diseño del Sistema. Dicho trabajo normalmente es realizado por los

llamados, propiamente, analistas de sistemas; quienes desarrollan el o los manuales del sistemay de los programas.De tal manera que se utilizan los manuales del sistema como apoyo y los manuales de

programas para entregarlos a los programadores como cuadernos de carga, en los cuales sedescriben detalladamente los programas que se deberán desarrollar.

Invariablemente los manuales de los programas, también llamados cuadernos de carga,serán complementados con información que anexará el programador.

Dependiendo de la técnica de análisis utilizada, se tendrá la estructura del o losmanuales del sistema. Una de estás técnicas, por ejemplo, incluye lo que serían tres capitulosdentro del manual del sistema, como son:

1. Análisis Previo.2. Análisis Funcional.3. Análisis Orgánico.

Sin embargo, el Análisis y Diseño de Sistemas, será otra materia interesante y digna deestudio por parte del lector25.

25 Sistemas de Información Gerencial. Autor: Ing. Domingo Olivares Barrios.




13.2. - Manual del programa.

Los elementos más comunes de documentación son:

1. Nombres de los archivos de datos, y los programas que los usan.

2. Descripción de los registros de los archivos de datos.

3. Tablas de impresión.

4. Narrativa del programa.

5. Hoja de corrida.

Cuando un programa se ha completado (escrito y probado), se separa un paquete dedocumentación. Se preparan versiones finales de los elementos antes mencionados y se agregan

los que siguen:

1. Una tabla del contenido del paquete de documentación.

2. Diagrama de flujo.

3. Un listado de programa fuente (listado del programa, según lo codifico elprogramador, producido por la "máquina"). Esta es la versión final delprograma fuente después de que se han corregido todos los errores y elprograma ha producido la salida correcta.

4. Muestras de los informes impresos producidos por el programa y, enparticular, cualesquiera formas especiales previamente impresas que puedanutilizarse al producir la salida.

5. Un diagrama de flujo del sistema puede incluirse para mostrar a que parte delsistema corresponde este programa.

13.3. - Manual del usuario.

En este caso se desarrolla un manual explicando el funcionamiento del programa, ycomo deberá usarlo el usuario. Las explicaciones deberán ser claras y sencillas, de tal maneraque sea fácil de entender, inclusive por cualquier persona que no tenga un gran conocimiento decomputación, o definitivamente desconozca el manejo de un equipo de computo.

Los manuales individuales de los programas, se integraran en un único manual delusuario, es decir, el manual del sistema.

Este manual del usuario o guía del usuario, como le llaman algunos, debe tratar de por lomenos algunos de los siguientes puntos:

• Prefacio.Con una explicación general del objetivo del sistema o programa, sus




requerimientos de hardware y software, así como las convenciones establecidasen cuanto a los tipos de letra utilizados en el manual para hacerlo más explicito.Por ejemplo, en un manual se podría establecer lo siguiente para el usuario:

Convención SignificadoNegrita En los procedimientos, indica el texto que usted escribe

Cursiva Índica un término del glosario.

Así mismo, deberá contener información acerca del lugar o persona de contactopara obtener soporte técnico.

• Introducción (o bienvenida).Con una breve descripción acerca de las facilidades del programa o sistema, obien, de las innovaciones, si es que es una versión actualizada.

• Capitulos de las opciones (uno para cada opción principal del programa).Por lo menos se deberá dedicar un capitulo a cada una de las principales

opciones del programa o sistema. Dichos capitulos y el número de éstos sedesarrollarán a criterio del equipo de trabajo que desarrolla los manuales delsistema o programa.

• Apéndices (si son necesarios).Que contendrán información adicional acerca de temas o informaciónindirectamente relacionados al programa o sistema.

• Glosario.Con definiciones de términos técnicos y conceptos.

• Índice (temático o alfabético).Obviamente con los números de página en donde se encuentra la informaciónque requiera el usuario.




S O L U C I O N E S

Como habrá podido observar, estimado lector, los capítulos previos a éste, son bastanteextensos; así que por razones de espacio y con la idea de permitir que practique en el desarrollo desoluciones o programas, aquí solo se plantean las soluciones a desarrollar, sin embargo, el desarrollo decada una de ellas, así como los códigos fuente de los programas y algunos lenguajes de programación,

se encuentran en el CD que acompaña a esta obra.Por lo que respecta a los compiladores e interpretes de los lenguajes de programación incluidos,

es conveniente y recomendable que se documente con bibliografía relativa a aquel que vaya a utilizar, yque incluya una relación descriptiva y estructurada de los comandos e instrucciones del lenguaje.

Las versiones de los lenguajes proporcionados, tal vez ya no sean tan populares ni utilizadas, sinembargo, se prestan perfectamente para iniciar una buena trayectoria a un nuevo programador.

Las soluciones propuestas para desarrollar, van incrementando su grado de dificultad y estánenfocadas para que el lector aplique algunas de las herramientas de programación aprendidas, y así mejore su comprensión al respecto.

LINEALES

1. Diseñar un programa que calcule el área de un triángulo.

2. ¿Cual es el costo por metro cuadrado de mi parcela?, si el precio es de $ 20,000.00. Las medidasson: Largo = 100 pies, Ancho = 80 pies, 1 pie = 0.305 mts.

3. Diseñar un programa que sume dos quebrados, y muestre el resultado en forma de quebrados.

4. Diseñar un programa que calcule el promedio final del nivel, el cual consta de tres materias:Introducción a la computación, Sistema Operativo y Lenguajes Algorítmicos.

5. Encontrar la media ponderada de tres puntuaciones de exámenes. Los pesos asociados son: 30 %,30 % y 40 %.

6. Calcular la edad de una persona, en una fecha determinada.

TOMAS DE DECISION

7. Diseñar un programa que diga cual de dos personas es la mayor.

8. Muchas universidades hacen que a los estudiantes del primer curso que están a punto de suspender

una asignatura se les dé un aviso. Usted ha de calcular media de las puntuaciones de tres exámenese imprimir el número de control del estudiante, la media y si el estudiante ha pasado o no. Parapasar se necesita una media de 60 puntos como mínimo. Si el estudiante ha pasado, pero conmenos de 70 de media, indicar que el o ella esta dudoso.

9. Diseñar un programa que acepte 3 números diferentes por teclado y despliegue el número mayor. Sien la entrada algún número es igual entre sí deberá ser rechazado.




10. Hacer un programa que pida tres números enteros. Si el primero es negativo, desplegar el productode los tres. Si no desplegar la suma de los tres.

11. Diseñar un programa que diga cual es el mayor de tres números.

a) Suponiendo que los tres números son iguales.

b) Suponiendo que dos o los tres pueden ser diferentes.

12. Hacer un programa que pida la temperatura y despliegue el deporte que es apropiado hacer a esatemperatura usando la siguiente tabla:

DEPORTE TEMPERATURA (GRADOS FAHRENHEIT)

Natación Temperatura > 85Tenis 70 < Temperatura <= 85Golf 32 < Temperatura <= 70

Esquí 10 < Temperatura <= 32Damas chinas Temperatura <= 10

13. Diseñar un programa que calcule el pago por consumo de energía eléctrica, según la siguiente tabla:

CONSUMO (KW/H) CUOTA POR KW/H

HASTA 15 $ 1.50LOS SIGUIENTES 60 $ 2.00MAS DE 75 $ 2.50

14. Calcular la hora de llegada a su destino de los siguientes vuelos:

VUELOS TIEMPO

Veracruz – México 35 min.Veracruz - Mérida 1 hr. 20 min.Veracruz – Xalapa 10 min.Veracruz – Monterrey 2 hr. 18 min.Veracruz – Guadalajara 4 hr. 48 min.Veracruz - Salina Cruz 2 hr. 25 min.Veracruz – Montreal 5 hr. 30 min.Veracruz – Tokio 8 hr. 40 min.Veracruz – Washington 4 hr.

CONTADOR O BUCLE FOR, WHILE O REPEAT

15. Realizar un programa que efectúe la suma de 15 números dados por teclado y despliegue elresultado.




TOMAS DE DECISION Y CONTADORES

16. Diseñar un programa que genere y despliegue los números del 1 al 100.

17. Diseñar un programa que simule el juego de ROCA - PAPEL - TIJERA. Para dos jugadores, aganar tres juegos; los empates no cuentan.

18. Diseñar un programa que nos dé el total de votos obtenidos por cada partido en las elecciones parapresidente, y cual fue el partido ganador. Los partidos participantes son: PRI, PAN y PRD.

19. Diseñar un programa que lea los resultados de los exámenes de veinticinco alumnos y nos digacuantos obtuvieron las siguientes calificaciones:

ACIERTOS CALIFICACION

95 – 100 A: EXCELENTE85 – 94 B: MUY BUENO

75 – 84 C: BUENO65 – 74 D: REGULAR0 – 64 E: MALO, REPROBADO

20. Diseñar un programa que clasifique a las personas, según su edad y sexo, y nos diga cuantasintegran cada grupo según la siguiente tabla:

EDAD GRUPO

0 – 13 niños14 – 18 adolescentes

19 – 25 jóvenes26 – 35 adultos jóvenes36 – 55 personas maduras56 en adelante personas mayores

21. Diseñar un programa que haga un examen de 10 preguntas y dé el número de buenas, el número demalas y la calificación obtenida según una escala de 0 a 100.

22. Diseñar un programa que simule un cajero automático, dando cambio en las siguientesdenominaciones:

BILLETES MONEDAS

$ 100 $ 2.00$ 50 $ 1.00$ 20 $ 0.50$ 10 $ 0.20$ 5 $ 0.10




TOMAS DE DECISION Y ACUMULADOR

23. Diseñar un programa que calcule el promedio de las ventas mensuales de un empleado (seis meses),para que de acuerdo a la siguiente tabla se pueda calcular su comisión correspondiente:

PROMEDIO <= $ 5,000 COMISION: 3 %

PROMEDIO > $ 5,000 COMISION: 5 %PROMEDIO > $ 10,000 COMISION: 8 %

24. Diseñar un programa que nos permita simular un sistema de apartado de ropa, dejando un 15 % desu costo total y a pagar en un mes.

BANDERA

25. Dada una serie de números cualesquiera, encontrar el número mayor.

BANDERA, ACUMULADOR, Y CONTADOR

26. Diseñar un programa que pida la temperatura de cada hora del día, y que encuentre la temperaturapromedio y las temperaturas más alta y más baja del día.

SALIDA POR OPCION

27. El Instituto México desea que se capturen los siguientes datos de los alumnos: Matricula, nombre,calificación 1, calificación 2.

Para calcular y desplegar sus promedios. Se debe considerar la opción de continuar.

SALIDA POR CENTINELA

28. Realice un programa para simular el proceso que realiza una caja registradora.El supermercado " Las Américas " hace un descuento del 10% a los artículos marcados con

la clave " AL79 " y un 15% a los artículos que tienen la clave " AM80 ". Desplegar el total de lacompra y aplicar centinela para finalizar.

OPERACIONES CON MATRICES

29. Diseñar un programa que solicite valores y los almacene en una matriz.

30. Diseñar un programa que solicite valores numéricos, los almacene en una matriz cuadrada, yobtenga la suma de los elementos de la diagonal principal.




APENDICE A

LIBRERIAS

NECESIDAD DE LAS LIBRERIAS.

El uso de las librerías es absolutamente necesario en la construcción de aplicaciones de gestión.El motivo fundamental es el importante ahorro de espacio de disco y de memoria que esto conlleva enla mayoría de los casos. Otro aspecto a tener en cuenta es el tiempo de programación que se gana sicada tarea que se repita, al menos una vez, a lo largo de una aplicación, se guarda en una librería y se lallama cada vez que la necesitemos, en vez de reprogramarla.

Muchas veces nos encontramos con la necesidad de realizar alguna tarea determinada y nodisponemos de ninguna función en las librerías del compilador que la realice. Si se prevé esta tarea másveces, se compila, se añade a una de nuestras librerías y cada vez que la necesitemos, enlazamosnuestros programas con ella, sin preocuparnos de nada más. El enlazador se encargará de buscarla

dentro de la librería y añadirla al ejecutable dejando las que no necesite para otra ocasión.

Si poseemos un conjunto de rutinas compiladas con las que enlazamos nuestros programas deforma habitual, estaremos añadiendo espacio innecesario a los ejecutables, a no ser que las utilicemostodas. El enlazador añade al ejecutable todo el código de los módulos compilados, los use o no,mientras que con las librerías sólo añade la parte del código que necesita.

Si poseyéramos todas nuestras rutinas compiladas por separado en módulos objeto y tuviésemosla precaución de enlazarlas una por una con nuestro programa cuando éste las necesite, estaríamoshaciendo exactamente la misma función que hace el enlazador con una librería.

CONSTRUCCION DE LIBRERIAS.

Existen varios (programas) utilitarios en el mercado para la construcción de librerías, porejemplo el programa LIB.EXE que viene junto a varios productos de Microsoft, o el TLIB de Borlandque viene junto a Turbo C. El uso de éstos y las técnicas a seguir para la construcción de librerías sonrelativamente simples.

REGLAS BÁSICAS.

Para diseñar una librería no basta con conocer bien la mecánica de funcionamiento del programaconstructor de librerías. Hace falta también seguir una serie de normas que optimicen el uso que mástarde se hará de nuestro programa. Algunas de estas normas básicas a observar son:

Código fuente Compilador Código objeto Constructor de librerías

Librería




• Hemos de procurar que las funciones estén bien documentadas, sobre todo en lo que alfuncionamiento se refiere, para que cualquiera que utilice la librería no tenga dudas a la hora deusarlas.

• Hay que intentar planificar bien los módulos de manera que al enlazarlos con el resto de laaplicación no ocupen espacio de más. Llevando esto a una situación extrema, lo mejor es que cada

función sea un módulo objeto distinto. Sin embargo, esta técnica hace crecer el tamaño de la libreríay deja un gran número de objetos desperdigados por el disco duro, por lo que a veces es mejorpensar en módulos que agrupen a varias funciones. Esto último es adecuado:

- Cuando hay un grupo de funciones que se supone que si se utiliza una, seutilizarán las demás. Por ejemplo, si usamos funciones para controlar el ratón, está claro que alemplear una que detecte la pulsación del botón derecho también usaremos otra para detectar lapulsación del botón izquierdo.

- Cuando el código de un grupo de funciones sea muy pequeño y supongaun aumento despreciable de nuestro ejecutable.

• En caso de agrupar funciones en un mismo módulo objeto es aconsejable que traten de un mismotema para mayor facilidad a la hora de localizarlas.

• No utilizar variables PRIVADAS o PUBLICAS, o sin declarar previamente, para optimizar espaciode ejecutable y memoria, y no interferir en las variables que declaren en sus aplicaciones losprogramadores que la usen.

• Declarar ESTATICAS las funciones auxiliares internas de la librería que no se usen para el resto delos programas.

• Hemos de procurar también que las funciones de nuestras librerías estén bien depuradas y pasenpruebas completamente rigurosas.

• Establecer un código de error que devuelvan las funciones cuando algo no vaya bien, por ejemplo –1. Este código no tiene por que ser el mismo para todas, pero sí tiene que ser (dentro de lo posible)del mismo tipo de dato que el que devuelve cuando su ejecución es normal.

LAS LIBRERIAS Y LOS GRUPOS DE TRABAJO.

Cuando trabajamos en equipo, y esto suele ser lo habitual, es lógico que cada programador notenga que repetir el trabajo realizado por los otros. Por ello es bueno que exista para la empresa, elgrupo de trabajo, el proyecto o al nivel que nos parezca oportuno, una librería común donde vayan aparar todas las rutinas de utilidad comunes. Es muy importante que la creación y el mantenimiento deesta librería se haga de un modo reglamentado para facilitar su buen uso y funcionamiento. Pensemos

en una empresa cualquiera (Chapuzas, S. A.) que se dedica al desarrollo de aplicaciones en Clipper.Cuenta con 8 desarrolladores distribuidos en 3 proyectos. Existe un responsable cada proyecto así comouno de todo el grupo (Director Técnico). Un modelo de la organización para la gestión de una libreríacomún podría regirse por las siguientes normas:

1. Debe haber una librería común CHAPUZAS.LIB para todos los desarrollos que la empresa lleveadelante. La responsabilidad última del uso y mantenimiento de esa librería es del DirectorTécnico. No obstante, deberá existir una Comisión de Control de Calidad encargada de la decisiónde incorporación de funciones ya desarrolladas y del planteamiento de la necesidad de nuevas




funciones. Esta comisión se reunirá con carácter semanal. Uno de sus miembros ha de ser eldesarrollador encargado de mantener físicamente la librería. En sus manos estará no solo ladocumentación de las funciones desarrolladas por otros sino también la de la creación de nuevasfunciones a petición de la Comisión de Control de Calidad.

2. Cualquier función que se incorpore a la librería debe estar documentada y probada. Ladocumentación debe constar de:

• Nombre de la función.• Fecha de creación.• Nombre del creador.• Fecha de cada modificación.• Nombre de cada modificador.• Parámetros que usa con explicación detallada de los tipos, valores y funciones de cada uno de

ellos.• Lo devuelto en caso de error.• Si maneja bases de datos, relación de las estructuras e índices.• Si llama a otras funciones de la misma u otras librerías complementarias, la especificación de la

misma.• Breve descripción de la funcionalidad que realiza.• Al menos un ejemplo de su uso.

3. Cuando cualquier equipo de trabajo necesite una rutina que considere necesaria para su aplicacióny que tenga el carácter genérico como para ser incorporada a la librería, y no pueda esperar a lareunión de control de calidad, podrá desarrollarla por sí mismo e incorporarla a su código como unmódulo OBJ. La comisión decidirá más tarde si:

• La función se incorpora a CHAPUZAS.LIB.•

La función no tiene interés general y, por tanto, no se incorpora a la librería aunque puede seguirformando parte de la aplicación.• La función puede sustituirse por otra de la librería y, por tanto, el grupo de trabajo que la maneja

debe modificar su código para eliminar la función por ellos desarrollada y adoptar la quecorresponda de la librería.




APENDICE B

PROGRAMACION SEGMENTADA

Overlays estáticos y dinámicos

En el pasado, el mayor problema con el que nos podíamos encontrar, cuando estábamosrealizando una aplicación, es que ésta no nos cupiera físicamente en la memoria de trabajo de nuestroordenador. El único modo que teníamos de solucionar este problema era proceder a los quedenominamos segmentación, programación por capas, solapes y overlays. Generalmente los overlayseran de carácter estático. Es decir, el programador los diseñaba en el momento de programar laaplicación y, de forma independiente al sistema en que la aplicación se implantara, los overlaysquedaban dimensionados hasta que el programa se reenlazaba bajo otros criterios. Actualmente muchoslenguajes solucionan este problema mediante la técnica de overlays dinámicos. Con estos elprogramador se olvida de seguir ningún criterio especial, siendo el propio sistema quien decide queparte del código se posiciona en el área de memoria principal y qué parte en el área de overlay.

Dado que los lenguajes actuales solucionan de forma automática el problema, quizá nunca tengaque usar la técnica de overlays estáticos. Sin embargo, aún algunos lenguajes y enlazadores también lopermiten, además de la estándar dinámica. En ocasiones, para integrar los módulos objetos de códigode diferentes lenguajes o para solucionar enrevesadas situaciones de gestión de memoria, quizá useoverlays estáticos. Algunos enlazadores sólo gestionan overlays dinámicos para ciertos lenguajes, porello será muy necesario que en aplicaciones grandes donde usted integre rutinas entre lenguajesdiferentes, diseñe áreas de overlays estáticos para facilitar la ubicación de las mismas. Por todo ellovamos a explicar a continuación como trabajar con este tipo de overlays.

Cuando programamos usando esta técnica, lo que hacemos es dividir nuestra memoria RAM endos o más áreas de trabajo. En la primera de ellas (área principal) se carga el módulo ejecutable y en lasáreas de solape se cargan y descargan, conforme se van usando, los diferentes módulos overlay quehayamos definido.

Los overlays estáticos permiten diversas configuraciones. La más básica es aquella que divide lamemoria de trabajo en un área principal y un área de solape. Una segunda forma es la que la divide enun área principal y varias de solape. La tercera, y última forma, es la que trabaja con un área principal yvarias de solape, teniendo alguna de éstas otros segmentos anidados. Para comprenderlo mejorsupongamos que una aplicación que posee la siguiente estructura de módulos:

PROGPRIN MODULO1

MODULO2

MODULO3 SUBMOD1

SUBMOD2




AREA PRINCIPAL

PROGPRIN

AREA DE OVERLAY

MODULO1 oMODULO2 o

MODULO3

PRIMERA FORMA SEGUNDA FORMA

AREA PRINCIPAL

PROGPRIN

AREA DE OVERLAY 1

MODULO1 oMODULO2

AREA DE OVERLAY 2

MODULO3

AREA PRINCIPAL

PROGPRIN

AREA DE OVERLAY 1

MODULO1 oMODULO2 o

TERCERA FORMA

MODULO3 con

SUBMOD1 oSUBMOD2




APENDICE C

VARIABLES DINÁMICAS.

Hasta ahora hemos manejado muchas variables, sin embargo, independientemente del tipo de

datos que contengan, éstas pueden ser estáticas o dinámicas.Una variable estática, que es la más común, existe mientras se esté ejecutando la parte delprograma en la que está declarada (bloque). Esto significa que aquellas variables declaradas en elprograma principal están siempre allí (durante la ejecución). Las variables declaradas en losprocedimientos y funciones existen desde que se llama el procedimiento hasta que se devuelve elcontrol a la rutina que hizo la llamada.

Muchos lenguajes, tal como Pascal y C, tienen un mecanismo para crear variables dinámicas.Esto significa que se puede definir un tipo en tiempo de compilación, pero realmente no crear unavariable de ese tipo hasta el tiempo de ejecución.

Estas variables dinámicas pueden crearse o destruirse en cualquier momento durante laejecución del programa. Pueden definirse de cualquier tipo simple o estructurado.

Referenciamos a una variable dinámica no por su nombre sino mediante un puntero. Un punteroes una variable que contiene la dirección (posición) de memoria de la variable dinámica a la quereferencia. Cada nueva variable dinámica creada tiene un puntero asociado para referenciarla(seleccionarla).

¿Cuándo son necesarias las variables dinámicas? Cuando necesitamos almacenar datos en unavariable de tipo arreglo, pero con la incertidumbre del número de elementos a manejar; por ejemplo, sideseamos almacenar una lista de alumnos en un arreglo, sería complicado definir un arreglo estático, siconsideramos que la cantidad de alumnos por grupo es variable.

¿Qué podemos hacer si no sabemos cuántas componentes necesitaremos? Podemos siempre daruna longitud y preveer en el programa que pueda ocurrir un error al tratar de almacenar datos cuando elarreglo está lleno. ¿Qué hacemos si queremos que una lista de componentes esté almacenada de una

forma ordenada? Haremos algoritmos para ordenar arreglos. ¿Cómo insertar o suprimir unacomponente? La inserción o supresión de componentes de una arreglo supone el desplazar parte delarreglo una componente en una u otra dirección. Si la lista (arreglo) es muy larga, la inserción osupresión de componentes necesitará una cantidad significativa de tiempo.

Podemos usar variables dinámicas para evitar estos problemas de las variables estáticas talescomo el arreglo. Podemos crear nuevas componentes para nuestra lista sólo cuando se necesiten,usando variables dinámicas como componentes. Haciendo que cada componente contenga el enlace opuntero a la siguiente componente de la lista, podemos crear una estructura de datos dinámica que seexpande o contrae conforme se ejecuta el programa.




No tenemos que saber de entrada cómo de grande será la lista. Ahora la única limitación es la cantidadde memoria disponible. Podemos cambiar fácilmente el orden de los componentes cambiando sólo losvalores de los punteros.

La inserción y supresión de componentes son más fáciles y más rápidas; simplemente hay quecambiar uno o dos valores de los punteros.

Podemos usar variables dinámicas y punteros para crear listas y estructuras de datos más

complejas que pueden expandirse y contraerse durante la ejecución del programa. Estas estructuras dedatos son extremadamente flexibles, permitiendo una más fácil inserción y supresión de lascomponentes.

ORDENACION

INSERCION

SUPRESION

MANIPULACIÓN DE UNA ESTRUCTURA DE DATOS DINAMICA




PUNTEROS Y LISTAS ENLAZADAS.

PUNTEROS

Las variables dinámicas no son referenciadas mediante el nombre sino mediante un puntero. Eltipo puntero (pointer) es un tipo de datos predefinido en algunos lenguajes de programación.

Una variable referenciada, es una variable accedida no por su nombre sino por una variablepuntero; una variable dinámica.

Para crear una variable referenciada se usa, en Pascal por ejemplo, el procedimiento estándarNEW.

NEW(P) – Crea una variable del tipo referenciado por el puntero P y almacena un puntero a la nuevavariable P.

Las sentenciasNEW(Ptr1);

NEW(Ptr2);NEW(Ptr3);

dejan en Ptr1, Ptr2 y Ptr3 las direcciones a cada una de las variables referenciadas creadas.

¿Cómo accedemos a las nuevas variables creadas? Las variables punteros seguidas de ^, para elcaso del Pascal, nos dan la variable a la que apunta. Para las variables referenciadas creadas antes, sonválidas estas asignaciones, en el caso del Pascal:

Ptr1^:= 18;Ptr2^:=ROJO;Ptr3^:=TRUE

El valor de un puntero es un entero en la mayoría de las computadoras, ya que las posiciones dememoria son direcciones en el rango de cero hasta el tamaño de la memoria. Sin embargo, un tipopuntero no es un tipo entero. Es de notar que el Pascal es un lenguaje fuertemente tipeado. No podemosasignar un valor entero a un puntero. Ni siquiera podemos asignar Ptr1, Ptr2 y Ptr3 unos a otros, puestoque no apuntan a variables del mismo tipo. (Podemos asignar punteros del mismo tipo unos a otros.)No está previsto imprimir un valor puntero.

18

Ptr1

ROJO

TRUE

Ptr2

Ptr3

18

ROJO

TRUE

Ptr1

Ptr2

Ptr3




La siguiente figura muestra un puntero y la variable referenciada por él.

1432

18

Los punteros son importantes para crear estructuras de datos dinámicas. Puesto que debemos teneralguna forma de enlazar cada componente con la siguiente de la estructura, cada componente debecontener un enlace o puntero que apunte a la siguiente componente de la estructura. El registro es idealcomo componente de una estructura de datos dinámica. Puede contener campos de diferentes tipos con

el puntero siendo uno de ellos. Por ejemplo, en Pascal tendríamos:

TYPE TipoPtr = ^Persona; (* Un puntero a un registro del tipo persona *)Persona = RECORDNombre : PACKED ARRAY[1..20] OF CHAR;Siguiente : TipoPtr (* Un puntero al siguiente elemento de la lista *)

END; (* RECORD *)

Para definir una variable dinámica se describe lo que esa variable puede ser en la sección dedeclaración de tipos de datos del lenguaje. En la sección de declaración de variables se declara unavariable del tipo puntero a una variable de ese tipo. Cuando se necesite una de las variablesreferenciadas, se usa el procedimiento de creación de variables puntero (NEW para Pascal), en lasección de declaración de variables.

Observe que la definición de TipoPtr incluye al identificador Persona el cual aún no estádefinido. En la definición de un tipo puntero debe usarse un identificador de tipo. Este identificador detipo es una excepción en la regla general de que los identificadores deben declararse antes de que seusen. Esto nos permite definir un puntero a un objeto (variable referenciada) antes de definir el propioobjeto.

No existe ninguna variable del tipo Persona antes del cuerpo del programa. Para obtener unavariable del tipo Persona, se llama al procedimiento (NEW) de creación de punteros, durante el tiempode ejecución. Al volver de dicho procedimiento, se ha creado una variable registro del tipo Persona. La

información sobre dónde está posicionada la variable se deja en la variable puntero Ptr . Observe quelos campos de esta nueva variable están indefinidos.

La variable puntero Ptr1contiene la dirección dePtr1^ (la variablereferenciada)

1432 es la dirección de memoriade la variable referenciada Ptr1^

Ptr Variable del tipo PERSONA

?

Nombre




Esto se llama asignación dinámica de memoria porque las variables del tipo Persona se creancuando se necesitan en el programa.

El uso repetido del procedimiento (NEW) de creación de punteros nos permite generar variablesadicionales de este tipo. Entre estas llamadas a dicho procedimiento, enlazamos la variable que hemosobtenido en la llamada anterior para formar una estructura de datos dinámica.

Los punteros siempre referencian a variables sin nombre. Los propios punteros pueden tenernombre o no. Es decir, podemos crear una cadena de punteros sin nombre dinámicamente, con cada unoapuntando al que le sigue. Sin embargo, tal cadena debe tener al menos una variable puntero connombre apuntando al primer elemento de la cadena o no tendremos ninguna forma de acceder a ella. Esparecido a esos juegos de las fiestas en los que las gentes tienen que seguir una cadena de pistas, cadapista dice dónde se encuentra la siguiente y así hasta que se encuentra un premio. Si no se da laposición de la primera pista entonces no hay forma de empezar la cadena. Si la posición dadacorresponde a una pista de la mitad de la cadena, no hay forma de encontrar las pistas anteriores.

Cuando una variable dinámica tal como Ptr no se necesita más, el procedimiento de liberaciónde memoria (DISPOSE par Pascal) la devolverá, de forma que la memoria ocupada por ella puedaasignarse más adelante si se necesita. Esto se llama devolución a la memoria disponible.

Cualquier operación que sea válida sobre una variable con nombre de un cierto tipo lo es sobreuna variable dinámica de este tipo. Sin embargo, sólo las asignaciones y las comparaciones para ver sison iguales, son operaciones válidas con las variables punteros. Por ejemplo, dadas estas operaciones enPascal:

TYPE Rango = 1..25;VAR PtrA, PtrB : ^Rango;

Podemos hacer las siguientes operaciones:

NEW(PtrA); (* Crea una variable dinámica *)NEW(PtrB); (* Crea una variable dinámica *)READ(PtrA^, PtrB^); (* Almacena valores capturados en estas variables dinámicas *)WRITELN(‘La suma de ‘, PtrA^:1, ‘ Y ‘, (* Despliega la suma de *)PtrB^:1, ‘ ES ‘, PtrA^+ PtrB^:1) (* estas variables dinámicas *)

Observe que PtrA^ + PtrB^ es válido porque hemos añadido los contenidos de las dos variablesdel tipo Rango apuntadas por PtrA y PtrB. PtrA + PtrB no sería válido porque no se pueden sumarvariables punteros. Podemos sólo asignar punteros del mismo tipo o compararlos para ver si son iguales

MEMORIA

Ptr




o desiguales. En otras palabras, podemos hacer que dos punteros referencien a la misma variable opodemos comparar dos punteros para ver si apuntan o no a la misma variable. En la siguiente figuracomparamos las direcciones contenidas en las variables punteros, no los contenidos de estas direccionesde memoria.

Usaremos la asignación y comparación de punteros en la creación y uso de estructuras de datosdinámicas.

LISTAS ENLAZADAS

Una de las estructuras de datos que podemos construir usando variables dinámicas y punteros seconoce como lista enlazada. De hecho, es la estructura enlazada que hemos descrito en la primera partede este apéndice.

Puesto que sólo podemos acceder a las variables dinámicas mediante un puntero (^), ¿tenemos

que tener tantas variables punteros como variables dinámicas haya (componentes) en la lista? ¿Cuál esla ventaja de esto? Ninguna, si la usamos así. Sin embargo, lo que podemos hacer es formar una cadenade estas variables. Apuntamos a la primera de la lista y luego almacenamos dentro de cada una unpuntero a la siguiente. Es decir, cada variable dinámica será un registro con un campo conteniendo unpuntero al siguiente.

El siguiente segmento de código en Pascal, crea una lista de cinco variables del tipo AlgunRegistro, todas enlazadas juntas.

TYPE Puntero = ^AlgunRegistro;AlgunRegistro = RECORD

(* Otros campos *)Siguiente : Puntero

END; (* RECORD *)

VAR List, (* El puntero a la primera componente de la lista *)Ptr1, (* El puntero a la última compnente de la lista *)Ptr2 : Puntero; (* El puntero a la componente más nueva *)Vcb : Integer;

15

PtrA

28

15

PtrB

28

PtrA = PtrB evalúa a FALSOPtrA <> PtrB evalua a VERDADERO

Resultado de la asignación PtrA := PtrBAhora PtrA = PtrB evalúa a VERDADERO

PtrA <> PtrB evalúa a FALSO

(A)(B)




BEGINNEW(List);Ptr1 := List;For Vcb := 1 TO 4 DO

BEGINNEW(Ptr2);

Ptr1^.Siguiente := Ptr2;Ptr1 := Ptr2END;

Ptr1^.Siguiente := NILEND.

¿Cómo crea este código una lista? ¿Por qué necesitamos tres punteros? Hagamos un recorrido lógicodel código y veamos como funciona este algoritmo.

NEW(List);

Se crea una variable del tipo AlgunRegistro. El puntero se deja en List. List permanecerá sincambiar como el puntero al primero. List se llama el puntero externo a la lista.

Ptr1 := List;

Nuestro algoritmo obtiene una nueva variable y almacena su puntero en el campo Siguiente dela última componente de la lista. Por tanto, necesitamos guardar la última componente para poderasignarle a su campo puntero la variable que se cree.

List Ptr1 Ptr2

LISTA ENLAZADA

List

List Ptr1




For Vcb := 1 TO 4 DO

Se utiliza un bucle controlado por contador para sumar las 4 últimas componentes de la lista.

BEGINNEW(Ptr2);

Se crea otra variable del tipo AlgunRegistro con Ptr2 apuntando a ella.

Ptr1^.Siguiente := Ptr2;

El puntero a la variable creada se almacena en el campo Siguiente de la última componente de lalista.

Ptr1 := Ptr2

Ptr1 está de nuevo apuntando a la última componente de la lista.




Primera vuelta del bucle FOR.

La secuencia de diagramas siguiente, muestra cómo se añade una componente a la lista (esdecir, lo que sucede en el cuerpo del bucle FOR).

Y así sucesivamente, hasta crear 4 elementos en la lista. Y al salir del bucle se ejecutará lo siguiente:

END;Ptr1^.Siguiente := NIL




Al campo Siguiente de la última componente de la lista se le asigna el valor especial NIL (Nulo).

Observe que asignamos el valor NIL al último puntero de la lista. NIL es una palabra reservadaque puede asignarse a cualquier variable puntero. Significa que el puntero no apunta a nada. Suimportancia está ligada con el hecho de que podemos comparar el campo enlace de cada componente dela lista con NIL para ver cuándo se alcanza el final de la lista. Esta técnica se usa cuando se busca en

(se recorre) la lista.




IMPRESIÓN DE UNA LISTA ENLAZADA

Para imprimir (o acceder en orden secuencial) a los elementos de una lista enlazada, comenzaremosimprimiendo los valores del primer elemento, luego los del segundo, luego los del tercero y así hastaque alcancemos el final de la lista. Esto nos sugiere algún tipo de bucle en el que la expresión sea“mientras no sea el final de la lista”. Lo que tenemos que hacer es usar un puntero como la variable de

control del bucle. Para incrementarlo en cada paso, pondremos el campo Siguiente del registro actual.El final de la condición del bucle será que el puntero sea igual a NIL.

PROCEDURE Imprimir(List: Puntero); (* List es el puntero externo *)

VAR P: Puntero;

BEGINP := List;WHILE P <> NIL DO

BEGIN

WRITE(P^.Info);P := P^.Siguiente

ENDEND;

Este procedimiento funcionará incluso para una lista vacía ( Lista = NIL).




INSERCIÓN EN UNA LISTA ENLAZADA.

Un procedimiento que inserte en una lista enlazada debe tener dos parámetros: una listaenlazada y el elemento que va a insertarse. “En” una lista enlazada es ambiguo. Podría significarinsertar un elemento como el primer elemento de la lista o insertar un elemento en su lugar de acuerdocon alguna ordenación (alfabética o numérica). Examinemos estas dos situaciones separadamente.

Para insertar un elemento como el primero de una lista enlazada hay que hacer dos pasos: crearel nuevo elemento y ponerlo como el primero.




PROCEDURE Meter(VAR List: Puntero; Elemento: Integer);(* Procedimiento para insertar un elemento en la cabeza de la lista *)

VAR P: Puntero;

BEGIN

NEW(P);P^.Info := Elemento; (* asigna el valor de Elemento al nuevo elemento *)P^.Siguiente := List; (* enlaza al anterior primer elemento *)List := P (* el puntero externo apunta al nuevo elemento *)

END;

Observe que antes de llamar a Meter la primera vez, deberá haberse puesto Lista a NIL.

Para insertar un elemento en su lugar se necesita del paso adicional de encontrar su lugar.Tendremos que ir recorriendo todos los nodos (elementos de la lista) hasta que encontremos uno cuyocampo Info sea mayor que el valor que quermos insertar. (Esto supone mantener una lista ordenada en

orden creciente). El siguiente fragmento hará esta búsqueda.

Ptr := List;WHILE (Ptr^.Info < Elemento) DO

Ptr := Ptr^.Siguiente;

Si el nodo referenciado por Ptr es el que tiene un valor mayor que el que queremos insertar,entonces el nuevo elemento debe insertarse delante de ese nodo. Esto causa un problema; necesitamosconocer el nodo anterior de la lista para poder cambiar su campo puntero y que apunte al nuevoelemento. Tendremos que mantener dos punteros conforme recorremos la lista: el puntero al nodoactual y el puntero al nodo anterior. El siguiente fragmento hará esto.

Ptr := List;

WHILE (Ptr^.Info < Elemento DOBEGINAnterior := Ptr;Ptr := Ptr^.Siguiente

END




Esto tiene en cuenta el caso en el que el elemento va en la mitad de la lista. ¿Qué sucede en losdos casos extremos, cuando el nuevo elemento debe insertarse por el principio o al final? Si el nuevoelemento es el primero, podemos usar el mismo algoritmo que acabamos de escribir. Si es el últimotendremos problemas, porque la comparación

Ptr^.Info < Elemento

Causa un error al final de la lista. El tratar de acceder a Ptr^ cuando Ptr es NIL causará un erroren tiempo de ejecución.

Nuestro bucle tendrá que tener dos condiciones. Nuestra primera idea podría ser usar

(Ptr <> NIL) AND (Ptr^.Info < Elemento)

pero esto no funcionará. La mayoría de los compiladores de Pascal evaluarán ambas comparaciones dela expresión incluso si la evaluación del primero da FALSE. Esto es, el que Ptr sea NIL no hará que sedeje de evaluar Ptr^.Info. Tendremos que usar nuestra vieja amiga la variable Booleana Encontrado. Lainicializaremos a FALSE y la cambiaremos a TRUE cuando encontremos el lugar en el que hay queinsertar el elemento.

(Ptr <> NIL) AND NOT Insertar

Esto tiene en cuenta los tres casos: la inserción por el principio, por la mitad y al final. El siguienteprocedimiento representa nuestro algoritmo de inserción general.

PROCEDURE Insertar (VAR List: Puntero; Elemento: INTEGER);(* Procedimiento para insertar un elemento en una lista manteniéndola ordenada *)

VAR Encontrado: BOOLEAN;P, Ptr, Anterior: Puntero; (* puntero local *)

BEGINNEW(P);P^.Info := Elemento; (* obtiene un nuevo nodo *)Anterior := NIL;Ptr := List;Encontrado := False;WHILE (Ptr <> NIL) AND NOT Encontrado DO




IF Ptr^.Info > ElementoTHEN

Encontrado := TRUEELSE

BEGINAnterior := Ptr;

Ptr := Ptr^.SiguienteEND;P^.Siguiente := Ptr;IF Anterior = NIL

THENList := P

ELSEAnterior^. Siguiente := P

END;

Observe dos cosas en este procedimiento. La primera es que el parámetro List tiene que ser un

parámetro VAR (por variable) para el caso en el que el nuevo elemento se inserta como el primerelemento. La segunda cosa es que funcionará para campos Info de cualquier tipo escalar sin más quecambiar el tipo de Elemento.




SUPRESIÓN EN UNA LISTA ENLAZADA

Para suprimir un nodo de una lista enlazada, debemos conocer qué nodo se va a suprimir. Estopuede especificarse como el i-ésimo nodo o buscando un nodo con un cierto campo Info.Examinaremos las dos supresiones: la supresión del primer nodo y la supresión de un nodo con uncampo Info determinado.

El quitar el primer nodo es simétrico a insertar un elemento como el primer nodo. El valor delcampo Info del primer nodo quitado de una lista se devolverá como un parámetro de salida.




PROCEDURE Sacar (VAR List: Puntero; VAR Elemento: INTEGER);(* Procedimiento para quitar el primer elemento de una lista*)

VAR P: Puntero;

BEGIN

P := List; (* guarda List para devolverlo a la memoria disponible *)Elemento := List^.Info;List := List^.Siguiente;DISPOSE(P) (* envia P^para que pueda usarse de nuevo *)

END;

Para suprimir un nodo cuyo campo Info tiene un cierto valor se hace de una forma muy similar alprocedimiento Insertar . La diferencia es que aquí buscamos un valor igual al nuestro, no un valormayor que el de nuestro elemento.




PROCEDURE Suprimir (VAR List: Puntero; Elemento: INTEGER);

VAR P, Ptr: Puntero;

BEGINIF Elemento = List^.Info

THEN List := List^.Siguiente (* se suprime el primer elemento *)ELSE

BEGINPtr := List;WHILE Ptr^.Siguiente^.Info <> Elemento DO

Ptr := Ptr^.Siguiente;P := Ptr^.Siguiente;Ptr^.Siguiente := Ptr^.Siguiente^.Siguiente;DISPOSE(P) (* devuelve P^ a la memoria disponible *)

END

END;

Observe que este procedimiento evita tener que llevar un puntero atrasado usandoPtr^.Siguiente^.Info y Ptr^.Siguiente^.Siguiente. Esto funciona inclusive si P^. Siguiente^.Siguiente esNIL. Sin embargo, si no se encuentra un elemento igual, se producirá un error en tiempo de ejecucióncuando P^.Siguiente es NIL.

Las expresiones con punteros pueden ser muy complejas. Veamos ahora algunas expresionescon punteros.

P, Q y R apuntan a los nodos de una lista. Para accedere a los campos de los nodos, se usa P, Q y R. Compruebe que las siguientes equivalencias son verdad.

P^.Siguiente = QP^.Siguiente^= Q^

P^.Siguiente^.Siguiente = R

P^.Siguiente^.Siguiente^= R^Q^.Siguiente = RQ^.Siguiente^ = R^

Recuerde la semántica de la sentencia de asignación:

P := Q asigna el valor del puntero Q al puntero P.P^ := Q^ asigna el valor de la variable referenciada por Q a la variable referenciada por P.




Para estas variables

La asignación

P^ := Q^

Da

Ahora los dos punteros P y Q apuntan cada uno a una variable diferente que contiene un GATO. Sinembargo, la asignación

P := Q

Daria como resultado

La variable que contiene Perro está aún allí pero P no apunta a ella. De hecho, a menos que el pobreviejo Perro pueda ser accedido de otra forma –otro puntero que le apunte- está perdido para siempre.Sigue estando en memoria, pero no hay forma de alcanzarlo, para usarlo o para mandarlo a la memoriadisponible y que pueda usarse de nuevo.




PILAS, COLAS, COLAS DOBLES, ÁRBOLES BINARIOS.

Además de las listas enlazadas hay otras muchas estructuras de datos dinámicas que se puedenconstruir. Puesto que esto no es un texto sobre estructuras de datos, describire brevemente algunas deellas sin usarlas en programas muestras.

PILAS

¿Ha reparado en los divertidos nombres de procedimientos Meter (Push) y Sacar (Pop) de lasección sobre manejo de listas enlazadas? Esos nombres se utilizan en la terminología sobre pilas.

Una pila se define como una estructura de datos dinámica en la que se accede sólo por unextremo. Se puede insertar un elemento como el primero (Meter) y suprimir el primero (Sacar).

Esta estructura de datos modela muchas cosas de la vida real. Se le suele llamar LIFO (Last-In-First-Out) que significa que el último en entrar es el primero en salir. Una pila de datos o bandejas enuna cafetería o panadería tienen esta propiedad. Usted puede tomar sólo el plato de encima. Cuando lohace, el que estaba debajo queda encima y la siguiente persona puede tomarlo.

Las latas de conservas en el estante de su supermercado tiene esta propiedad. Cuando usted

toma la primera lata de una fila, está tomando la última lata que se puso en esa fila.El conjunto de diagramas de la figura que se muestra a continuación ilustra lo que sucede

cuando se mete un elemento en una determinada pila y luego se saca de la pila. Por razones obvias, elpuntero que apunta a la cabeza o tope de la pila se llama frecuentemente Tope.




Las pilas son extremadamente útiles en informática. Si se quiere imprimir una línea decaracteres en orden inverso se podría hacer lo siguiente:

Tope := NIL;WHILE NOT EOLN DO

BEGIN

READ(Ch);Meter(Tope, Ch)END;

WHILE Tope <> NIL DOBEGIN

Sacar(Tope,Ch);WRITE(Ch)

END

El último carácter leído debe ser el primer carácter que se imprima.

COLAS y COLAS DOBLES

Una cola es una estructura de datos dinámica en la que los elementos se introducen por unextremo y se suprimen o sacan por el otro. Se le suele llamar a esto FIFO (First-In-First-Out)significando que el primero en entrar es el primero en salir. Esto se parece a una cola de espera en unbanco o supermercado. Por ello, las colas se utilizan para simular este tipo de situación.

Mientras que la terminología usada en la literatura anglosajona para referirse a la inserción ysupresión en pilas es estándar (Push, Pop), no existe tal estandarización con las colas. La operación deinsertar por el final tiene muchos nombres en la literatura: Insert (Insertar), Enter (Introducir) y Enq(Intc) son tres nombres muy utilizados. Correspondientemente la operación de suprimir del frente ocabeza se le llama Delete (Suprimir), Remove (Quitar) y Deq (Supc). Para llamar a nuestrosprocedimientos elegimos Intc y Supc. Puesto que se accederá por los dos extremos, necesitaremos dospunteros externos: Frente y Final.

Para insertar un elemento por el Final debemos considerar dos casos: cuando la cola esta vacía ycuando tiene al menos un elemento. Si la cola está vacia (Final = NIL) entonces debemos poner losdos punteros Final y Frente apuntando al elemento que se ha introducido en la cola. Si existe ya almenos un elemento en la cola, debemos insertar el nuevo elemento a continuación de Final^ y redefinirFinal para que apunte al nuevo elemento.

Para los dos procedimientos siguientes usaremos las siguientes declaraciones.

TYPE PtrNodo = ^TipoNodo;




TipoNodo = RECORDElemento: INTEGER;Siguiente: PtrNodo

END; (* RECORD *)

VAR Nodo: TipoNodo;

Frente, Final: PtrNodo;Num: Integer;

PROCEDURE Intc(VAR Frente, Final: PtrNodo; Num: INTEGER);(* Procedimiento para insertar un elemento al final de una cola *)

VAR Ptr: PtrNodo;

BEGINNEW(Ptr);Ptr^.Elemento := Num;

Ptr^.Siguiente := NIL;IF Final = NILTHEN

BEGINFinal := Ptr;Frente := Ptr

ENDELSE

BEGINFinal^.Siguiente := Ptr;Final := Ptr

ENDEND;

El suprimir un elemento del frente o cabeza es realmente igual que sacar de una pila. De hecho,podemos usar el procedimiento Sacar . La única cosa adicional que hay que hacer es comprobar si lacola queda vacía después de quitar el elemento. Si queda vacía, debe ponerse Final a NIL.

PROCEDURE Supc(VAR Frente, Final: PtrNodo;VAR Elemento: Integer);(* Procedimiento para quitar un elemento del frente de una cola *)

BEGINSacar(Frente, Elemento);IF Frente = NIL

THEN Final := NILEND;




Hay otras formas de implementar las pilas y las colas, pero puesto que estas estructuras varíanen tamaño durante el tiempo de ejecución, se implementan frecuentemente como listas enlazadas talcomo lo he descrito aquí.

Para el caso de las colas dobles, la lógica a aplicar es la de Insertar o Suprimir por ambos ladosde la lista enlazada. Es decir, el frente y final pueden ser intercambiados, de tal manera que cambia elsentido de la cola, y el frente pasa a ser final y el final a ser el frente. Para ello se requiere que la

estructura elemento cuente con dos punteros.




ARBOLES BINARIOS

El concepto de lista enlazada puede extenderse a estructuras que contienen nodos con más de uncampo puntero. Una de estas estructuras se conoce como árbol. El diagrama mostrado a continuación sellama arbol binario, cada nodo tiene como máximo dos descendientes.

El árbol se referencia mediante un puntero externo al nodo especial llamado raíz. La raíz tienedos punteros: uno a su hijo izquierdo y otro a su hijo derecho. Cada hijo tiene a su vez dos punteros:uno a su hijo izquierdo y otro a su hijo derecho.

Los árboles binarios de búsqueda son árboles que tienen la propiedad de que la información decualquier nodo es mayor que la información de cualquier nodo de su hijo izquierdo y de cualquier nodode sus hijos, y menor que la información de su hijo derecho y cualquier nodo de sus hijos.

El árbol anterior es un ejemplo de árbol binario de búsqueda. La razón de su utilidad está en que

si se busca un cierto número, se puede saber después de una comparación en qué mitad del árbol está.Con otra comparación se puede saber en qué mitad de esa mitad estaría. Así se continúa hasta que seencuentre el elemento, o se sepa que no está en el árbol.

Probemos con el número 50.




Veamos ahora para el 18, un número que no está en el árbol.

El hijo izquierdo de 19 es NIL por lo que el 18 no está en el árbol. No sólo sabemos que no estáallí, sino que si queremos insertarlo, estamos en el lugar en el que se insertaría.



BIBLIOGRAFIA

Curso de Programación en Clipper 5.Grupo EIDOS. Vladimir Algara, Francisco Marín, Antonio Quirós, Antonio Torres, Helio Yago.De la edición RA-MA. Editorial Adison-Wesley Iberoamericana.

Librerías en Clipper 5

LenguajesAlgoritmicosExcelente

Documents

Transcript of LenguajesAlgoritmicosExcelente