Está en la página 1de 39

Centro de Bachillerato Tecnologico Industrial y de Servicios No.

102

PRINCIPIOS DE PROGRAMACION

Lenguaje C++”

LIA. Disela Pacheco Hernandez

Lucero Castillo Marinero

20 de mayo del 2011

CONTENIDO
1.-Uso del editor y compilador
Trace into (ejecución línea por línea) (F/).................................................................... Step over (ejecución por subrutinas o funciones ) (F8)............................................... Program reset (interrumpir la ejecución paso a paso) (Ctrl-F2).................................. Inspect (Inspeccionar variables) (Alt-F4)..................................................................... Evaluate/Modify (Ctrl-F4)…………………………………………………………………... Add watch (Ctrl-F7)...................................................................................................... Toggle breakpoint (Ctrl-F8)..........................................................................................
Pag

4 4 5 5 6 7 8

2.- Configuración del compilador

Modelos de memoria................................................................................................... 9 Directorios.................................................................................................................... 10 Guardar configuración................................................................................................. 11

3.- Subrutinas
Procedimientos............................................................................................................ Funciones.................................................................................................................... Limitaciones de return()............................................................................................... Variables locales y globales........................................................................................ Usando argumentos para pasar datos a subrutinas .................................................... Recibiendo un valor de una función............................................................................ Paso de argumentos por referencia............................................................................ Compilación condicional.............................................................................................. Encabezados creados por el programador (archivos *.h)...........................................

12 12 12 13 13 13 14 16 18 19 20 20 21 23 28 28 29 30 31

4.- Uso de los recursos del sistema
Registros de la CPU.................................................................................................... Interrupciones.............................................................................................................. Función int86()............................................................................................................. Desapareciendo el cursor............................................................................................ Aplicaciones usando el mouse....................................................................................

5.- Graficación
Resolución................................................................................................................... Inicializar el mo nitor en modo gráfico.......................................................................... Uso de coordenadas.................................................................................................... Líneas, figuras geométricas, colores y rellenos.......................................................... Programa fuente con los escudos del Tec y de ISC...................................................

Archivar y cargar una imagen...................................................................................... 35

BIBLIOGRAFÍA............................................................................................................ 39

si en el código se encuentra el llamado a una subrutina. pero a diferencia del “Trace into” no lo hace línea por línea. La herramienta “Trace into” ejecuta paso a paso un programa.1) contiene varias herramientas para ejecutar programas paso a paso. la ejecuta completamente sin llamarla 4 . poder observar los valores de variables en tiempo real.1. sino por subrutinas o funciones. Para lograr esto. Fig. sólo basta oprimir la tecla F7 cada vez que se requiera ejecutar una línea de código. Por ello es indispensable saber ejecutar los programas paso a paso... Step over (ejecución por subrutinas o funciones) (F8) Esta herramienta también ejecuta paso a paso un programa.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero 1.Ventana de ejecución de programas. línea por línea de código. A continuación se muestran las herramientas que presenta Turbo C++ para esto. es decir. 1. 1. Trace into (ejecución línea por línea) (F7) La ventana de Run (ejecución) (Fig. Un aspecto muy importante es la depuración de los programas para identificar fácilmente los errores o las áreas sujetas a optimización. por bloques. monitorear variables e incluso alterar sus valores en tiempo de ejecución para realizar las pruebas a dichos programas. es decir.USO DEL EDITOR Y COMPILADOR Para codificar mejores programas es recomendable utilizar y aprovechar al máximo las herramientas que proporciona el editor y el compilador.

1.Depurar. Inspect (inspeccionar variables) (Alt-F4) Turbo C++ muestra varias herramientas para monito rear variables (Fig. es decir. Basta oprimir la combinación de teclas Ctrl-F2. Para lograr esto sólo basta oprimir la tecla F8 cada vez que se requiera ejecutar la siguiente subrutina o función.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero línea por línea.2). Program reset (interrumpir la ejecución paso a paso de un programa) (Ctrl-F2) Se utiliza esta opción cuando se desea interrumpir la ejecución y depuración de un programa.. 1. monitorear su valor. 5 . 1. Fig.2.3). su tipo y la dirección donde se aloja en memoria (Fig. La opción “Inspect” permite inspeccionar variables.

4.Evaluar/Modificar variables..4) y es útil cuando se desea modificar el valor de una variable en tiempo de ejecución. Fig 1. 6 .PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero Fig. 1.3.Inspeccionar variables Evaluate/Modify (evaluar y modificar variables) (Ctrl-F4) Con esta herramienta se puede monitorear y alterar el valor de variables (Fig. 1..

1. 7 . Fig. 1. 1. 1.Ventana de monitoreo de algunas variables.6).5.6.Vistas de variables.5) y es útil cuando se desea observar constantemente las variables en tiempo de ejecución.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero Add watch (agregar vista para monitorear variables) (Ctrl-F7) Con esta herramienta se puede monitorear constantemente las variables (Fig.. Fig. Se puede agregar mas de una variable en una ventana (Fig..

PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero Toggle breakpoint ( agregar/eliminar punto de ruptura) (Ctrl-F8) Esta opción permite establecer o eliminar puntos de ruptura.7. 1. es decir. cuando se desea ejecutar un programa paso a paso a partir de alguna línea de código.7). para después ejecutar el programa normalmente y cuando vaya a ejecutar la línea marcada. se detiene la ejecución a esperar un “Trace into” o un “Step over” (Fig. 1. 8 . Breakpoint. se establece un breakpoint (se marca la línea de código con una franja roja). Fig.

ES y SS en la misma dirección. 2.1. 9 .2): Tiny: Este modelo de memoria usa los registros CS. Existen los siguientes modelos de memoria (Fig. ya que se cuenta con 64K de memoria para el código y 64K para datos y la pila.CONFIGURACIÓN DEL COMPILADOR Es importante conocer las opciones de configuración del compilador para optimizar el rendimiento de nuestros programas.Configuración de los modelos de memoria. 2. En esta sección se verá brevemente las diversas formas de configuración. datos y pila. Esto significa que se cuenta con 64K de memoria para código.1 muestra la ventana de configuración de los modelos de memoria del compilador.. Modelos de memoria La Fig. Fig.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero 2. DS.. Small: Se usa este modelo de memoria para aplicaciones de tamaño regular. 2. Los segmentos de código y de datos son diferentes y no se empalman.

10 . Compact: Este modelo es lo contrario del modelo Médium y úselo cuando se tenga poco código en el programa pero que maneje una gran cantidad de memoria de datos. hasta 1MB de código y 64K para la pila. Large: Use este modelo solamente para aplicaciones muy grandes. pero el código puede ocupar hasta 1MB de memoria.2. Huge: También se usa este modelo para aplicaciones muy grandes. Se usan apuntadores lejanos tanto para datos como para código.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero Medium: Este modelo se utiliza cuando se tiene un programa de gran tamaño que no maneja muchos datos en memoria. es decir. En este caso se usan apuntadores lejanos para los datos pero no para el código.3 muestra la ventana donde se establecen las rutas de búsqueda de las utilerías del compilador. Los apuntadores lejanos se utilizan para el código pero no para los datos.. 2. Fig 2. además se define el subdirectorio donde se grabarán los programas objeto y los ejecutables producto de la ejecución de los programas.Modelos de memoria Directorios La Fig. se tienen 64K para datos y pila. sólo que permite varios segmentos de datos de 64K cada uno. otorgándoles 1MB de memoria a cada uno. ya que éste se limita a 64K mientras que los datos pueden ocupar hasta 1MB de memoria.

4 Una vez que se modifica la configuración del compilador.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero Fig.Directorios.4. Grabar la configuración del compilador. Guardar configuración para 2. 2. 11 . Fig.3. es necesaria grabarla mantenerla en compilaciones futuras (Fig.. 2.

? Subrutinas ? Procedimientos Funciones Procedimientos Son un tipo de subrutina que ejecuta un conjunto de acciones sin devolver valor alguno como resultado de dichas operaciones.SUBRUTINAS Básicamente una Subrutina es un segmento de código que se escribe sólo una vez pero puede invocarse o ejecutarse muchas veces.. void Rutina(void).PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero 3. Si se desea que la función devuelva más de un valor debe usarse otro mecanismo. ejem. Funciones A diferencia de los procedimientos. // Devuelve un valor de tipo entero float CALCULA(void). 12 . void TAREA(void). Existen dos tipos: Procedimientos y Funciones. // Devuelve un valor de tipo real Limitación de return() La cláusula return() sólo devuelve un valor. int SUMA(void). Estos se identifican por su declaración void(). P. P. ejem. las funciones después de ejecutar un conjunto de acciones devuelven sólo un valor del tipo usado en la declaración de ésta por medio de return().

13 . float y) Argumentos Se pueden enviar varios argumentos a una subrutina. Cualquier función puede acceder a ellas sin tener en cuenta en qué función esté dicha expresión. Se pueden declarar variables globales declarándolas fuera de cualquier función. Usando argumentos para pasar datos a subrutinas El mecanismo para enviar información a las subrutinas es llamado argumento (algunos autores lo conocen como parámetro) y son los datos que se colocan entre paréntesis al invocarlas. P. 5.25). a=PROCESO(3. P. sin embargo es necesario precisar que deben estar declaradas las variables receptoras en el orden indicado considerando el tipo de dato apropiado.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero TIP Cuando se desee que una función devuelva más de un valor. utilice apuntadores y envíe argumentos por referencia Variables locales y globales Las variables que se declaran dentro de una subrutina se llaman locales mientras que las variables globales se conocen a través del programa entero y se pueden usar en cualquier segmento de código manteniendo su valor. la cual debe ser del mismo tipo de la función. int PROCESO(int x. Ejem. Recibiendo un valor de una función Una vez que se invoca una función es necesario utilizar la variable capaz de recibir el valor calculado por ésta. ejem.

3.. clrscr(). // Declaracion del procedimiento RUTINA que acepta // un argumento (apuntador a un entero) void main(void) { int x=3. RUTINA(&x).PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero en el caso anterior. cout << "\n\n\n\r Valor modificado de y=" << *y. } Fig. Bruno Lopez Takeyas */ #include <conio.h> void RUTINA(int *y). return. /* Programa para el paso de argumentos por referencia MiniTaller: Tecnicas avanzadas de programacion en Lenguaje C++ Instructor: M.Paso de argumentos por referencia 14 . la variable “a” recibe el valor calculado por la función “PROCESO”. pero también se puede enviar la dirección de memoria de una variable a una subrutina.1. 3. quien acepta los argumentos 3 y 5. getch().h> #include <iostream. *y+=5.C. cout << "\n\r Antes de la rutina x=" << x.1 muestra un ejemplo. Paso de argumentos por referencia Existen dos formas de pasar argumentos a una subrutina: por valor y por referencia. // Envio de la direccion de “x” como argumento cout << "\n\n\n\r Despues de la rutina x=" << x.25 respectivamente. Hasta este punto sólo se ha analizado el envío de valores. return. El cuadro de la Fig. } void RUTINA(int *y) { cout << "\n\n\n\r Valor recibido por y=" << *y.

2. 3..h> #include <stdio.C. 3. 3.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero TIP Todos los arreglos se pasan por referencia a una subrutina En el ejemplo de la Fig. Bruno Lopez Takeyas */ #include <conio.3 muestra una aplicación típica de envío de argumentos por referencia: el ordenamiento de un arreglo. // Declaracion del que acepta el arreglo B // para ordenarlo en forma ascendente void IMPRIME(int B[TOP]). que se pasa por referencia (se manda su dirección de memoria) a un procedimiento llamado RUTINA.h> #include <iostream. /* Programa para ordenar un arreglo (pasandolo por referencia) MiniTaller: Tecnicas avanzadas de programacion en Lenguaje C++ Instructor: M. // Procedimiento que imprime los elementos // de un arreglo 15 .1 se muestra una variable x de tipo entero. Esto se refleja en memoria como lo indica la Fig.Apuntadores como receptores de direcciones El programa de la Fig. quien recibe dicha dirección con una variable apuntador a un valor entero (y). indirectamente se modifica el valor de x. Memoria RAM 1400 1401 1402 1403 1404 1405 3 x 1401 y Fig. 3.2. La variable y recibe la dirección donde se aloja el valor de x y esto provoca que cuando se modifica lo que apunta y (valor de x).h> #define TOP 10 // Cantidad de elementos en el arreglo void SORTEADOR(int B[TOP]).

entonces el código que está entre una de las precedentes y un #endif se compilará.B[i]). // Intercambio de elementos B[j]=aux. } return. // Declaracion e inicializacion del // arreglo original clrscr(). for(i=0.i<TOP. #ifdef.i++) for(j=i+1.0..j++) if(B[i]>B[j]) { aux=B[i].i++) printf("%2d ". compilarán selectivamente varias porciones de un programa.6. 3.8. } Fig. return.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero void main(void) { int A[TOP]={3. // Variables locales for(i=0. B[i]=B[j]. #endif.j<TOP. // Imprime los elementos del arreglo A antes de sortearlo SORTEADOR(A).Sorteador de un arreglo Compilación condicional Las directivas del preprocesador #if. La directiva #endif marca el final de un bloque #if.i<TOP-1..aux. return.j.".". } void IMPRIME(int B[TOP]) { int i.. #ifdef o #ifndef es cierta. cout << "\n\rArreglo antes de sortearlo . El #else se puede usar con cualquiera 16 . // Variable local printf("\n\r").3. La idea general es que si la expresión después de #if...7. // Imprime los elementos del arreglo A despues de sortearlo getch().2.1. IMPRIME(A). IMPRIME(A).9. } void SORTEADOR(int B[TOP]) { int i. // Procedimiento para ordenar el arreglo A en forma ascendente cout << "\n\n\n\rArreglo despues de sortearlo . #ifndef.4}. #else.5. #elif. de lo contrario se saltará.

5.4}. cin >> A[i]. /* Programa para mostrar la forma de compilar condicionalmente un programa MiniTaller: Tecnicas avanzadas de programacion en Lenguaje C++ Instructor: M.i++) { printf("\n\rA[%d] ? ". IMPRIME(A).4 ilustra el uso de estas directivas.C. IMPRIME(A). El programa de la Fig."... int i..6.". se cancela la // captura de los elementos desde el teclado #define TOP 10 // Cantidad de elementos en el arreglo void SORTEADOR(int B[TOP]).0. // Declaracion del que acepta el arreglo B // para ordenarlo en forma ascendente void IMPRIME(int B[TOP]).h> #include <stdio.7. Bruno Lopez Takeyas */ #include <conio.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero de los anteriores de manera similar a las sentencias else e if. } 17 .h> #define CAPTURAR_ELEMENTOS // Bandera para activar/desactivar la compilacion // de un segmento de codigo // Si se omite esta definicion.i<TOP..i). } #endif CAPTURAR_ELEMENTOS cout << "\n\rArreglo antes de sortearlo . #else if int A[TOP]={3. // Imprime los elementos del arreglo A antes de sortearlo SORTEADOR(A). // Declaracion e inicializacion del // arreglo original #endif CAPTURAR_ELEMENTOS clrscr(). #ifdef CAPTURAR_ELEMENTOS for(i=0. // Imprime los elementos del arreglo A despues de sortearlo getch(). // Procedimiento que imprime los elementos // de un arreglo void main(void) { #ifdef CAPTURAR_ELEMENTOS int A[TOP]. 3. // Procedimiento para ordenar el arreglo A en forma ascendente cout << "\n\n\n\rArreglo despues de sortearlo .h> #include <iostream. return.1.2.9.8.

3. 3.Encabezados creados por el programador. basta con codificar las rutinas y grabarlas en un archivo con extensión h.j<TOP.i++) printf("%2d ".i<TOP-1. for(i=0. // Variables locales for(i=0.4. Estos mensajes llamados “directivas del compilador”. // Intercambio de elementos B[j]=aux. return.5 muestra un ejemplo de la forma de incluir estos encabezados creados por el usuario. La Fig. #include “c:\\tarea\\CAPTURA. // Variable local printf("\n\r"). B[i]=B[j]. } return.j.i<TOP. Regularmente se encuentran almacenados en el subdirectorio \INCLUDE.aux.5.j++) if(B[i]>B[j]) { aux=B[i].PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero void IMPRIME(int B[TOP]) { int i. Sin e mbargo. es entonces cuando surge la necesidad de crear archivos de encabezados que sólo incluye en sus programas cada vez que los necesita..i++) for(j=i+1.. } void SORTEADOR(int B[TOP]) { int i. 18 . informan al compilador de definiciones de frases.Compilación condicional Encabezados creados por el programador (archivos *. el programador puede diseñar segmentos de código (regularmente con subrutinas) que utiliza repetidamente en sus programas. 3.B[i]).h” Fig. Ciertas directivas del compilador se agrupan en los archivos de encabezados y pueden ser incluídas en el código fuente de los programas antes de compilarse. Es posible colocar estatutos en el listado de programas que no son código de programación sino mensajes para el compilador. } Fig.h) Los archivos de encabezados (también conocidos como archivos “include”) son de texto tal como los que codifica el programador usando el editor de programas de Turbo C++.

PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero 4. Registros de Propósito General AH AL AX BH BX Registros de puntero e índice SP Puntero de pila BP Puntero base BL DX CH CX DH CL DL SI Ïndice fuente DI Índice destino 19 . Registros de base de puntero e índice: Se usan para proporcionar soporte a cosas como direccionamiento relativo. Registros de segmento: Son usados para soportar el esquema de memoria segmentada. Registros de la CPU La familia de procesadores 8086 tiene 14 registros en los que se pone la información para procesar o el programa de control (Fig. apuntador de pila e instrucciones para mover b loques.. el ES el segmento extra y el SS el segmento de pila. sistema operativo y entorno tiene sus propios métodos de acceder a los recursos del sistema. el DS el segmento actual de datos. Para efectos didácticos se asumirá el uso del sistema operativo PC-DOS y la familia de procesadores 8086.1). Los registros pueden ser de las categorías siguientes: Registros de propósito general: Son de trabajo de la CPU. En estos registros se colocan los valores para su procesamiento que incluye operaciones aritméticas. El registro CS guarda el segmento de código actual. 4. Registros de propósito especial: Guardan el estado de la CPU y el apuntador de instrucciones que indica la siguiente instrucción que ejecutará la CPU. comparaciones e instrucciones de bifurcación o saltos.USO DE LOS RECURSOS DEL SISTEMA En esta sección se examinarán varias funciones especiales de Turbo C++ que permiten que los programas accedan a los recursos de la computadora mediante las funciones BIOS o DOS. Cada procesador.

Cada interrupción se asocia a una categoría de servicios a las que accede que son determinados por el valor del registro AH. La CPU permite a un programa ejecutar una interrupción software por la instrucción INT. guarda el estado actual del sistema en la pila y salta a una rutina de manejo de la interrupción que se determina por el número de la interrupción. CX y DX. 4. Se declara como int86(int intnum.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero Registros de segmento CS Segmento de código DS Segmento de datos Registro de propòsito especial SS Segmento de pila ES Segmento extra IP Registro de indicadores Fig. union REGS *out) El número de la interrupción en esta función es intnum. Si se necesita información adicional se pasa en los registros AL. realiza una vuelta a la interrupción que provoca que se reanude la ejecución del programa anterior. Hay dos tipos básicos de interrupciones: las generales por hardware y las provocadas por software. in es una unión que contiene los registros que se usarán para pasar la información a los manejadores de la 20 . union REGS *in. Función int86() La función int86() de Turbo C++ se usa para ejecutar una interrupción de software. Después de que acabe la rutina. INT 21h provoca la interrupción 21h. BX.1. Registros de la CPU Puntero de instrucciones Interrupciones Una interrupción es un tipo especial de instrucción que provoca la parada de la ejecución del programa. El número que sigue a la instrucción determina el número de la interrupción. Muchas de estas interrupciones son usadas por el BIOS o el DOS como un medio de acceder a diversas funciones que son parte del sistema operativo. Por ejemplo.

2. cflag. Colocando un 0 aparece nuevamente Fig.3). lo cual indica el valor que se necesita. al. Usar la estructura WORDREGS permite acceder a los registros de la CPU como cantidades de 16 bits. struct WORDREGS { unsigned int }.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero interrupción y out es una unión que guardará los valores devueltos por la interrupción (si los hay). struct BYTEREGS h. dx. dh. bx. bl.2. si. }. REGS es una unión de dos estructuras que contiene el archivo de encabezado DOS. 4. ax. ch. flags.H Como se puede observar en la Fig. CH= 7 6 5 4 3 2 1 0 Colocando un 1 a este bit.2. Desapareciendo el cursor Se puede desaparecer el cursor si se coloca un 1 en el 5º bit del registro CH (Fig. cx. 4.Tipo REGS incluido en el archivo de encabezado DOS.H. El uso de BYTEREGS da acceso a los registros de 8 bits. 4. Para colocar el 5º bit con el valor de 1. se desaparece el cursor. di. se coloca el número hexadecimal 20 en el registro CH.. 4. ah. Fig. lo cual equivale a 00100000 en binario. cl. struct BYTEREGS { unsigned char }.Bit del cursor 21 . bh.. union REGS { struct WORDREGS x. dl.

4.h> #include <iostream.h.ch=0..h.&regs).h> // Encabezado con la definicion de int86() #include <conio. // Declaracion de la union regs de tipo REGS para el uso de // los registros de la CPU clrscr().C. regs... regs. // Inicializar el registro CH con el valor 0(hexadecimal) // equivalente a 00000000. // Invoca la INT 10h (video) cout << "\n\n\n\n\r<<< Oprima cualquier tecla para aparecer el cursor >>>". // Servicio 1 de la INT 10h (video) que se refiere al tama¤o // del cursor int86(0x10.ah=1.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero /* Programa para desaparecer el cursor usando la funcion int86() MiniTaller: Tecnicas avanzadas de programacion en Lenguaje C++ Instructor: M. return.h> void main(void) { union REGS regs.".&regs. es decir colocar un 0 en el // 5o.. // Servicio 1 de la INT 10h (video) que se refiere al tama¤o // del cursor int86(0x10. // Inicializar el registro CH con el valor 20(hexadecimal) // equivalente a 00100000.ah=1. // Invoca la INT 10h (video) cout << "\n\n\n\n\r<<< Oprima cualquier tecla para aparecer el cursor >>>". bit del registro CH para desaparecer el cursor regs. cout << "\n\rDesapareciendo el cursor .Desapareciendo el cursor usando la función int86(). cout << "\n\n\n\n\n\rApareciendo el cursor . getch(). 22 .&regs.ch=0x20..3.h. es decir colocar un 1 en el // 5o.&regs). bit del registro CH para aparecer el cursor regs.h. } Fig. getch().". Bruno Lopez Takeyas */ #include <dos.

4 muestra un ejemplo de la forma de implementar el mouse. // Inicializar el registro AL con el valor 3(hexadecimal) // es decir. invoca el servicio 3 de la INT 33h (mouse) // para detectar el status del mouse. 4.&regs.12).24).h.&regs). } if(regs. // Invoca la INT 33h (mouse) // El servicio 3 de la INT 33h devuelve el status del mouse en el registro BX // Si BX=1 entonces se oprimio el boton izquierdo // Si BX=2 entonces se oprimio el boton derecho if(regs. invoca el servicio 1 de la INT 33h (mouse) // para habilitar el mouse int86(0x33.bx==1) { gotoxy(20. cout << "Boton derecho".al=0x1.bx==2) { gotoxy(40.12).12).x. // Inicializar el registro AL con el valor 1(hexadecimal) // es decir. Bruno Lopez Takeyas */ #include <dos.C. o sea. cout << "Oprima cualquier tecla para salir". /* Programa para usar el mouse MiniTaller: Tecnicas avanzadas de programacion en Lenguaje C++ Instructor: M. gotoxy(40. cout << "Boton izquierdo". cout << " } ".h> #include <iostream.&regs.al=0x3. // Declaracion de la union regs de tipo REGS para el uso de // los registros de la CPU clrscr(). 23 .h.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero Aplicaciones usando el mouse Se pueden desarrollar aplicaciones en las que se incluya el manejo mediante el uso del mouse a través de la INT 33h con sus servicios correspondientes. gotoxy(1. cout << " ". El programa de la Fig.12).h> // Encabezado con la definicion de int86() #include <conio.&regs).x. // Invoca la INT 33h (mouse) while(!kbhit()) { // Ciclo mientras NO se oprima cualquier tecla regs. si se // oprime algun boton y las coordenadas del cursor int86(0x33.h> void main(void) { union REGS regs. gotoxy(20. regs.

/* /* /* /* /* /* /* /* INICIALIZAR SI SE ENCUENTRA INICIALIZA EL DRIVER MUESTRA EL CURSOR ESCONDE EL CURSOR COLOCA LAS COORDENADAS x.... ISC . 4.5 se muestra un encabezado (LIBMOUSE... monitorea constantemente el status del mouse invocando la INT 33h con el servicio AL=3... zMouseInit(struct mdata *Mptr).. */ #define zCOMPILER zTURBOC #define zMOUSE 0x33 #include <dos.....PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero } return.4 .y CHECA LA POSICION Y EL BOTON COLOCA EL RANGO HORIZONTAL COLOCA EL RANGO VERTICAL */ */ */ */ */ */ */ */ /* LIBRERIA .H Librer¡a del programa GRAF_ECA (Graficador de Diagramas Electr¢nicos Bruno L¢pez Takeyas . Sólo basta incluirlo como mediante la siguiente línea de código: #include “LIBMOUSE..Manejo del mouse El programa de la Fig.... zMouseVLimit(struct mdata *Mptr)..h) que contiene las declaraciones necesarias y la mayoría de los servicios necesarios para utilizar el mouse en un programa.... LIBMOUSE..... 86100233 . } Fig.. zMouseHide(struct mdata *Mptr)..h> #if zCOMPILER==zQUICKC static union REGS inregs. la cual devuelve en BX=1 si se oprimió el botón izquierdo o en BX=2 si se oprimió el botón derecho.... zMousePos(struct mdata *Mptr)..outregs. #endif /* PARA EL CONTENIDO DE REGISTROS*/ 24 .. zMouseInfo(struct mdata *Mptr).4 inicializa primero el mouse invocando la INT 33h con el servicio AL=1.. zMouseShow(struct mdata *Mptr). zMouseHLimit(struct mdata *Mptr). 4. En la Fig...h” Las rutinas contenidas en este encabezado son: void void void void void void void void zMouseDetect(struct mdata *Mptr).. #elif zCOMPILER==zTURBOC static union REGS regs.... Instituto Tecnol¢gico de Nuevo Laredo .. Contiene un ciclo que mientras no se oprima cualquier tecla........ 4...

}MouseParams. int MouseButton.x. zMouseVLimit(struct mdata *Mptr).ax=0. zMouseInfo(struct mdata *Mptr). zMousePos(struct mdata *Mptr). zMouseVLimit(Mptr). int MouseMinY. int86(zMOUSE. zMousePos(Mptr). int MouseX.x. /* LLAMA LA INTERRUPCION 33 HEX */ Mptr->MouseFlag=regs. int MouseMaxX.y CHECA LA POSICION Y EL BOTON COLOCA EL RANGO HORIZONTAL COLOCA EL RANGO VERTICAL */ */ */ */ */ */ */ */ /* DECLARACION DE ALGUNAS VARIABLES : /* FUNCION DE ALTO NIVEL PARA INICIALIZAR EL MOUSE SI ESTA PRESENTE : void zMouseDetect(struct mdata *Mptr) { zMouseInit(Mptr).x. } */ */ */ */ /* PRE-INICIALIZACION DE MOUSE A BAJO NIVEL : */ void zMouseInit(struct mdata *Mptr) { #if zCOMPILER==zQUICKC inregs.ax=0. zMouseHLimit(struct mdata *Mptr).ax. int MouseY. int MouseMaxY. zMouseHide(struct mdata *Mptr).&regs). #elif zCOMPILER==zTURBOC regs. /* FUNCION #0 DEL MOUSE */ int86(zMOUSE. #elif zCOMPILER==zTURBOC */ 25 . zMouseInit(struct mdata *Mptr).&inregs.ax=1. Mptr->MouseFlag=outregs. /* /* /* /* /* /* /* /* INICIALIZAR SI SE ENCUENTRA INICIALIZA EL DRIVER MUESTRA EL CURSOR ESCONDE EL CURSOR COLOCA LAS COORDENADAS x. zMouseShow(struct mdata *Mptr). /* INTENTA INICIALIZAR EL MOUSE if(Mptr->MouseFlag==0) return. int86(zMOUSE.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero #ifdef SII struct mdata { int MouseFlag. int MouseMinX.&outregs).&inregs.ax. } /* FUNCION PARA MOSTRAR EL CURSOR DEL MOUSE : void zMouseShow(struct mdata *Mptr) { #if zCOMPILER==zQUICKC inregs.&outregs).&regs. #endif SII void void void void void void void void /* ESTRUCTURA DE DATOS DE MOUSE */ zMouseDetect(struct mdata *Mptr). /* ABORTAR SI NO SE ENCUENTRA zMouseHLimit(Mptr).x. /* IGUALA A 0 SI NO ESTA PRESENTE*/ #endif return.x.

#elif zCOMPILER==zTURBOC regs. /* LLAMA LA INTERRUPCION 33 HEX #endif return.cx=Mptr->MouseX.cx=Mptr->MouseX.&regs.dx.ax=4.dx. /* COLOCA LA COORDENADA EN x regs.x.x.&regs). Mptr->MouseY=outregs.x.x.x.&regs.x.&regs).x. inregs. Mptr->MouseButton=outregs.dx=Mptr->MouseY. #endif return. /* COLOCA LA COORDENADA EN y int86(zMOUSE. int86(zMOUSE. /* OBTIENE LA COORDENADA EN x */ Mptr->MouseY=regs.&inregs.&regs.dx=Mptr->MouseY.x.&regs).x.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero regs. } /* FUNCION PARA BORRAR LA UBICACION DEL CURSOR DEL MOUSE : void zMousePos(struct mdata *Mptr) { #if zCOMPILER==zQUICKC inregs. /* FUNCION #3 DEL MOUSE */ int86(zMOUSE. /* LLAMA LA INTERRUPCION 33 HEX #endif return.&outregs). int86(zMOUSE.&regs). /* 1 (IZQUIERDO) ¢ 2 (DERECHO) */ Mptr->MouseX=regs.x.x.ax=3. /* FUNCION #2 DEL MOUSE int86(zMOUSE.&outregs).x.x.&inregs.cx.cx.ax=2.ax=2.x. #elif zCOMPILER==zTURBOC regs. /* LLAMA LA INTERRUPCION 33 HEX */ Mptr->MouseButton=regs. } /* FUNCION #1 DEL MOUSE /* LLAMA LA INTERRUPCION 33 HEX */ */ /* FUNCION PARA NO MOSTRAR EL CURSOR DEL MOUSE : void zMouseHide(struct mdata *Mptr) { #if zCOMPILER==zQUICKC inregs. /* OBTIENE LA COORDENADA EN y */ #endif return. /* FUNCION #4 DEL MOUSE regs.bx.x. #elif zCOMPILER==zTURBOC regs.&inregs. Mptr->MouseX=outregs. } /* FUNCION PARA COLOCAR EL RANGO HORIZONTAL MINIMO Y MAXIMO : void zMouseHLimit(struct mdata *Mptr) { */ */ */ */ */ */ 26 .&regs.&outregs).ax=1.bx. inregs. int86(zMOUSE. } */ */ */ /* FUNCION PARA DETERMINAR LA UBICACION DEL MOUSE Y EL ESTADO DE BOTONES :*/ void zMouseInfo(struct mdata *Mptr) { #if zCOMPILER==zQUICKC inregs.x. int86(zMOUSE.ax=4.x.ax=3.

&regs).x. } */ */ */ */ */ Fig.&inregs.cx=Mptr->MouseMinY.ax=8.x.x. int86(zMOUSE. } /* /* /* /* FUNCION #7 DEL MOUSE COLOCA LA MINIMA COORDENADA x COLOCA LA MAXIMA COORDENADA x LLAMA LA INTERRUPCION 33 HEX */ */ */ */ /* FUNCION PARA COLOCAR EL RANGO VERTICAL MINIMO Y MAXIMO : void zMouseVLimit(struct mdata *Mptr) { #if zCOMPILER==zQUICKC inregs. int86(zMOUSE.dx=Mptr->MouseMaxX.x. #elif zCOMPILER==zTURBOC regs. /* COLOCA LA MAXIMA COORDENADA y int86(zMOUSE.x. #endif return.&inregs.Encabezado LIBMOUSE.cx=Mptr->MouseMinY.. inregs.&regs. regs. 4. inregs.5.dx=Mptr->MouseMaxY.&outregs).x. /* COLOCA LA MINIMA COORDENADA y regs.x.cx=Mptr->MouseMinX.x.dx=Mptr->MouseMaxX. regs. /* LLAMA LA INTERRUPCION 33 HEX #endif return.ax=8.&outregs).ax=7. inregs.&regs.ax=7.dx=Mptr->MouseMaxY.x.x.x. #elif zCOMPILER==zTURBOC regs.H 27 .&regs). inregs.cx=Mptr->MouseMinX. /* FUNCION #8 DEL MOUSE regs.x.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero #if zCOMPILER==zQUICKC inregs. int86(zMOUSE.

escogen un modo y formato especial para habilitar el monitor para graficar. La cantidad de píxeles usada en la pantalla se conoce como resolución. int modo. 5. modo texto o modo gráfico y otros elementos donde cada modo requiere de cierto equipo (hardware). El programa de la Fig. es necesario incluir el encabezado GRAPHICS. 28 . número posible de colores. existe una cantidad específica de filas y cada fila tiene una cantidad específica de píxeles. Dicha función requiere las siguientes declaraciones: int monitor=DETECT..1 muestra un ejemplo de inicialización y uso del monitor en modo gráfico. Cada modo proporciona ciertas características como la resolución.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero 5. Cada modo gráfico tiene una resolución particular. Resolución Las imágenes gráficas mostradas en un monitor de computadora se componen de pequeños puntos llamados píxeles. los cuales están distribuidos en la pantalla en filas. // Usar el monitor VGA a su maxima resolución Para terminar de usar el monitor en modo gráfico y devolverlo a su modo de texto se usa la función closegraph(). los programadores. // Variable para usar el monitor tipo VGA int modo=VGAHI. Inicializar el monitor en modo gráfico Para habilitar el monitor en modo gráfico y utilizar sus píxeles.GRAFICACIÓN Tal como un artista selecciona diversos medios para representar sus pinturas.H que contiene las declaraciones y funciones relacionadas con graficación e inicializar el monitor en modo gráfico y utilizar sus píxeles con la función initgraph(). // Variable para detectar el tipo de monitor // Modo de operación del monitor también se puede declarar e inicializar con un tipo de monitor específico como: int monitor=VGA.

Las funciones de gráficos tienen como estándar el orden de manejo de coordenadas como columna.1. } closegraph(). // Termina el modo grafico (vuelve a su modo normal) } Fig. el renglon (1.h> // // // // Encabezado con Para el uso de Para el uso de Para el uso de declaraciones de graficos kbhit() random() delay void main(void) { int monitor=VGA. // Declaracion de tipo de monitor y modo initgraph(&monitor. primero se anota la columna y después el renglón para posicionarse en dicha coordenada. Bruno Lopez Takeyas */ #include #include #include #include <graphics. 5."\\tc\\bgi").. // Inicializa el modo grafico indicando el monitor y modo utilizado // El subdirectorio \\tc\\bgi indica la ruta de localizacion de los // archivos *.h> <dos.getmaxcolor) delay(5).BGI (monitores) y *. // Coloca un pixel en la pantalla. 29 . La función getmaxx() calcula la cantidad de píxeles por renglón y la función getmaxy() calcula la cantidad de renglones de la pantalla.h> <stdlib.h> <conio.getmaxy) y el color (1.&modo.C. es decir..PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero /* Programa para inicializar el monitor en modo grafico MiniTaller: Tecnicas avanzadas de programacion en Lenguaje C++ Instructor: M.Inicializar el monitor en modo gráfico Uso de coordenadas Una vez que se inicializa el monitor en modo gráfico.CHR (tipos de letras) while(!kbhit()) // Mientras no se oprima cualquier tecla { putpixel(random(getmaxx()).random(getmaxy()).getmaxx). seleccionando al azar la columna // (1. renglón.random(getmaxcolor())). modo=VGAHI... las coordenadas tienen al píxel como unidad de medida.

RED).0. un tipo de línea. gotoxy(1. Básicamente mostraremos que antes de utilizar un color. // Establece el color amarillo (de aqui en adelante // los trazos aparecen de este color line(0. texto. // Rellena el contorno desde 100. colores y rellenos.h> #include <conio. es necesario definirlo con anterioridad.100.100 hasta // 300.&modo.BGI (monitores) y *.CHR (tipos de letras) gotoxy(1. 5.h> #include <stdio. figuras geométricas.150. // Dibuja un rectangulo desde 200. // Rellena el contorno desde 100. modo.printf("getmaxx()=%d".getmaxy()). setcolor(YELLOW).WHITE).200). sin embargo. /* Programa para graficar figuras geometricas. // Dibuja una linea desde 0.300.50 setcolor(WHITE).200 hasta // encontrar un trazo blanco setcolor(GREEN).30). de relleno.200.2 es un claro ejemplo del uso de líneas. // Inicializa el modo grafico indicando el monitor y modo utilizado // El subdirectorio \\tc\\bgi indica la ruta de localizacion de los // archivos *.5). // Establece el relleno de lineas rojas floodfill(100.HORIZ_DIR.50.0 hasta 50. Bruno Lopez Takeyas */ #include <graphics. // Establece el font como Gotico 30 . // Declaracion de tipo de monitor y modo // Automaticamente detecta el tipo de monitor initgraph(&monitor. figuras geométricas elementales. El programa de la Fig. // Dibuja un circulo cuyo centro esta en 100.50).BLUE).h> // Encabezado con declaraciones de graficos void main(void) { int monitor=DETECT.printf("getmaxy()=%d". // Establece el relleno como cuadricula floodfill(250.24). //Establece el color blanco circle(100. lineas.C.WHITE). colores y rellenos Sería muy difícil considerar todas las opciones posibles de todas las funciones de graficación. //Establece el color verde settextstyle(GOTHIC_FONT.200.200 y de // radio=30 pixeles setfillstyle(LINE_FILL.getmaxx()). etc.200 hasta // encontrar un trazo blanco rectangle(200. colores y rellenos MiniTaller: Tecnicas avanzadas de programacion en Lenguaje C++ Instructor: M. en estos apuntes se tratan los temas fundamentales para implementar este tipo de funciones.200 setfillstyle(HATCH_FILL.23).PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero Líneas."\\tc\\bgi").

"Sanserif").CHR (tipos de letras) TEC(100.BGI (monitores) y *.100 setcolor(CYAN).h> // Encabezado desarrollado por el programador con el // codigo fuente de los escudos del Tec y de ISC void main(void) { int monitor=DETECT. // Declaracion de tipo de monitor y modo // Automaticamente detecta el tipo de monitor initgraph(&monitor."\\tc\\bgi"). 5. Programa fuente con los escudos del Tec y de ISC El código fuente del programa de la Fig. /* Programa para graficar los escudos del Tec y de ISC MiniTaller: Tecnicas avanzadas de programacion en Lenguaje C++ Instructor: M. closegraph(). // Despliega el mensaje "Gothic" en 330..200).h> <stdio. //Establece el color celeste settextstyle(SANS_SERIF_FONT.200 getch(). // Inicializa el modo grafico indicando el monitor y modo utilizado // El subdirectorio \\tc\\bgi indica la ruta de localizacion de los // archivos *.Líneas. Bruno Lopez Takeyas */ #include #include #include #include <graphics. // Termina el modo grafico (vuelve a su modo normal) return.200. // Termina el modo grafico (vuelve a su modo normal) return. colores y rellenos. 5. //Escudo del Tec en columna=100 y renglon=200 ISC(getmaxx()-100. 5. figuras geométricas.// Establece el font como // Sanserif en posicion Vertical de tama¤o 7 outtextxy(330..100. } Fig.Programa fuente con los escudos del Tec y de ISC 31 . closegraph().// Despliega el mensaje "Sanserif" en 330.2.3."Gothic").3 muestra la forma de dibujar el escudo del Instituto Tecnológico de Nuevo Laredo y el escudo de la carrera de Ingeniería en Sistemas Computacionales (ISC).h> <tec.h> // Encabezado con declaraciones de graficos <conio. //Escudo de ISC en columna=540 y renglon=200 getch(). apoyándose en el encabezado de la Fig. modo. 5.7).C.VERT_DIR. } Fig.&modo.200).4.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero // en posicion Horizontal de tama¤o 5 outtextxy(330.

rectangle(x+1. line(x-13.2. line(x+33-4.45.10.y-14+4.. rectangle(x-19.y+30).270.. line(x+38. arc(x+30..3).x+54.35.y-12+3).y-12.y+20-13).y+25-2.y-6-4+2). floodfill(x-17. line(x-19.y-25.y+25-13.. TEC. /* cresta */ ellipse(x+45.y-12).y+46-6.y-24). rectangle(x-2.15).265. line(x-17. rectangle(x+3.x-9.. /* nuca */ line(x+32+12.x+33.90.y-54).y+37..280.y-18).y+34.y-4.y-20.y+35-9.y+42.x+54. arc(x-21. line(x+40. line(x+30..x-25.y-29). line(x+10.y+34).45.y-50).90.. line(x-18. line(x-18.y-6+4+2).y+22-7+2). line(x-24...275.y-46)..x-13.x-32.x+55. line(x+38.x+5.y-29)... 32 .y+42.y-32.y+26).3).40.y+21.7.37).12).x-13...y-8). rectangle(x-14. line(x-20.x+14.55.90.8).9).y-33).60.y-27.y+35-7.y+20-13..y-23.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero /* LIBRERIA .y-17+3-2...y+22...3).int y) { setfillstyle(SOLID_FILL.WHITE). line(x+30. line(x+42.y-14+4.y+40..y-33.y-6+4).y+56.y-48). /* barbilla */ line(x-18.3). arc(x+34. ellipse(x+50.y-11.y+46-4.x+10.y+5). line(x-17.H Libreria de los logos del ITNL y de ISC */ void ISC(int x.. arc(x+40.y-24.x+30. /* garganta */ arc(x-18.y-23.y+35.y-6. floodfill(x+21..90.y-15.x-14.8).270.y-17+3-2.8).x+12. line(x+30-7+4..4).90.. ellipse(x+10.y-29.WHITE).y-16.280.x-13..y+19-3.2.y-17. arc(x-15. line(x-13.y-12).270.y-21.x+11.y-23).y-2).y-9..y+22... /* labio superior */ ellipse(x-25.x-15.. line(x-20.x-14.y-12.x-18. /* tarjeta */ circle(x+21. floodfill(x-23.. rectangle(x-20.. line(x-16-5-2...x-12-3.280. line(x-25.y+28.y+35+7). /* labio inferior */ arc(x-25.45.x-11.x+38+12.y+40).y-23..3.y+19.y+28. /* cuello */ ellipse(x-8.y+35+9).270.y+47.x-26.x-20.90. line(x-16-5-2.y-10.270.y-40.y+22+7+1-2...x-25. arc(x-25..x+7. floodfill(x-14.. line(x-32.x+38.y-14+8+2.y-27.y+45)..x-14.x+38.x-17.170.x-9. line(x-13.y-23.y+42).y+22..y+37). ellipse(x-25.WHITE).235.330.95..y-6+4. line(x-5.y+28).182.y+20-25).WHITE).14).. line(x+7..WHITE).7).3).x+17.y-6+4).x-26.x+30-2+7..y+32)..y-25).. line(x-14.5.

y-52. line(x-6.y-55).y-67.1. line(x+6.x-4.x-5."G").x+5.y-58). outtextxy(x+53."COMPUTACIONALES").x+24.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero ellipse(x-21.y+14.y-52.x-20. line(x+2.y-45.y-38.x+1.y-45).y-40). outtextxy(x-14.x+13."E").x. outtextxy(x-42.y-28.y-49). line(x-5.y-40).63).y-48.y-49.x+24.y-58.HORIZ_DIR.y-55. /* fabrica */ line(x+24.y-61. line(x-10.x+8. outtextxy(x-5.y-49. line(x+6.y-30).y+17. line(x+13.x-16."N"). outtextxy(x+35.90. line(x-20.y-45. line(x-20.64). line(x-10. line(x-15.y-32).y-42.y-45.x+6.y-56. line(x+20.y+17).y-49.x+8.int y) { setcolor(WHITE).y-45."A").y-14+8.y-55.y-70.y-51.y-58).y-49)."N").y+56.y-64.y-32).60).y-49. line(x+15. outtextxy(x-25.y-55). line(x-4.x+13.y+14). line(x+10. line(x-51.y-70. setcolor(WHITE).y-40."E").x+15.x+10.y.x-40.x+24.y-45.y-49). outtextxy(x+17. outtextxy(x+45. outtextxy(x-35. line(x-4. line(x-15. circle(x.y-52.y-61.y-58). line(x+5.y-45. } void TEC(int x. line(x. line(x+2.x-6.x-20.y-42).y-56.y-45.y-58).y-48).x-15.y-58).y-40).4).5)."SISTEMAS").x+24.x-10.x-6. circle(x.x+2.y+14. settextstyle(SMALL_FONT.y-49)."I"). outtextxy(x+5.y-40).x+2. line(x+1.y-40."I").x+20. line(x+8.y-40).y-51.y.x-10. circle(x. line(x-54.y-38)."R").x-17.y-45. /* libro */ line(x-54. outtextxy(x+25.x-43.y-58. line(x-15.y-40).y-58).y+69.y.y-55)."I").x+24.y-40).y-55. line(x-15.y-40). setcolor(GREEN).y-18). line(x-51.x-10. return. line(x+13.y-64. 33 .270.y+17. line(x+24. outtextxy(x-15. line(x-10.y-67.y-58).

y+40. line(x+31.y+40).y+40).y-40.y+47).x+39.x+25. line(x-13. line(x+25. setfillstyle(SOLID_FILL.y-27).y+40.y-7.y-30.y+29). line(x+25. line(x+44. line(x+8. line(x-15.x+25.x-25. line(x+25.RED).y+43).x-20.y+45).y+43).y+47. line(x-5.y-28.y-16).x+31.y+43).y-26.x+7.x+10.x-13.x-3. line(x+34.y-40).x+38.y+9.RED).x+5.y+29).x+27.y+43.x+11. line(x+25. line(x+18.x+18. line(x-20.y+23).y+29.y+45. line(x-4.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero line(x-17.y+6).y+41.y+23.y-36).y+32).y+13).y+9. line(x-14.y+43).y+41). line(x-3.y+40. line(x+13.x+13.x+44.y+32).x+45.x-14. floodfill(x-4.x+29.x+13.y+14.x+40.y+43).x-15. /* engrane orilla externa */ setcolor(WHITE).y+9).y+44.y-58).y+12). line(x+38.x+9.y-13). line(x+39.y+32.y-32). line(x+10.y+18). line(x+25.x+42. /* rayo */ setcolor(RED).x-14.y+41. line(x+45.x+9.y+38. line(x+7.y+18.y-26).x-20.x-5.y+6.y+44).x+18.x+33. line(x+27. line(x+9.y-40. line(x+40. line(x+31.x-17.y+40).y.y-17.y+9).y-16.y+38. line(x+44.y-36.y+48.y-7).y-58.y+12.y-19).y+48). line(x+44. line(x+25. line(x-15.y-19.y+43.y-58).y-13.x-6. line(x+33.y+21). line(x-14.y+38).y+45. line(x-25.y+34).y+29.y+42.y+34.x+44.x+33.y+41. line(x-20.y+43.y-27.y+45.y+21. line(x-6.y+41). 34 .y+40.y-3). line(x+48.y+41). line(x-15.x-15.x+25. line(x+45.y+45).x+27. line(x+33. /* engrane orilla interna */ line(x-25. line(x+11.x+8. line(x-12.x+44.x+34.y-3.x-17.x+44.y+19).x-25. line(x+13. line(x+26.x+25.y+34).y+36.x+4.y-17).x-12.x+45. line(x+42.y+40.y+42).y+45).x-4.y+40). line(x+18. line(x+4.y+40). line(x+9.y+42).x+25.y-51.y+42.y-23).y+43.x+48. line(x+48.y-28).x+48. line(x+5.y-23.y+32.

x+43. line(x+43.180.65.4).90.243.y+22. arc(x-16.17.0.y.y-7. ellipse(x+25. line(x+44.52.320.52.5). line(x-20.y-15. line(x-5.y-4.5). arc(x+10.295.y+8.y-3.25.25.355.0.y+15.y-15.. o cualquier estructura de datos. ellipse(x.y+29).230.y+22.180. ellipse(x+18.360.12. Para ello es necesario capturar en memoria la imagen que se desea grabar usando un apuntador y apoyándose en las declaraciones de la Fig. semicirculos centrales */ arc(x. orificios del engrane */ arc(x-7.Encabezado con los detalles de los escudos Archivar y cargar una imagen Igual que se puede almacenar cualquier variable con un tipo de datos en particular como enteros. line(x-13. ellipse(x-12.120. arc(x-31.360.5).275.y+31.y-9. reales.5). ellipse(x-12-18.7).17).63.285.y-17).y-22).120.x-35. arc(x. cadenas.285. ellipse(x-25.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero /* /* /* /* line(x+42. arc(x+24.x-19.180. arc(x+10. también es posible almacenar en un archivo una imagen que se despliega en la pantalla.y+18.3).12.y-13.y-18.y.y-23). line(x-37.x+10.10. line(x+43.230.y-13).57.6.y+8). registros.y-7.15).90.230. } Fig.275.y-30. caracteres.y+26. return.y.y+2). arc(x.4).y-30. 35 .90.7.180. 5.20). arc(x.y-9.0.y.90.y-16).x+48.80.x+44.y.5 y las funciones mostradas en la Fig.10. 5. hoja del libro */ ellipse(x-33.4).4.x-28.x+44.y-7. arc(x-15.0.10).180.5).17.240.y+14.220.y-9.6).9).0. arc(x+24.y-19.y-17).90. atomo */ ellipse(x-25.15).y-34.y.8). line(x-30.4).15.5). 5.x-12.7.4). arc(x-34.180.

y1) a (x2. Apuntador para capturar en memoria la imagen (puede ser direccionada hasta 1 MB) Declaracion del alias para el archivo. 5. char far *imagen.Declaraciones necesarias para archivar una imagen 36 .y2) Fig.5 .6 .imagen) Captura en el apuntador imagen el dibujo comprendido entre (x1.5 .Funciones necesarias para archivar una imagen Una vez capturada en memoria la imagen.7). Función de manejo de archivos alias_archivo=fopen(“IMAGEN.”wb”) Uso Crea el archivo “IMAGEN..x2. 5. El programa de la Fig.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero Declaración long tamano. 5. FILE *alias_archivo Uso Variable de tipo entero largo para calcular el tamaño en bytes de la imagen que se desea archivar..1.sizeof(imagen).y2) Calcula el espacio necesario para capturar en memoria la imagen comprendida entre las esquinas (x1. Fig. 5.y1.y2.y1) y (x2.8 muestra el código completo.IMG”.y2) imagen=(char far *) farmalloc(tamano) Reserva el espacio de memoria indicado por tamano getimage(x1.alias_archivo) Graba la imagen capturada en el archivo fclose(alias_archivo) Cierra el archivo Fig. 5. .IMG” en modo binario Fwrite(imagen.x2. para proceder a escribir el apuntador con la imagen capturada (Fig.y1.Declaraciones necesarias para archivar una imagen Función Uso tamano=(long int) imagesize(x1. se abre un archivo con un nombre específico en modo binario.

19).270).h> // Encabezado desarrollado por el programador con el // codigo fuente de los escudos del Tec y de ISC void main(void) { int monitor=DETECT. // Capturar el nombre del archivo tamano = (long int)imagesize(250. // Variable para capturar en memoria la imagen que se desea // archivar FILE *alias_archivo. grabarlo en un archivo para cargarlo y desplegarlo posteriormente MiniTaller: Tecnicas avanzadas de programacion en Lenguaje C++ Instructor: M.200). // Variable para calcular el tama¤o en bytes de la imagen que // se desea archivar char far *imagen.imagen).CHR (tipos de letras) TEC(320. // Crear el archivo con el nombre capturado fwrite(imagen.1).130.390. int columna. //Reserva la memoria suficiente getimage(250.130. gotoxy(1.1.&modo. // Calcula el tama¤o de la // imagen que se desea archivar imagen = (char far *) farmalloc(tamano).alias_archivo). Bruno Lopez Takeyas */ #include #include #include #include #include #include #include <graphics.h> <iostream. //Escudo del Tec en columna=320 y renglon=200 setlinestyle(DOTTED_LINE.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero /* Programa para graficar el escudo del Tec.h> <stdio."wb"). // Graba en el archivo la imagen // cargada en memoria 37 . modo.h> <tec. // Inicializa el modo grafico indicando el monitor y modo utilizado // El subdirectorio \\tc\\bgi indica la ruta de localizacion de los // archivos *. // Cargar en memoria la imagen que // contiene el cuadro de las coordenadas indicadas alias_archivo=fopen(archivo. initgraph(&monitor.C.BGI (monitores) y *.130.tamano."\\tc\\bgi").270.renglon. rectangle(250.390. cout << "Anote el nombre del archivo (incluyendo la extension): ".h> <alloc. // Declaracion de tipo de monitor y modo // Automaticamente detecta el tipo de monitor char *archivo.h> // Para usar la funcion farmalloc <string. // Para capturar el nombre del archivo long tamano.270).h> // Encabezado con declaraciones de graficos <conio.1.390. gets(archivo).

alias_archivo). cout << "\n\nColumna=".Programa para archivar una imagen. // Cierra el archivo cout << "\nAnote las coordenadas donde desea desplegar la imagen .imagen.1. cout << "\n\nRenglon=". // Lee desde el archivo la imagen fcloseall()..tamano.. clearviewport(). 5. // Cierra el archivo cout << "\n\ntama¤o=" << tamano << " bytes".. 38 . getch().6.". // Abre el archivo en modo de solo lectura fread(imagen. } Fig. // Coloca en pantalla la imagen // cargada del archivo en las coordenadas especificadas getch().1). // Termina el modo grafico (vuelve a su modo normal) return.PRINCIPIOS DE PROGRAMACION Lucero Castillo Marinero fcloseall(). cin >> columna.renglon."rb"). cout << "\nOprima cualquier tecla para limpiar la pantalla y cargar la imagen". closegraph(). cin >> renglon. // Limpia la pantalla en modo grafico alias_archivo=fopen(archivo. putimage(columna.