Documentos de Académico
Documentos de Profesional
Documentos de Cultura
SEIT
DGIT
MiniTaller: Tcnicas avanzadas de programacin en Lenguaje C++ Instructor: M.C. Bruno Lpez Takeyas Jefe del Centro de Cmputo Noviembre del 2002
CONTENIDO
1.-Uso del editor y compilador
Trace into (ejecucin lnea por lnea) (F/).................................................................... Step over (ejecucin por subrutinas o funciones ) (F8)............................................... Program reset (interrumpir la ejecucin 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
3.- Subrutinas
Procedimientos............................................................................................................ Funciones.................................................................................................................... Limitaciones de return()............................................................................................... Variables locales y globales........................................................................................ Usando argumentos para pasar datos a subrutinas .................................................... Recibiendo un valor de una funcin............................................................................ Paso de argumentos por referencia............................................................................ Compilacin 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
5.- Graficacin
Resolucin................................................................................................................... Inicializar el mo nitor en modo grfico.......................................................................... Uso de coordenadas.................................................................................................... Lneas, figuras geomtricas, colores y rellenos.......................................................... Programa fuente con los escudos del Tec y de ISC...................................................
BIBLIOGRAFA............................................................................................................ 39
takeyas@itnuevolaredo.edu.mx
lnea por lnea. Para lograr esto slo basta oprimir la tecla F8 cada vez que se requiera ejecutar la siguiente subrutina o funcin.
www.itnuevolaredo.edu.mx/takeyas
takeyas@itnuevolaredo.edu.mx
takeyas@itnuevolaredo.edu.mx
takeyas@itnuevolaredo.edu.mx
www.itnuevolaredo.edu.mx/takeyas
takeyas@itnuevolaredo.edu.mx
Modelos de memoria
La Fig. 2.1 muestra la ventana de configuracin de los modelos de memoria del compilador.
Existen los siguientes modelos de memoria (Fig. 2.2): Tiny: Este modelo de memoria usa los registros CS, DS, ES y SS en la misma direccin. Esto significa que se cuenta con 64K de memoria para cdigo, datos y pila. Small: Se usa este modelo de memoria para aplicaciones de tamao regular. Los segmentos de cdigo y de datos son diferentes y no se empalman, ya que se cuenta con 64K de memoria para el cdigo y 64K para datos y la pila.
www.itnuevolaredo.edu.mx/takeyas
takeyas@itnuevolaredo.edu.mx
Medium: Este modelo se utiliza cuando se tiene un programa de gran tamao que no maneja muchos datos en memoria. Los apuntadores lejanos se utilizan para el cdigo pero no para los datos, es decir, se tienen 64K para datos y pila, pero el cdigo puede ocupar hasta 1MB de memoria. Compact: Este modelo es lo contrario del modelo Mdium y selo cuando se tenga poco cdigo en el programa pero que maneje una gran cantidad de memoria de datos. En este caso se usan apuntadores lejanos para los datos pero no para el cdigo, ya que ste se limita a 64K mientras que los datos pueden ocupar hasta 1MB de memoria. Large: Use este modelo solamente para aplicaciones muy grandes. Se usan apuntadores lejanos tanto para datos como para cdigo, otorgndoles 1MB de memoria a cada uno. Huge: Tambin se usa este modelo para aplicaciones muy grandes, slo que permite varios segmentos de datos de 64K cada uno, hasta 1MB de cdigo y 64K para la pila.
Directorios
La Fig. 2.3 muestra la ventana donde se establecen las rutas de bsqueda de las utileras del compilador, adems se define el subdirectorio donde se grabarn los programas objeto y los ejecutables producto de la ejecucin de los programas. www.itnuevolaredo.edu.mx/takeyas
10
takeyas@itnuevolaredo.edu.mx
Guardar configuracin
para 2.4 Una vez que se modifica la configuracin del compilador, es necesaria grabarla mantenerla en compilaciones futuras (Fig.
11
takeyas@itnuevolaredo.edu.mx
3.- SUBRUTINAS
Bsicamente una Subrutina es un segmento de cdigo que se escribe slo una vez pero puede invocarse o ejecutarse muchas veces. Existen dos tipos: Procedimientos y Funciones.
? Subrutinas ?
Procedimientos
Funciones
Procedimientos
Son un tipo de subrutina que ejecuta un conjunto de acciones sin devolver valor alguno como resultado de dichas operaciones. Estos se identifican por su declaracin void(). P. ejem. void Rutina(void); void TAREA(void);
Funciones
A diferencia de los procedimientos, las funciones despus de ejecutar un conjunto de acciones devuelven slo un valor del tipo usado en la declaracin de sta por medio de return(). P. ejem. int SUMA(void); // Devuelve un valor de tipo entero float CALCULA(void); // Devuelve un valor de tipo real
Limitacin de return()
La clusula return() slo devuelve un valor. Si se desea que la funcin devuelva ms de un valor debe usarse otro mecanismo.
www.itnuevolaredo.edu.mx/takeyas
12
takeyas@itnuevolaredo.edu.mx
TIP
Cuando se desee que una funcin devuelva ms de un valor, utilice apuntadores y enve argumentos por referencia
Se pueden enviar varios argumentos a una subrutina, sin embargo es necesario precisar que deben estar declaradas las variables receptoras en el orden indicado considerando el tipo de dato apropiado.
www.itnuevolaredo.edu.mx/takeyas
13
takeyas@itnuevolaredo.edu.mx
en el caso anterior, la variable a recibe el valor calculado por la funcin PROCESO, quien acepta los argumentos 3 y 5.25 respectivamente.
cout << "\n\n\n\r Despues de la rutina x=" << x; getch(); return; } void RUTINA(int *y) { cout << "\n\n\n\r Valor recibido por y=" << *y; *y+=5; cout << "\n\n\n\r Valor modificado de y=" << *y; return; }
www.itnuevolaredo.edu.mx/takeyas
14
takeyas@itnuevolaredo.edu.mx
TIP
En el ejemplo de la Fig. 3.1 se muestra una variable x de tipo entero, que se pasa por referencia (se manda su direccin de memoria) a un procedimiento llamado RUTINA, quien recibe dicha direccin con una variable apuntador a un valor entero (y). La variable y recibe la direccin donde se aloja el valor de x y esto provoca que cuando se modifica lo que apunta y (valor de x), indirectamente se modifica el valor de x. Esto se refleja en memoria como lo indica la Fig. 3.2. Memoria RAM 1400 1401 1402 1403 1404 1405
1401
Fig. 3.2.- Apuntadores como receptores de direcciones El programa de la Fig. 3.3 muestra una aplicacin tpica de envo de argumentos por referencia: el ordenamiento de un arreglo.
/* Programa para ordenar un arreglo (pasandolo por referencia) MiniTaller: Tecnicas avanzadas de programacion en Lenguaje C++ Instructor: M.C. Bruno Lopez Takeyas */ #include <conio.h> #include <stdio.h> #include <iostream.h> #define TOP 10 // Cantidad de elementos en el arreglo
void SORTEADOR(int B[TOP]); // Declaracion del que acepta el arreglo B // para ordenarlo en forma ascendente void IMPRIME(int B[TOP]); // Procedimiento que imprime los elementos // de un arreglo
www.itnuevolaredo.edu.mx/takeyas
15
takeyas@itnuevolaredo.edu.mx
void main(void) { int A[TOP]={3,5,6,7,8,0,2,9,1,4}; // Declaracion e inicializacion del // arreglo original clrscr(); cout << "\n\rArreglo antes de sortearlo ..."; IMPRIME(A); // Imprime los elementos del arreglo A antes de sortearlo SORTEADOR(A); // Procedimiento para ordenar el arreglo A en forma ascendente cout << "\n\n\n\rArreglo despues de sortearlo ..."; IMPRIME(A); // Imprime los elementos del arreglo A despues de sortearlo getch(); return; } void IMPRIME(int B[TOP]) { int i; // Variable local printf("\n\r"); for(i=0;i<TOP;i++) printf("%2d ",B[i]); return; } void SORTEADOR(int B[TOP]) { int i,j,aux; // Variables locales for(i=0;i<TOP-1;i++) for(j=i+1;j<TOP;j++) if(B[i]>B[j]) { aux=B[i]; B[i]=B[j]; // Intercambio de elementos B[j]=aux; } return; }
Compilacin condicional
Las directivas del preprocesador #if, #ifdef, #ifndef, #else, #elif, #endif, compilarn selectivamente varias porciones de un programa. La idea general es que si la expresin despus de #if, #ifdef o #ifndef es cierta, entonces el cdigo que est entre una de las precedentes y un #endif se compilar; de lo contrario se saltar. La directiva #endif marca el final de un bloque #if. El #else se puede usar con cualquiera www.itnuevolaredo.edu.mx/takeyas
16
takeyas@itnuevolaredo.edu.mx
de los anteriores de manera similar a las sentencias else e if. El programa de la Fig. 3.4 ilustra el uso de estas directivas.
/* Programa para mostrar la forma de compilar condicionalmente un programa MiniTaller: Tecnicas avanzadas de programacion en Lenguaje C++ Instructor: M.C. Bruno Lopez Takeyas */ #include <conio.h> #include <stdio.h> #include <iostream.h> #define CAPTURAR_ELEMENTOS // Bandera para activar/desactivar la compilacion // de un segmento de codigo // Si se omite esta definicion, se cancela la // captura de los elementos desde el teclado #define TOP 10 // Cantidad de elementos en el arreglo
void SORTEADOR(int B[TOP]); // Declaracion del que acepta el arreglo B // para ordenarlo en forma ascendente void IMPRIME(int B[TOP]); // Procedimiento que imprime los elementos // de un arreglo void main(void) { #ifdef CAPTURAR_ELEMENTOS int A[TOP]; int i; #else if int A[TOP]={3,5,6,7,8,0,2,9,1,4}; // Declaracion e inicializacion del // arreglo original #endif CAPTURAR_ELEMENTOS clrscr(); #ifdef CAPTURAR_ELEMENTOS for(i=0;i<TOP;i++) { printf("\n\rA[%d] ? ",i); cin >> A[i]; } #endif CAPTURAR_ELEMENTOS cout << "\n\rArreglo antes de sortearlo ..."; IMPRIME(A); // Imprime los elementos del arreglo A antes de sortearlo SORTEADOR(A); // Procedimiento para ordenar el arreglo A en forma ascendente cout << "\n\n\n\rArreglo despues de sortearlo ..."; IMPRIME(A); // Imprime los elementos del arreglo A despues de sortearlo getch(); return; }
www.itnuevolaredo.edu.mx/takeyas
17
takeyas@itnuevolaredo.edu.mx
printf("\n\r"); for(i=0;i<TOP;i++) printf("%2d ",B[i]); return; } void SORTEADOR(int B[TOP]) { int i,j,aux; // Variables locales for(i=0;i<TOP-1;i++) for(j=i+1;j<TOP;j++) if(B[i]>B[j]) { aux=B[i]; B[i]=B[j]; // Intercambio de elementos B[j]=aux; } return; }
18
takeyas@itnuevolaredo.edu.mx
Registros de la CPU
La familia de procesadores 8086 tiene 14 registros en los que se pone la informacin para procesar o el programa de control (Fig. 4.1). Los registros pueden ser de las categoras siguientes: Registros de propsito general: Son de trabajo de la CPU. En estos registros se colocan los valores para su procesamiento que incluye operaciones aritmticas, comparaciones e instrucciones de bifurcacin o saltos. Registros de base de puntero e ndice: Se usan para proporcionar soporte a cosas como direccionamiento relativo, apuntador de pila e instrucciones para mover b loques. Registros de segmento: Son usados para soportar el esquema de memoria segmentada. El registro CS guarda el segmento de cdigo actual, el DS el segmento actual de datos, el ES el segmento extra y el SS el segmento de pila. Registros de propsito especial: Guardan el estado de la CPU y el apuntador de instrucciones que indica la siguiente instruccin que ejecutar la CPU. Registros de Propsito 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
www.itnuevolaredo.edu.mx/takeyas
19
takeyas@itnuevolaredo.edu.mx
Interrupciones
Una interrupcin es un tipo especial de instruccin que provoca la parada de la ejecucin del programa, guarda el estado actual del sistema en la pila y salta a una rutina de manejo de la interrupcin que se determina por el nmero de la interrupcin. Despus de que acabe la rutina, realiza una vuelta a la interrupcin que provoca que se reanude la ejecucin del programa anterior. Hay dos tipos bsicos de interrupciones: las generales por hardware y las provocadas por software. La CPU permite a un programa ejecutar una interrupcin software por la instruccin INT. El nmero que sigue a la instruccin determina el nmero de la interrupcin. Por ejemplo, INT 21h provoca la interrupcin 21h. 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. Cada interrupcin se asocia a una categora de servicios a las que accede que son determinados por el valor del registro AH. Si se necesita informacin adicional se pasa en los registros AL, BX, CX y DX.
Funcin int86()
La funcin int86() de Turbo C++ se usa para ejecutar una interrupcin de software. Se declara como int86(int intnum, union REGS *in, union REGS *out) El nmero de la interrupcin en esta funcin es intnum, in es una unin que contiene los registros que se usarn para pasar la informacin a los manejadores de la www.itnuevolaredo.edu.mx/takeyas
20
takeyas@itnuevolaredo.edu.mx
interrupcin y out es una unin que guardar los valores devueltos por la interrupcin (si los hay).
Como se puede observar en la Fig. 4.2, REGS es una unin de dos estructuras que contiene el archivo de encabezado DOS.H. Usar la estructura WORDREGS permite acceder a los registros de la CPU como cantidades de 16 bits. El uso de BYTEREGS da acceso a los registros de 8 bits.
Desapareciendo el cursor
Se puede desaparecer el cursor si se coloca un 1 en el 5 bit del registro CH (Fig. 4.3). Para colocar el 5 bit con el valor de 1, se coloca el nmero hexadecimal 20 en el registro CH, lo cual equivale a 00100000 en binario, lo cual indica el valor que se necesita. CH= 7 6 5 4 3 2 1 0
Colocando un 1 a este bit, se desaparece el cursor. Colocando un 0 aparece nuevamente Fig. 4.2.- Bit del cursor
www.itnuevolaredo.edu.mx/takeyas
21
takeyas@itnuevolaredo.edu.mx
/* Programa para desaparecer el cursor usando la funcion int86() MiniTaller: Tecnicas avanzadas de programacion en Lenguaje C++ Instructor: M.C. Bruno Lopez Takeyas */ #include <dos.h> // Encabezado con la definicion de int86() #include <conio.h> #include <iostream.h>
void main(void) { union REGS regs; // Declaracion de la union regs de tipo REGS para el uso de // los registros de la CPU clrscr(); cout << "\n\rDesapareciendo el cursor ..."; regs.h.ch=0x20; // Inicializar el registro CH con el valor 20(hexadecimal) // equivalente a 00100000; es decir colocar un 1 en el // 5o. bit del registro CH para desaparecer el cursor regs.h.ah=1; // Servicio 1 de la INT 10h (video) que se refiere al tamao // del cursor int86(0x10,®s,®s); // Invoca la INT 10h (video) cout << "\n\n\n\n\r<<< Oprima cualquier tecla para aparecer el cursor >>>"; getch(); cout << "\n\n\n\n\n\rApareciendo el cursor ..."; regs.h.ch=0; // Inicializar el registro CH con el valor 0(hexadecimal) // equivalente a 00000000; es decir colocar un 0 en el // 5o. bit del registro CH para aparecer el cursor
regs.h.ah=1; // Servicio 1 de la INT 10h (video) que se refiere al tamao // del cursor int86(0x10,®s,®s); // Invoca la INT 10h (video) cout << "\n\n\n\n\r<<< Oprima cualquier tecla para aparecer el cursor >>>"; getch(); return; }
www.itnuevolaredo.edu.mx/takeyas
22
takeyas@itnuevolaredo.edu.mx
void main(void) { union REGS regs; // Declaracion de la union regs de tipo REGS para el uso de // los registros de la CPU clrscr(); gotoxy(1,24);
regs.h.al=0x1; // Inicializar el registro AL con el valor 1(hexadecimal) // es decir, invoca el servicio 1 de la INT 33h (mouse) // para habilitar el mouse int86(0x33,®s,®s); // Invoca la INT 33h (mouse) while(!kbhit()) { // Ciclo mientras NO se oprima cualquier tecla
regs.h.al=0x3; // 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, o sea, si se // oprime algun boton y las coordenadas del cursor int86(0x33,®s,®s); // 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.x.bx==1) { gotoxy(20,12); cout << "Boton izquierdo"; gotoxy(20,12); cout << " "; } if(regs.x.bx==2) { gotoxy(40,12); cout << "Boton derecho"; gotoxy(40,12); cout << " }
";
www.itnuevolaredo.edu.mx/takeyas
23
takeyas@itnuevolaredo.edu.mx
} return; }
El programa de la Fig. 4.4 inicializa primero el mouse invocando la INT 33h con el servicio AL=1. Contiene un ciclo que mientras no se oprima cualquier tecla, monitorea constantemente el status del mouse invocando la INT 33h con el servicio AL=3, la cual devuelve en BX=1 si se oprimi el botn izquierdo o en BX=2 si se oprimi el botn derecho. En la Fig. 4.5 se muestra un encabezado (LIBMOUSE.h) que contiene las declaraciones necesarias y la mayora de los servicios necesarios para utilizar el mouse en un programa. Slo basta incluirlo como mediante la siguiente lnea de cdigo: #include LIBMOUSE.h Las rutinas contenidas en este encabezado son:
zMouseDetect(struct mdata *Mptr); zMouseInit(struct mdata *Mptr); zMouseShow(struct mdata *Mptr); zMouseHide(struct mdata *Mptr); zMousePos(struct mdata *Mptr); zMouseInfo(struct mdata *Mptr); zMouseHLimit(struct mdata *Mptr); zMouseVLimit(struct mdata *Mptr);
/* /* /* /* /* /* /* /*
INICIALIZAR SI SE ENCUENTRA INICIALIZA EL DRIVER MUESTRA EL CURSOR ESCONDE EL CURSOR COLOCA LAS COORDENADAS x,y CHECA LA POSICION Y EL BOTON COLOCA EL RANGO HORIZONTAL COLOCA EL RANGO VERTICAL
*/ */ */ */ */ */ */ */
/* LIBRERIA ................................................ LIBMOUSE.H Librera del programa GRAF_ECA (Graficador de Diagramas Electrnicos Bruno Lpez Takeyas . 86100233 . ISC . Instituto Tecnolgico de Nuevo Laredo . */ #define zCOMPILER zTURBOC #define zMOUSE 0x33 #include <dos.h> #if zCOMPILER==zQUICKC static union REGS inregs,outregs; #elif zCOMPILER==zTURBOC static union REGS regs; #endif
www.itnuevolaredo.edu.mx/takeyas
24
takeyas@itnuevolaredo.edu.mx
#ifdef SII struct mdata { int MouseFlag; int MouseButton; int MouseX; int MouseY; int MouseMinX; int MouseMaxX; int MouseMinY; int MouseMaxY; }MouseParams; #endif SII void void void void void void void void
*/
zMouseDetect(struct mdata *Mptr); zMouseInit(struct mdata *Mptr); zMouseShow(struct mdata *Mptr); zMouseHide(struct mdata *Mptr); zMousePos(struct mdata *Mptr); zMouseInfo(struct mdata *Mptr); zMouseHLimit(struct mdata *Mptr); zMouseVLimit(struct mdata *Mptr);
/* /* /* /* /* /* /* /*
INICIALIZAR SI SE ENCUENTRA INICIALIZA EL DRIVER MUESTRA EL CURSOR ESCONDE EL CURSOR COLOCA LAS COORDENADAS x,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); /* INTENTA INICIALIZAR EL MOUSE if(Mptr->MouseFlag==0) return; /* ABORTAR SI NO SE ENCUENTRA zMouseHLimit(Mptr); zMouseVLimit(Mptr); zMousePos(Mptr); }
*/ */
*/ */
/* PRE-INICIALIZACION DE MOUSE A BAJO NIVEL : */ void zMouseInit(struct mdata *Mptr) { #if zCOMPILER==zQUICKC inregs.x.ax=0; int86(zMOUSE,&inregs,&outregs); Mptr->MouseFlag=outregs.x.ax; #elif zCOMPILER==zTURBOC regs.x.ax=0; /* FUNCION #0 DEL MOUSE */ int86(zMOUSE,®s,®s); /* LLAMA LA INTERRUPCION 33 HEX */ Mptr->MouseFlag=regs.x.ax; /* IGUALA A 0 SI NO ESTA PRESENTE*/ #endif return; } /* FUNCION PARA MOSTRAR EL CURSOR DEL MOUSE : void zMouseShow(struct mdata *Mptr) { #if zCOMPILER==zQUICKC inregs.x.ax=1; int86(zMOUSE,&inregs,&outregs); #elif zCOMPILER==zTURBOC */
www.itnuevolaredo.edu.mx/takeyas
25
takeyas@itnuevolaredo.edu.mx
*/ */
/* FUNCION PARA NO MOSTRAR EL CURSOR DEL MOUSE : void zMouseHide(struct mdata *Mptr) { #if zCOMPILER==zQUICKC inregs.x.ax=2; int86(zMOUSE,&inregs,&outregs); #elif zCOMPILER==zTURBOC regs.x.ax=2; /* FUNCION #2 DEL MOUSE int86(zMOUSE,®s,®s); /* LLAMA LA INTERRUPCION 33 HEX #endif return; }
*/
*/ */
/* FUNCION PARA DETERMINAR LA UBICACION DEL MOUSE Y EL ESTADO DE BOTONES :*/ void zMouseInfo(struct mdata *Mptr) { #if zCOMPILER==zQUICKC inregs.x.ax=3; int86(zMOUSE,&inregs,&outregs); Mptr->MouseButton=outregs.x.bx; Mptr->MouseX=outregs.x.cx; Mptr->MouseY=outregs.x.dx; #elif zCOMPILER==zTURBOC regs.x.ax=3; /* FUNCION #3 DEL MOUSE */ int86(zMOUSE,®s,®s); /* LLAMA LA INTERRUPCION 33 HEX */ Mptr->MouseButton=regs.x.bx; /* 1 (IZQUIERDO) 2 (DERECHO) */ Mptr->MouseX=regs.x.cx; /* OBTIENE LA COORDENADA EN x */ Mptr->MouseY=regs.x.dx; /* OBTIENE LA COORDENADA EN y */ #endif return; } /* FUNCION PARA BORRAR LA UBICACION DEL CURSOR DEL MOUSE : void zMousePos(struct mdata *Mptr) { #if zCOMPILER==zQUICKC inregs.x.ax=4; inregs.x.cx=Mptr->MouseX; inregs.x.dx=Mptr->MouseY; int86(zMOUSE,&inregs,&outregs); #elif zCOMPILER==zTURBOC regs.x.ax=4; /* FUNCION #4 DEL MOUSE regs.x.cx=Mptr->MouseX; /* COLOCA LA COORDENADA EN x regs.x.dx=Mptr->MouseY; /* COLOCA LA COORDENADA EN y int86(zMOUSE,®s,®s); /* LLAMA LA INTERRUPCION 33 HEX #endif return; } /* FUNCION PARA COLOCAR EL RANGO HORIZONTAL MINIMO Y MAXIMO : void zMouseHLimit(struct mdata *Mptr) { */
*/ */ */ */
*/
www.itnuevolaredo.edu.mx/takeyas
26
takeyas@itnuevolaredo.edu.mx
#if zCOMPILER==zQUICKC inregs.x.ax=7; inregs.x.cx=Mptr->MouseMinX; inregs.x.dx=Mptr->MouseMaxX; int86(zMOUSE,&inregs,&outregs); #elif zCOMPILER==zTURBOC regs.x.ax=7; regs.x.cx=Mptr->MouseMinX; regs.x.dx=Mptr->MouseMaxX; int86(zMOUSE,®s,®s); #endif return; }
/* /* /* /*
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.x.ax=8; inregs.x.cx=Mptr->MouseMinY; inregs.x.dx=Mptr->MouseMaxY; int86(zMOUSE,&inregs,&outregs); #elif zCOMPILER==zTURBOC regs.x.ax=8; /* FUNCION #8 DEL MOUSE regs.x.cx=Mptr->MouseMinY; /* COLOCA LA MINIMA COORDENADA y regs.x.dx=Mptr->MouseMaxY; /* COLOCA LA MAXIMA COORDENADA y int86(zMOUSE,®s,®s); /* LLAMA LA INTERRUPCION 33 HEX #endif return; }
*/
*/ */ */ */
www.itnuevolaredo.edu.mx/takeyas
27
takeyas@itnuevolaredo.edu.mx
5.- GRAFICACIN
Tal como un artista selecciona diversos medios para representar sus pinturas, los programadores, escogen un modo y formato especial para habilitar el monitor para graficar. Cada modo proporciona ciertas caractersticas como la resolucin, nmero posible de colores, modo texto o modo grfico y otros elementos donde cada modo requiere de cierto equipo (hardware).
Resolucin
Las imgenes grficas mostradas en un monitor de computadora se componen de pequeos puntos llamados pxeles, los cuales estn distribuidos en la pantalla en filas; existe una cantidad especfica de filas y cada fila tiene una cantidad especfica de pxeles. La cantidad de pxeles usada en la pantalla se conoce como resolucin. Cada modo grfico tiene una resolucin particular.
tambin se puede declarar e inicializar con un tipo de monitor especfico como: int monitor=VGA; // Variable para usar el monitor tipo VGA int modo=VGAHI; // Usar el monitor VGA a su maxima resolucin
Para terminar de usar el monitor en modo grfico y devolverlo a su modo de texto se usa la funcin closegraph(). El programa de la Fig. 5.1 muestra un ejemplo de inicializacin y uso del monitor en modo grfico.
www.itnuevolaredo.edu.mx/takeyas
28
takeyas@itnuevolaredo.edu.mx
/* Programa para inicializar el monitor en modo grafico MiniTaller: Tecnicas avanzadas de programacion en Lenguaje C++ Instructor: M.C. Bruno Lopez Takeyas */ #include #include #include #include <graphics.h> <conio.h> <stdlib.h> <dos.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, modo=VGAHI; // Declaracion de tipo de monitor y modo initgraph(&monitor,&modo,"\\tc\\bgi"); // Inicializa el modo grafico indicando el monitor y modo utilizado // El subdirectorio \\tc\\bgi indica la ruta de localizacion de los // archivos *.BGI (monitores) y *.CHR (tipos de letras) while(!kbhit()) // Mientras no se oprima cualquier tecla { putpixel(random(getmaxx()),random(getmaxy()),random(getmaxcolor())); // Coloca un pixel en la pantalla, seleccionando al azar la columna // (1..getmaxx), el renglon (1..getmaxy) y el color (1..getmaxcolor) delay(5); } closegraph(); // Termina el modo grafico (vuelve a su modo normal) }
Uso de coordenadas
Una vez que se inicializa el monitor en modo grfico, las coordenadas tienen al pxel como unidad de medida. La funcin getmaxx() calcula la cantidad de pxeles por rengln y la funcin getmaxy() calcula la cantidad de renglones de la pantalla. Las funciones de grficos tienen como estndar el orden de manejo de coordenadas como columna, rengln; es decir, primero se anota la columna y despus el rengln para posicionarse en dicha coordenada.
www.itnuevolaredo.edu.mx/takeyas
29
takeyas@itnuevolaredo.edu.mx
/* Programa para graficar figuras geometricas, lineas, texto, colores y rellenos MiniTaller: Tecnicas avanzadas de programacion en Lenguaje C++ Instructor: M.C. Bruno Lopez Takeyas */ #include <graphics.h> #include <conio.h> #include <stdio.h> // Encabezado con declaraciones de graficos
void main(void) { int monitor=DETECT, modo; // Declaracion de tipo de monitor y modo // Automaticamente detecta el tipo de monitor initgraph(&monitor,&modo,"\\tc\\bgi"); // Inicializa el modo grafico indicando el monitor y modo utilizado // El subdirectorio \\tc\\bgi indica la ruta de localizacion de los // archivos *.BGI (monitores) y *.CHR (tipos de letras) gotoxy(1,23);printf("getmaxx()=%d",getmaxx()); gotoxy(1,24);printf("getmaxy()=%d",getmaxy()); setcolor(YELLOW); // Establece el color amarillo (de aqui en adelante // los trazos aparecen de este color line(0,0,50,50); // Dibuja una linea desde 0,0 hasta 50,50
setcolor(WHITE); //Establece el color blanco circle(100,200,30); // Dibuja un circulo cuyo centro esta en 100,200 y de // radio=30 pixeles setfillstyle(LINE_FILL,RED); // Establece el relleno de lineas rojas floodfill(100,200,WHITE); // Rellena el contorno desde 100,200 hasta // encontrar un trazo blanco rectangle(200,100,300,200); // Dibuja un rectangulo desde 200,100 hasta // 300,200 setfillstyle(HATCH_FILL,BLUE); // Establece el relleno como cuadricula floodfill(250,150,WHITE); // Rellena el contorno desde 100,200 hasta // encontrar un trazo blanco setcolor(GREEN); //Establece el color verde settextstyle(GOTHIC_FONT,HORIZ_DIR,5); // Establece el font como Gotico
www.itnuevolaredo.edu.mx/takeyas
30
takeyas@itnuevolaredo.edu.mx
// en posicion Horizontal de tamao 5 outtextxy(330,100,"Gothic"); // Despliega el mensaje "Gothic" en 330,100 setcolor(CYAN); //Establece el color celeste settextstyle(SANS_SERIF_FONT,VERT_DIR,7);// Establece el font como // Sanserif en posicion Vertical de tamao 7 outtextxy(330,200,"Sanserif");// Despliega el mensaje "Sanserif" en 330,200 getch(); closegraph(); // Termina el modo grafico (vuelve a su modo normal) return; }
void main(void) { int monitor=DETECT, modo; // Declaracion de tipo de monitor y modo // Automaticamente detecta el tipo de monitor initgraph(&monitor,&modo,"\\tc\\bgi"); // Inicializa el modo grafico indicando el monitor y modo utilizado // El subdirectorio \\tc\\bgi indica la ruta de localizacion de los // archivos *.BGI (monitores) y *.CHR (tipos de letras) TEC(100,200); //Escudo del Tec en columna=100 y renglon=200 ISC(getmaxx()-100,200); //Escudo de ISC en columna=540 y renglon=200 getch(); closegraph(); // Termina el modo grafico (vuelve a su modo normal) return; }
Fig. 5.3.- Programa fuente con los escudos del Tec y de ISC www.itnuevolaredo.edu.mx/takeyas
31
takeyas@itnuevolaredo.edu.mx
/* LIBRERIA ................................................ TEC.H Libreria de los logos del ITNL y de ISC */ void ISC(int x,int y) { setfillstyle(SOLID_FILL,WHITE); ellipse(x+10,y-40,7,182,35,14); /* cresta */ ellipse(x+45,y-4,270,90,10,37); /* nuca */ line(x+32+12,y+34,x+38+12,y+42); ellipse(x+50,y+56,90,170,55,15); /* cuello */ ellipse(x-8,y+47,280,95,3,7); /* garganta */ arc(x-18,y+35,60,330,9); /* barbilla */ line(x-18,y+35-9,x-18,y+35+9); line(x-14,y+35-7,x-14,y+35+7); line(x-5,y+42,x+7,y+37); line(x+7,y+37,x+10,y+40); line(x+10,y+40,x+11,y+45); /* tarjeta */ circle(x+21,y-23,12); floodfill(x+21,y-23,WHITE); line(x-18,y+42,x+38,y-48); arc(x+40,y-9,40,275,3); line(x+42,y-12,x+55,y-2); line(x+40,y-6,x+54,y+5); line(x+38,y-10,x-17,y-46); arc(x-25,y+25-2,90,270,3); /* labio inferior */ arc(x-25,y+19-3,90,270,3); /* labio superior */ ellipse(x-25,y-32,90,270,2,8); line(x-25,y+25-13,x-32,y+20-13); line(x-32,y+20-13,x-25,y+20-25); ellipse(x-25,y-15,90,270,2,8); line(x+33-4,y+46-4,x+33,y+32); line(x+38,y+46-6,x+38,y+30); arc(x+34,y+28,265,5,4); arc(x-21,y-21,45,280,3); arc(x-15,y-16,280,45,3); line(x-18,y-23,x-13,y-18); line(x-20,y-17,x-14,y-12); floodfill(x-17,y-20,WHITE); line(x-17,y-27,x-13,y-23); line(x-13,y-33,x-9,y-29); line(x-13,y-29,x+5,y-54); line(x-17,y-27,x-13,y-33); line(x-13,y-23,x-9,y-29); floodfill(x-14,y-25,WHITE); line(x-16-5-2,y-17+3-2,x-12-3,y-12+3); line(x-16-5-2,y-17+3-2,x-26,y-12); line(x-19,y-12,x-25,y-8); floodfill(x-23,y-11,WHITE); arc(x+30,y+22,235,45,8); line(x+30-7+4,y+22+7+1-2,x+30-2+7,y+22-7+2); line(x+30,y+22,x-26,y-25); line(x-24,y-24,x+54,y-24); line(x+30,y+22,x+30,y-50); rectangle(x-2,y+28,x+17,y+34); rectangle(x+1,y+19,x+14,y+28); rectangle(x+3,y+21,x+12,y+26); rectangle(x-20,y-14+4,x-14,y-6+4); rectangle(x-14,y-14+8+2,x-11,y-6-4+2); line(x-20,y-14+4,x-20,y-6+4); rectangle(x-19,y-6+4,x-15,y-6+4+2);
www.itnuevolaredo.edu.mx/takeyas
32
takeyas@itnuevolaredo.edu.mx
ellipse(x-21,y-14+8,90,270,1,4); settextstyle(SMALL_FONT,HORIZ_DIR,5); outtextxy(x-14,y+56,"SISTEMAS"); outtextxy(x-42,y+69,"COMPUTACIONALES"); outtextxy(x-35,y-56,"I"); outtextxy(x-25,y-61,"N"); outtextxy(x-15,y-64,"G"); outtextxy(x-5,y-67,"E"); outtextxy(x+5,y-70,"N"); outtextxy(x+17,y-70,"I"); outtextxy(x+25,y-67,"E"); outtextxy(x+35,y-64,"R"); outtextxy(x+45,y-61,"I"); outtextxy(x+53,y-56,"A"); return; } void TEC(int x,int y) { setcolor(WHITE); circle(x,y,60); setcolor(GREEN); circle(x,y,64); circle(x,y,63); setcolor(WHITE); /* libro */ line(x-54,y+17,x-17,y+17); line(x-54,y+17,x-43,y-30); line(x-51,y+14,x-16,y+14); line(x-51,y+14,x-40,y-32); line(x+1,y-28,x+1,y-18); /* fabrica */ line(x+24,y-40,x+24,y-49); line(x+24,y-49,x+13,y-49); line(x+13,y-49,x+13,y-55); line(x+13,y-55,x+2,y-49); line(x+2,y-49,x+2,y-55); line(x+2,y-55,x-10,y-49); line(x-10,y-49,x-10,y-55); line(x-10,y-55,x-20,y-48); line(x-20,y-48,x-20,y-32); line(x-20,y-38,x+24,y-38); line(x-15,y-40,x+24,y-40); line(x-15,y-42,x+24,y-42); line(x-15,y-45,x+24,y-45); line(x-10,y-45,x-10,y-40); line(x-5,y-45,x-5,y-40); line(x,y-45,x,y-40); line(x+5,y-45,x+5,y-40); line(x+10,y-45,x+10,y-40); line(x+15,y-45,x+15,y-40); line(x+20,y-45,x+20,y-40); line(x+8,y-52,x+8,y-58); line(x+6,y-51,x+6,y-58); line(x+6,y-58,x+8,y-58); line(x-4,y-52,x-4,y-58); line(x-6,y-51,x-6,y-58); line(x-4,y-58,x-6,y-58); line(x-15,y-52,x-15,y-58);
www.itnuevolaredo.edu.mx/takeyas
33
takeyas@itnuevolaredo.edu.mx
line(x-17,y-51,x-17,y-58); line(x-15,y-58,x-17,y-58); /* rayo */ setcolor(RED); setfillstyle(SOLID_FILL,RED); line(x+25,y-40,x+10,y-16); line(x+25,y-40,x+11,y-23); line(x+10,y-16,x+9,y-19); line(x+11,y-23,x+9,y-28); line(x+9,y-19,x-13,y+21); line(x+9,y-28,x-12,y+12); line(x-13,y+21,x-14,y+18); line(x-12,y+12,x-14,y+9); line(x-14,y+18,x-25,y+40); line(x-14,y+9,x-25,y+40); floodfill(x-4,y,RED); /* engrane orilla externa */ setcolor(WHITE); line(x-25,y+40,x-20,y+43); line(x-20,y+43,x-15,y+41); line(x-15,y+41,x-6,y+43); line(x-6,y+43,x-4,y+47); line(x-4,y+47,x+4,y+48); line(x+4,y+48,x+7,y+44); line(x+7,y+44,x+13,y+43); line(x+13,y+43,x+18,y+45); line(x+18,y+45,x+25,y+42); line(x+25,y+42,x+25,y+40); line(x+25,y+40,x+27,y+34); line(x+26,y+36,x+34,y+32); line(x+34,y+32,x+39,y+32); line(x+39,y+32,x+45,y+23); line(x+45,y+23,x+42,y+13); line(x+42,y+14,x+44,y+9); line(x+44,y+9,x+48,y+6); line(x+48,y+6,x+48,y-3); line(x+48,y-3,x+44,y-7); line(x+44,y-7,x+44,y-13); line(x+44,y-13,x+45,y-17); line(x+45,y-17,x+40,y-27); line(x+40,y-27,x+33,y-26); line(x+33,y-26,x+29,y-32); line(x+31,y-30,x+31,y-36); line(x+31,y-36,x+25,y-40); /* engrane orilla interna */ line(x-25,y+38,x-20,y+40); line(x-20,y+40,x-15,y+38); line(x-15,y+38,x-5,y+41); line(x-5,y+41,x-3,y+45); line(x-3,y+45,x+5,y+45); line(x+5,y+45,x+8,y+42); line(x+8,y+42,x+13,y+41); line(x+13,y+41,x+18,y+43); line(x+18,y+43,x+25,y+40); line(x+25,y+40,x+25,y+43); line(x+25,y+40,x+27,y+34); line(x+27,y+34,x+33,y+29); line(x+33,y+29,x+38,y+29); line(x+38,y+29,x+44,y+19);
www.itnuevolaredo.edu.mx/takeyas
34
takeyas@itnuevolaredo.edu.mx
/*
/*
/*
/*
line(x+42,y+14,x+44,y+8); line(x+44,y+8,x+48,y+2); line(x+43,y-7,x+43,y-13); line(x+43,y-13,x+44,y-17); semicirculos centrales */ arc(x,y,243,63,5); arc(x,y,240,57,20); ellipse(x,y+18,230,10,12,4); arc(x,y,275,25,10); arc(x,y,275,25,15); atomo */ ellipse(x-25,y-9,0,360,7,15); ellipse(x-25,y-9,0,360,15,7); arc(x-34,y-3,120,355,5); arc(x-16,y-18,320,120,5); line(x-37,y-7,x-19,y-23); line(x-30,y,x-12,y-16); arc(x-31,y-19,65,230,5); arc(x-15,y-4,230,80,5); line(x-20,y,x-35,y-17); line(x-13,y-9,x-28,y-22); hoja del libro */ ellipse(x-33,y+15,0,180,17,3); ellipse(x-12,y-30,0,180,12,4); ellipse(x-12-18,y-34,180,0,10,4); ellipse(x+18,y-30,90,180,17,4); orificios del engrane */ arc(x-7,y+26,90,295,4); arc(x+10,y+22,285,52,6); arc(x+10,y+22,285,52,5); line(x-5,y+31,x+10,y+29); ellipse(x+25,y-7,220,90,7,17); arc(x+24,y-15,90,180,9); arc(x+24,y-15,90,180,8); return;
www.itnuevolaredo.edu.mx/takeyas
35
takeyas@itnuevolaredo.edu.mx
Uso Variable de tipo entero largo para calcular el tamao en bytes de la imagen que se desea archivar. Apuntador para capturar en memoria la imagen (puede ser direccionada hasta 1 MB) Declaracion del alias para el archivo.
Funcin Uso tamano=(long int) imagesize(x1,y1,x2,y2) Calcula el espacio necesario para capturar en memoria la imagen comprendida entre las esquinas (x1,y1) a (x2,y2) imagen=(char far *) farmalloc(tamano) Reserva el espacio de memoria indicado por tamano getimage(x1,y1,x2,y2,imagen) Captura en el apuntador imagen el dibujo comprendido entre (x1,y1) y (x2,y2) Fig. 5.6 . - Funciones necesarias para archivar una imagen
Una vez capturada en memoria la imagen, se abre un archivo con un nombre especfico en modo binario, para proceder a escribir el apuntador con la imagen capturada (Fig. 5.7). El programa de la Fig. 5.8 muestra el cdigo completo.
Uso Crea el archivo IMAGEN.IMG en modo binario Fwrite(imagen,sizeof(imagen),1,alias_archivo) Graba la imagen capturada en el archivo fclose(alias_archivo) Cierra el archivo Fig. 5.5 .- Declaraciones necesarias para archivar una imagen
www.itnuevolaredo.edu.mx/takeyas
36
takeyas@itnuevolaredo.edu.mx
/* Programa para graficar el escudo del Tec, grabarlo en un archivo para cargarlo y desplegarlo posteriormente MiniTaller: Tecnicas avanzadas de programacion en Lenguaje C++ Instructor: M.C. Bruno Lopez Takeyas */ #include #include #include #include #include #include #include <graphics.h> // Encabezado con declaraciones de graficos <conio.h> <stdio.h> <iostream.h> <alloc.h> // Para usar la funcion farmalloc <string.h> <tec.h> // Encabezado desarrollado por el programador con el // codigo fuente de los escudos del Tec y de ISC
void main(void) { int monitor=DETECT, modo; // Declaracion de tipo de monitor y modo // Automaticamente detecta el tipo de monitor char *archivo; // Para capturar el nombre del archivo long tamano; // Variable para calcular el tamao en bytes de la imagen que // se desea archivar char far *imagen; // Variable para capturar en memoria la imagen que se desea // archivar FILE *alias_archivo; int columna,renglon;
initgraph(&monitor,&modo,"\\tc\\bgi"); // Inicializa el modo grafico indicando el monitor y modo utilizado // El subdirectorio \\tc\\bgi indica la ruta de localizacion de los // archivos *.BGI (monitores) y *.CHR (tipos de letras)
TEC(320,200); //Escudo del Tec en columna=320 y renglon=200 setlinestyle(DOTTED_LINE,1,1); rectangle(250,130,390,270); gotoxy(1,19); cout << "Anote el nombre del archivo (incluyendo la extension): "; gets(archivo); // Capturar el nombre del archivo tamano = (long int)imagesize(250,130,390,270); // Calcula el tamao de la // imagen que se desea archivar imagen = (char far *) farmalloc(tamano); //Reserva la memoria suficiente getimage(250,130,390,270,imagen); // Cargar en memoria la imagen que // contiene el cuadro de las coordenadas indicadas alias_archivo=fopen(archivo,"wb"); // Crear el archivo con el nombre capturado fwrite(imagen,1,tamano,alias_archivo); // Graba en el archivo la imagen // cargada en memoria
www.itnuevolaredo.edu.mx/takeyas
37
takeyas@itnuevolaredo.edu.mx
fcloseall(); // Cierra el archivo cout << "\n\ntamao=" << tamano << " bytes"; cout << "\nOprima cualquier tecla para limpiar la pantalla y cargar la imagen"; getch(); clearviewport(); // Limpia la pantalla en modo grafico alias_archivo=fopen(archivo,"rb"); // Abre el archivo en modo de solo lectura fread(imagen,1,tamano,alias_archivo); // Lee desde el archivo la imagen fcloseall(); // Cierra el archivo cout << "\nAnote las coordenadas donde desea desplegar la imagen ..."; cout << "\n\nColumna="; cin >> columna; cout << "\n\nRenglon="; cin >> renglon; putimage(columna,renglon,imagen,1); // Coloca en pantalla la imagen // cargada del archivo en las coordenadas especificadas getch(); closegraph(); // Termina el modo grafico (vuelve a su modo normal) return; }
www.itnuevolaredo.edu.mx/takeyas
38
takeyas@itnuevolaredo.edu.mx
BIBLIOGRAFA
Barkakati Nabajyoti. The Waite Groups. Turbo C Bible. Howard W. Sams & Company. Estados Unidos. 1990. Garca Badell, J. Javier. "Turbo C. Programacin en manejo de archivos". Macrobit. Deitel y Deitel. C++ Cmo programar. Segunda edicin. Pearson-Prentice Hall. Estados Unidos. 1999. Lafore, Robert. The Waite Groups. Turbo C. Programming for the PC. Revised Edition. Howard W. Sams & Company. Estados Unidos. 1990. Schildt, Herbert. Turbo C. Programacin avanzada. Segunda edicin, McGraw Hill. Estados Unidos. 1990. Staugaard, Andrew. Tcnicas estructuradas y orientadas a objetos. Una introduccin utilizando C++. Segunda edicin. Prentice Hall. Estados Unidos. 1998.
www.itnuevolaredo.edu.mx/takeyas
39
takeyas@itnuevolaredo.edu.mx