Tecnicas Avanzadas de Programacion en Lenguaje C++ PDF

SEP SEIT DGIT
INSTITUTO TECNOLGICO DE NUEVO LAREDO
INGENIERA EN SISTEMAS COMPUTACIONALES
MiniTaller: Tcnicas avanzadas de programacin en

Lenguaje C++
Instructor: M.C. Bruno Lpez Takeyas

Jefe del Centro de Cmputo
Noviembre del 2002

CONTENIDO
Pag
1.-Uso del editor y compilador
Trace into (ejecucin lnea por lnea) (F/).................................................................... 4
Step over (ejecucin por subrutinas o funciones ) (F8)............................................... 4
Program reset (interrumpir la ejecucin paso a paso) (Ctrl-F2).................................. 5
Inspect (Inspeccionar variables) (Alt-F4)..................................................................... 5
Evaluate/Modify (Ctrl-F4)... 6
Add watch (Ctrl-F7)...................................................................................................... 7
Toggle breakpoint (Ctrl-F8).......................................................................................... 8
2.- Configuracin del compilador

Modelos de memoria................................................................................................... 9
Directorios.................................................................................................................... 10
Guardar configuracin................................................................................................. 11
3.- Subrutinas
Procedimientos............................................................................................................ 12
Funciones.................................................................................................................... 12
Limitaciones de return()............................................................................................... 12
Variables locales y globales........................................................................................ 13
Usando argumentos para pasar datos a subrutinas .................................................... 13
Recibiendo un valor de una funcin............................................................................ 13
Paso de argumentos por referencia............................................................................ 14
Compilacin condicional.............................................................................................. 16
Encabezados creados por el programador (archivos *.h)........................................... 18
4.- Uso de los recursos del sistema

Registros de la CPU.................................................................................................... 19
Interrupciones.............................................................................................................. 20
Funcin int86()............................................................................................................. 20
Desapareciendo el cursor............................................................................................ 21
Aplicaciones usando el mouse.................................................................................... 23
5.- Graficacin
Resolucin................................................................................................................... 28
Inicializar el mo nitor en modo grfico.......................................................................... 28
Uso de coordenadas.................................................................................................... 29
Lneas, figuras geomtricas, colores y rellenos.......................................................... 30
Programa fuente con los escudos del Tec y de ISC................................................... 31
Archivar y cargar una imagen...................................................................................... 35
BIBLIOGRAFA............................................................................................................ 39
Tcnicas avanzadas de programacin en Lenguaje C++ M.C. Bruno Lpez Takeyas
1.- USO DEL EDITOR Y COMPILADOR

Para codificar mejores programas es recomendable utilizar y aprovechar al
mximo las herramientas que proporciona el editor y el compilador. Un aspecto muy
importante es la depuracin de los programas para identificar fcilmente los errores o
las reas sujetas a optimizacin. Por ello es indispensable saber ejecutar los programas
paso a paso, por bloques, poder observar los valores de variables en tiempo real,
monitorear variables e incluso alterar sus valores en tiempo de ejecucin para realizar
las pruebas a dichos programas. A continuacin se muestran las herramientas que
presenta Turbo C++ para esto.
Trace into (ejecucin lnea por lnea) (F7)

La ventana de Run (ejecucin) (Fig. 1.1) contiene varias herramientas para
ejecutar programas paso a paso. La herramienta Trace into ejecuta paso a paso un
programa, es decir, lnea por lnea de cdigo. Para lograr esto, slo basta oprimir la
tecla F7 cada vez que se requiera ejecutar una lnea de cdigo.
Fig. 1.1.- Ventana de ejecucin de programas.
Step over (ejecucin por subrutinas o funciones) (F8)
Esta herramienta tambin ejecuta paso a paso un programa, pero a diferencia del
Trace into no lo hace lnea por lnea, sino por subrutinas o funciones; es decir, si en el
cdigo se encuentra el llamado a una subrutina, la ejecuta completamente sin llamarla
www.itnuevolaredo.edu.mx/takeyas 4 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.
Program reset (interrumpir la ejecucin paso a paso de

un programa) (Ctrl-F2)
Se utiliza esta opcin cuando se desea interrumpir la ejecucin y depuracin de

un programa. Basta oprimir la combinacin de teclas Ctrl-F2.
Inspect (inspeccionar variables) (Alt-F4)
Turbo C++ muestra varias herramientas para monito rear variables (Fig. 1.2). La
opcin Inspect permite inspeccionar variables, es decir, monitorear su valor, su tipo y
la direccin donde se aloja en memoria (Fig. 1.3).
Fig. 1.2.- Depurar.
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.4)
y es til cuando se desea modificar el valor de una variable en tiempo de ejecucin.
Fig 1.4.- Evaluar/Modificar variables.
Add watch (agregar vista para monitorear variables)

(Ctrl-F7)
Con esta herramienta se puede monitorear constantemente las variables (Fig. 1.5)
y es til cuando se desea observar constantemente las variables en tiempo de
ejecucin. Se puede agregar mas de una variable en una ventana (Fig. 1.6).
Fig. 1.5.- Vistas de variables.
Fig. 1.6.- Ventana de monitoreo de algunas variables.

Toggle breakpoint ( agregar/eliminar punto de ruptura)

(Ctrl-F8)
Esta opcin permite establecer o eliminar puntos de ruptura, es decir, cuando se

desea ejecutar un programa paso a paso a partir de alguna lnea de cdigo, se
establece un breakpoint (se marca la lnea de cdigo con una franja roja), para despus
ejecutar el programa normalmente y cuando vaya a ejecutar la lnea marcada, se
detiene la ejecucin a esperar un Trace into o un Step over (Fig. 1.7).
Fig. 1.7. Breakpoint.
2.- CONFIGURACIN DEL COMPILADOR
Es importante conocer las opciones de configuracin del compilador para

optimizar el rendimiento de nuestros programas. En esta seccin se ver brevemente
las diversas formas de configuracin.
Modelos de memoria
La Fig. 2.1 muestra la ventana de configuracin de los modelos de memoria del
compilador.
Fig. 2.1.- Configuracin de los modelos de memoria.
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.
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.
Fig 2.2.- Modelos de memoria
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.
Fig. 2.3.- Directorios.
Guardar configuracin
Una vez que se modifica la configuracin del compilador, es necesaria grabarla
para mantenerla en compilaciones futuras (Fig.
2.4
Fig. 2.4. Grabar la configuracin del compilador.
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.
? Procedimientos
Subrutinas
? 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.
Cuando se desee que una funcin

TIP devuelva ms de un valor, utilice
apuntadores y enve 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 travs del programa entero y se pueden usar
en cualquier segmento de cdigo manteniendo su valor. Se pueden declarar variables
globales declarndolas fuera de cualquier funcin. Cualquier funcin puede acceder a
ellas sin tener en cuenta en qu funcin est dicha expresin.
Usando argumentos para pasar datos a subrutinas

El mecanismo para enviar informacin a las subrutinas es llamado argumento
(algunos autores lo conocen como parmetro) y son los datos que se colocan entre
parntesis al invocarlas.
P. ejem.
int PROCESO(int x, float y) Argumentos
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.
Recibiendo un valor de una funcin

Una vez que se invoca una funcin es necesario utilizar la variable capaz de
recibir el valor calculado por sta, la cual debe ser del mismo tipo de la funcin. P.
Ejem.
a=PROCESO(3, 5.25);
en el caso anterior, la variable a recibe el valor calculado por la funcin PROCESO,

quien acepta los argumentos 3 y 5.25 respectivamente.
Paso de argumentos por referencia

Existen dos formas de pasar argumentos a una subrutina: por valor y por
referencia. Hasta este punto slo se ha analizado el envo de valores, pero tambin se
puede enviar la direccin de memoria de una variable a una subrutina. El cuadro de la
Fig. 3.1 muestra un ejemplo.
/*
Programa para el paso de argumentos por referencia
MiniTaller: Tecnicas avanzadas de programacion en Lenguaje C++

Instructor: M.C. Bruno Lopez Takeyas
*/
#include <conio.h>
#include <iostream.h>
void RUTINA(int *y); // Declaracion del procedimiento RUTINA que acepta

// un argumento (apuntador a un entero)
void main(void)
{
int x=3;
clrscr();
cout << "\n\r Antes de la rutina x=" << x;
RUTINA(&x); // Envio de la direccion de x como argumento
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;
}
Fig. 3.1.- Paso de argumentos por referencia
Todos los arreglos se pasan por

TIP referencia a una subrutina
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 3 x
1402
1403
1404
1405 1401 y
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)

*/
#include <conio.h>
#include <stdio.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
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;
}
Fig. 3.3.- Sorteador de un arreglo
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
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

*/
#include <conio.h>
#include <stdio.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;
}
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;
}
Fig. 3.4.- Compilacin condicional
Encabezados creados por el programador (archivos *.h)

Los archivos de encabezados (tambin conocidos como archivos include) son de
texto tal como los que codifica el programador usando el editor de programas de Turbo
C++. Regularmente se encuentran almacenados en el subdirectorio \INCLUDE. Es
posible colocar estatutos en el listado de programas que no son cdigo de
programacin sino mensajes para el compilador. Estos mensajes llamados directivas
del compilador, informan al compilador de definiciones de frases. Ciertas directivas del
compilador se agrupan en los archivos de encabezados y pueden ser includas en el
cdigo fuente de los programas antes de compilarse. Sin embargo, el programador
puede disear segmentos de cdigo (regularmente con subrutinas) que utiliza
repetidamente en sus programas, es entonces cuando surge la necesidad de crear
archivos de encabezados que slo incluye en sus programas cada vez que los necesita,
basta con codificar las rutinas y grabarlas en un archivo con extensin h. La Fig. 3.5
muestra un ejemplo de la forma de incluir estos encabezados creados por el usuario.
#include c:\\tarea\\CAPTURA.h
Fig. 3.5.- Encabezados creados por el programador.
4.- USO DE LOS RECURSOS DEL SISTEMA
En esta seccin se examinarn 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, sistema operativo y entorno tiene sus propios mtodos de
acceder a los recursos del sistema. Para efectos didcticos se asumir el uso del
sistema operativo PC-DOS y la familia de procesadores 8086.
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 CH CL
AX CX
BH BL DH DL
BX DX
Registros de puntero e ndice

SP SI
Puntero de pila ndice fuente
BP DI
Puntero base ndice destino
Registros de segmento
CS SS
Segmento de cdigo Segmento de pila
DS ES
Segmento de datos Segmento extra
Registro de propsito especial

IP
Registro de indicadores Puntero de instrucciones
Fig. 4.1. Registros de la CPU
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
interrupcin y out es una unin que guardar los valores devueltos por la interrupcin
(si los hay).
struct WORDREGS {
unsigned int ax, bx, cx, dx, si, di, cflag, flags;
};
struct BYTEREGS {
unsigned char al, ah, bl, bh, cl, ch, dl, dh;
};
union REGS {
struct WORDREGS x;
struct BYTEREGS h;
};
Fig. 4.2.- Tipo REGS incluido en el archivo de encabezado DOS.H
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
/*
Programa para desaparecer el cursor usando la funcion int86()

*/
#include <dos.h> // Encabezado con la definicion de int86()

#include <conio.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,&regs,&regs); // 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,&regs,&regs); // Invoca la INT 10h (video)
cout << "\n\n\n\n\r<<< Oprima cualquier tecla para aparecer el cursor >>>";
getch();
return;
}
Fig. 4.3.- Desapareciendo el cursor usando la funcin int86().
Aplicaciones usando el mouse

Se pueden desarrollar aplicaciones en las que se incluya el manejo mediante el
uso del mouse a travs de la INT 33h con sus servicios correspondientes. El programa
de la Fig. 4.4 muestra un ejemplo de la forma de implementar el mouse.
/*
Programa para usar el mouse

*/
#include <dos.h> // Encabezado con la definicion de int86()

#include <conio.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();
gotoxy(1,24); cout << "Oprima cualquier tecla para salir";
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,&regs,&regs); // 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,&regs,&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.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 << " ";
}
}
return;
}
Fig. 4.4 .- Manejo del mouse
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:
void zMouseDetect(struct mdata *Mptr); /* INICIALIZAR SI SE ENCUENTRA */

void zMouseInit(struct mdata *Mptr); /* INICIALIZA EL DRIVER */
void zMouseShow(struct mdata *Mptr); /* MUESTRA EL CURSOR */
void zMouseHide(struct mdata *Mptr); /* ESCONDE EL CURSOR */
void zMousePos(struct mdata *Mptr); /* COLOCA LAS COORDENADAS x,y */
void zMouseInfo(struct mdata *Mptr); /* CHECA LA POSICION Y EL BOTON */
void zMouseHLimit(struct mdata *Mptr); /* COLOCA EL RANGO HORIZONTAL */
void zMouseVLimit(struct mdata *Mptr); /* 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; /* PARA EL CONTENIDO DE REGISTROS*/
#endif
#ifdef SII
struct mdata /* ESTRUCTURA DE DATOS DE MOUSE */
{
int MouseFlag;
int MouseButton;
int MouseX;
int MouseY;
int MouseMinX;
int MouseMaxX;
int MouseMinY;
int MouseMaxY;
}MouseParams;
#endif SII
void zMouseDetect(struct mdata *Mptr); /* INICIALIZAR SI SE ENCUENTRA */

void zMouseInit(struct mdata *Mptr); /* INICIALIZA EL DRIVER */
void zMouseShow(struct mdata *Mptr); /* MUESTRA EL CURSOR */
void zMouseHide(struct mdata *Mptr); /* ESCONDE EL CURSOR */
void zMousePos(struct mdata *Mptr); /* COLOCA LAS COORDENADAS x,y */
void zMouseInfo(struct mdata *Mptr); /* CHECA LA POSICION Y EL BOTON */
void zMouseHLimit(struct mdata *Mptr); /* COLOCA EL RANGO HORIZONTAL */
void zMouseVLimit(struct mdata *Mptr); /* 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)
{
inregs.x.ax=0;
int86(zMOUSE,&inregs,&outregs);
Mptr->MouseFlag=outregs.x.ax;
regs.x.ax=0; /* FUNCION #0 DEL MOUSE */
int86(zMOUSE,&regs,&regs); /* 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)
{
inregs.x.ax=1;

#endif
return;
}
/* FUNCION PARA NO MOSTRAR EL CURSOR DEL MOUSE : */

void zMouseHide(struct mdata *Mptr)
{
inregs.x.ax=2;
#endif
return;
}
/* FUNCION PARA DETERMINAR LA UBICACION DEL MOUSE Y EL ESTADO DE BOTONES :*/

void zMouseInfo(struct mdata *Mptr)
{
inregs.x.ax=3;
Mptr->MouseButton=outregs.x.bx;
Mptr->MouseX=outregs.x.cx;
Mptr->MouseY=outregs.x.dx;
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)
{
inregs.x.ax=4;
inregs.x.cx=Mptr->MouseX;
inregs.x.dx=Mptr->MouseY;
regs.x.cx=Mptr->MouseX; /* COLOCA LA COORDENADA EN x */
regs.x.dx=Mptr->MouseY; /* COLOCA LA COORDENADA EN y */
#endif
return;
}
/* FUNCION PARA COLOCAR EL RANGO HORIZONTAL MINIMO Y MAXIMO : */

void zMouseHLimit(struct mdata *Mptr)
{
inregs.x.ax=7;
inregs.x.cx=Mptr->MouseMinX;
inregs.x.dx=Mptr->MouseMaxX;
regs.x.cx=Mptr->MouseMinX; /* COLOCA LA MINIMA COORDENADA x */
regs.x.dx=Mptr->MouseMaxX; /* COLOCA LA MAXIMA COORDENADA x */
#endif
return;
}
/* FUNCION PARA COLOCAR EL RANGO VERTICAL MINIMO Y MAXIMO : */

void zMouseVLimit(struct mdata *Mptr)
{
inregs.x.ax=8;
inregs.x.cx=Mptr->MouseMinY;
inregs.x.dx=Mptr->MouseMaxY;
regs.x.cx=Mptr->MouseMinY; /* COLOCA LA MINIMA COORDENADA y */
regs.x.dx=Mptr->MouseMaxY; /* COLOCA LA MAXIMA COORDENADA y */
#endif
return;
}
Fig. 4.5.- Encabezado LIBMOUSE.H
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.
Inicializar el monitor en modo grfico

Para habilitar el monitor en modo grfico y utilizar sus pxeles, es necesario incluir
el encabezado GRAPHICS.H que contiene las declaraciones y funciones relacionadas
con graficacin e inicializar el monitor en modo grfico y utilizar sus pxeles con la
funcin initgraph(). Dicha funcin requiere las siguientes declaraciones:
int monitor=DETECT; // Variable para detectar el tipo de monitor

int modo; // Modo de operacin del monitor
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.
/*
Programa para inicializar el monitor en modo grafico

*/
#include <graphics.h> // Encabezado con declaraciones de graficos

#include <conio.h> // Para el uso de kbhit()
#include <stdlib.h> // Para el uso de random()
#include <dos.h> // Para el uso de 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)

}
Fig. 5.1.- Inicializar el monitor en modo grfico
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.
Lneas, figuras geomtricas, colores y rellenos

Sera muy difcil considerar todas las opciones posibles de todas las funciones de
graficacin; sin embargo, en estos apuntes se tratan los temas fundamentales para
implementar este tipo de funciones. Bsicamente mostraremos que antes de utilizar un
color, un tipo de lnea, de relleno, etc. es necesario definirlo con anterioridad.
El programa de la Fig. 5.2 es un claro ejemplo del uso de lneas, figuras
geomtricas elementales, colores y rellenos.
/*
Programa para graficar figuras geometricas, lineas, texto, colores y rellenos

*/

#include <conio.h>
#include <stdio.h>
void main(void)
{
int monitor=DETECT, modo; // Declaracion de tipo de monitor y modo
// Automaticamente detecta el tipo de monitor
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
// 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();
return;
}
Fig. 5.2.- Lneas, figuras geomtricas, colores y rellenos.
Programa fuente con los escudos del Tec y de ISC

El cdigo fuente del programa de la Fig. 5.3 muestra la forma de dibujar el escudo
del Instituto Tecnolgico de Nuevo Laredo y el escudo de la carrera de Ingeniera en
Sistemas Computacionales (ISC), apoyndose en el encabezado de la Fig. 5.4.
/*
Programa para graficar los escudos del Tec y de ISC
*/

#include <conio.h>
#include <stdio.h>
#include <tec.h> // Encabezado desarrollado por el programador con el
// codigo fuente de los escudos del Tec y de ISC
void main(void)
{
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();
return;
}
Fig. 5.3.- Programa fuente con los escudos del Tec y de ISC
/* 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);
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);
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);
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);
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);
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;
}
Fig. 5.4.- 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, reales, caracteres, cadenas, registros, o cualquier estructura de datos,
tambin es posible almacenar en un archivo una imagen que se despliega en la
pantalla. Para ello es necesario capturar en memoria la imagen que se desea grabar
usando un apuntador y apoyndose en las declaraciones de la Fig. 5.5 y las funciones
mostradas en la Fig. 5.6.
Declaracin Uso
long tamano; Variable de tipo entero largo para calcular el tamao en bytes
de la imagen que se desea archivar.
char far *imagen; Apuntador para capturar en memoria la imagen (puede ser
direccionada hasta 1 MB)
FILE *alias_archivo Declaracion del alias para el archivo.
Fig. 5.5 .- Declaraciones necesarias para archivar una imagen
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.
Funcin de manejo de archivos Uso

alias_archivo=fopen(IMAGEN.IMG,wb) 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
/*
Programa para graficar el escudo del Tec, grabarlo en un archivo para
cargarlo y desplegarlo posteriormente

*/

#include <conio.h>
#include <stdio.h>
#include <alloc.h> // Para usar la funcion farmalloc
#include <string.h>
#include <tec.h> // Encabezado desarrollado por el programador con el
// codigo fuente de los escudos del Tec y de ISC
void main(void)
{
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;
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
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();
return;
}
Fig. 5.6.- Programa para archivar una imagen.
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.

Tecnicas Avanzadas de Programacion en Lenguaje C++ PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Tecnicas Avanzadas de Programacion en Lenguaje C++ PDF

Cargado por

Copyright:

Formatos disponibles

SEP SEIT DGIT

INSTITUTO TECNOLGICO DE NUEVO LAREDO

INGENIERA EN SISTEMAS COMPUTACIONALES

MiniTaller: Tcnicas avanzadas de programacin en

Instructor: M.C. Bruno Lpez Takeyas

Noviembre del 2002

2.- Configuracin del compilador

4.- Uso de los recursos del sistema

1.- USO DEL EDITOR Y COMPILADOR

Trace into (ejecucin lnea por lnea) (F7)

Fig. 1.1.- Ventana de ejecucin de programas.

Step over (ejecucin por subrutinas o funciones) (F8)

Program reset (interrumpir la ejecucin paso a paso de

Se utiliza esta opcin cuando se desea interrumpir la ejecucin y depuracin de

Inspect (inspeccionar variables) (Alt-F4)

Fig. 1.2.- Depurar.

Fig. 1.3.- Inspeccionar variables

Evaluate/Modify (evaluar y modificar variables) (Ctrl-F4)

Fig 1.4.- Evaluar/Modificar variables.

Add watch (agregar vista para monitorear variables)

Fig. 1.5.- Vistas de variables.

Fig. 1.6.- Ventana de monitoreo de algunas variables.

Toggle breakpoint ( agregar/eliminar punto de ruptura)

Esta opcin permite establecer o eliminar puntos de ruptura, es decir, cuando se

Fig. 1.7. Breakpoint.

2.- CONFIGURACIN DEL COMPILADOR

Es importante conocer las opciones de configuracin del compilador para

Fig. 2.1.- Configuracin de los modelos de memoria.

Existen los siguientes modelos de memoria (Fig. 2.2):

Fig 2.2.- Modelos de memoria

Fig. 2.3.- Directorios.

Fig. 2.4. Grabar la configuracin del compilador.

Bsicamente una Subrutina es un segmento de cdigo que se escribe slo una

Cuando se desee que una funcin

Variables locales y globales

Usando argumentos para pasar datos a subrutinas

int PROCESO(int x, float y) Argumentos

Se pueden enviar varios argumentos a una subrutina, sin embargo es necesario

Recibiendo un valor de una funcin

en el caso anterior, la variable a recibe el valor calculado por la funcin PROCESO,

Paso de argumentos por referencia

MiniTaller: Tecnicas avanzadas de programacion en Lenguaje C++

void RUTINA(int *y); // Declaracion del procedimiento RUTINA que acepta

RUTINA(&x); // Envio de la direccion de x como argumento

cout << "\n\n\n\r Despues de la rutina x=" << x;

void RUTINA(int *y)

Fig. 3.1.- Paso de argumentos por referencia

Todos los arreglos se pasan por

Fig. 3.2.- Apuntadores como receptores de direcciones

El programa de la Fig. 3.3 muestra una aplicacin tpica de envo de argumentos

MiniTaller: Tecnicas avanzadas de programacion en Lenguaje C++

#define TOP 10 // Cantidad de elementos en el arreglo

void SORTEADOR(int B[TOP]); // Declaracion del que acepta el arreglo B

void IMPRIME(int B[TOP]); // Procedimiento que imprime los elementos

cout << "\n\rArreglo antes de sortearlo ...";

SORTEADOR(A); // Procedimiento para ordenar el arreglo A en forma ascendente

cout << "\n\n\n\rArreglo despues de sortearlo ...";

void IMPRIME(int B[TOP])

void SORTEADOR(int B[TOP])

Fig. 3.3.- Sorteador de un arreglo

MiniTaller: Tecnicas avanzadas de programacion en Lenguaje C++

#define CAPTURAR_ELEMENTOS // Bandera para activar/desactivar la compilacion

#define TOP 10 // Cantidad de elementos en el arreglo

int86(int intnum, union REGS in, union REGS out)

void zMouseDetect(struct mdata Mptr); / INICIALIZAR SI SE ENCUENTRA */

void zMouseDetect(struct mdata Mptr); / INICIALIZAR SI SE ENCUENTRA */