Técnicas avanzadas de programación en Lenguaje C++

SEP
SEIT
DGIT
INSTITUTO TECNOLÓGICO DE NUEVO LAREDO
INGENIERÍA EN SISTEMAS COMPUTACIONALES
MiniTaller: “Técnicas avanzadas de programación en
Lenguaje C++”
Instructor: M.C. Bruno López Takeyas
Jefe del Centro de Cómputo
Noviembre del 2002
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
4.- Uso de los recursos del sistema
Registros de la CPU....................................................................................................
Interrupciones..............................................................................................................
Función int86().............................................................................................................
Desapareciendo el cursor............................................................................................
Aplicaciones usando el mouse....................................................................................
19
20
20
21
23
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...................................................
28
28
29
30
31
Archivar y cargar una imagen...................................................................................... 35
BIBLIOGRAFÍA............................................................................................................ 39
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
1.- 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. 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 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 ejecución para realizar
las pruebas a dichos programas. A continuación se muestran las herramientas que
presenta Turbo C++ para esto.
Trace into (ejecución línea por línea) (F7)
La ventana de Run (ejecución) (Fig. 1.1) contiene varias herramientas para
ejecutar programas paso a paso. La herramienta “Trace into” ejecuta paso a paso un
programa, es decir, línea por línea de código. Para lograr esto, sólo basta oprimir la
tecla F7 cada vez que se requiera ejecutar una línea de código.
Fig. 1.1.- Ventana de ejecución de programas.
Step over (ejecución por subrutinas o funciones) (F8)
Esta herramienta también ejecuta paso a paso un programa, pero a diferencia del
“Trace into” no lo hace línea por línea, sino por subrutinas o funciones; es decir, si en el
código se encuentra el llamado a una subrutina, la ejecuta completamente sin llamarla
www.itnuevolaredo.edu.mx/takeyas
4
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
línea por línea. Para lograr esto sólo basta oprimir la tecla F8 cada vez que se requiera
ejecutar la siguiente subrutina o función.
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. Basta oprimir la combinación de teclas Ctrl-F2.
Inspect (inspeccionar variables) (Alt-F4)
Turbo C++ muestra varias herramientas para monito rear variables (Fig. 1.2). La
opción “Inspect” permite inspeccionar variables, es decir, monitorear su valor, su tipo y
la dirección donde se aloja en memoria (Fig. 1.3).
Fig. 1.2.- Depurar.
www.itnuevolaredo.edu.mx/takeyas
5
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
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 ejecución.
Fig 1.4.- Evaluar/Modificar variables.
www.itnuevolaredo.edu.mx/takeyas
6
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
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
ejecución. 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.
www.itnuevolaredo.edu.mx/takeyas
7
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
Toggle breakpoint ( agregar/eliminar punto de ruptura)
(Ctrl-F8)
Esta opción permite establecer o eliminar puntos de ruptura, es decir, cuando se
desea ejecutar un programa paso a paso a partir de alguna línea de código, se
establece un breakpoint (se marca la línea de código con una franja roja), 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.7).
Fig. 1.7. Breakpoint.
www.itnuevolaredo.edu.mx/takeyas
8
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
2.- CONFIGURACIÓN DEL COMPILADOR
Es importante conocer las opciones de configuración del compilador para
optimizar el rendimiento de nuestros programas. En esta sección se verá brevemente
las diversas formas de configuración.
Modelos de memoria
La Fig. 2.1 muestra la ventana de configuración de los modelos de memoria del
compilador.
Fig. 2.1.- Configuración 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
dirección. Esto significa que se cuenta con 64K de memoria para código, datos y pila.
Small: Se usa este modelo de memoria para aplicaciones de tamaño regular. Los
segmentos de código y de datos son diferentes y no se empalman, ya que se cuenta
con 64K de memoria para el código y 64K para datos y la pila.
www.itnuevolaredo.edu.mx/takeyas
9
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
Medium: Este modelo se utiliza cuando se tiene un programa de gran tamaño que no
maneja muchos datos en memoria. Los apuntadores lejanos se utilizan para el código
pero no para los datos, es decir, se tienen 64K para datos y pila, pero el código puede
ocupar hasta 1MB de memoria.
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.
En este caso se usan apuntadores lejanos para los datos pero no para el código, 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 código, otorgándoles 1MB de memoria
a cada uno.
Huge: También se usa este modelo para aplicaciones muy grandes, sólo que permite
varios segmentos de datos de 64K cada uno, hasta 1MB de código 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 búsqueda de las
utilerías del compilador, además se define el subdirectorio donde se grabarán los
programas objeto y los ejecutables producto de la ejecución de los programas.
www.itnuevolaredo.edu.mx/takeyas
10
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
Fig. 2.3.- Directorios.
Guardar configuración
para
2.4
Una vez que se modifica la configuración del compilador, es necesaria grabarla
mantenerla
en
compilaciones
futuras
(Fig.
Fig. 2.4. Grabar la configuración del compilador.
www.itnuevolaredo.edu.mx/takeyas
11
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
3.- 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. Existen dos tipos:
Procedimientos y Funciones.
?
Procedimientos
?
Funciones
Subrutinas
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 declaración
void().
P. ejem.
void Rutina(void);
void TAREA(void);
Funciones
A diferencia de los procedimientos, 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().
P. ejem.
int SUMA(void);
// Devuelve un valor de tipo entero
float CALCULA(void); // Devuelve un valor de tipo real
Limitación de return()
La cláusula return() sólo devuelve un valor. Si se desea que la función devuelva
más de un valor debe usarse otro mecanismo.
www.itnuevolaredo.edu.mx/takeyas
12
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
TIP
M.C. Bruno López Takeyas
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. Se pueden declarar variables
globales declarándolas fuera de cualquier función. Cualquier función puede acceder a
ellas sin tener en cuenta en qué función esté dicha expresió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. 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 función
Una vez que se invoca una función es necesario utilizar la variable capaz de
recibir el valor calculado por ésta, la cual debe ser del mismo tipo de la función. P.
Ejem.
a=PROCESO(3, 5.25);
www.itnuevolaredo.edu.mx/takeyas
13
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
en el caso anterior, la variable “a” recibe el valor calculado por la función “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 sólo se ha analizado el envío de valores, pero también se
puede enviar la dirección 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
www.itnuevolaredo.edu.mx/takeyas
14
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
Todos los arreglos se pasan por
referencia a una subrutina
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 dirección de memoria) a un procedimiento llamado
RUTINA, quien recibe dicha dirección con una variable apuntador a un valor entero (y).
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), 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
3
x
1401
y
Fig. 3.2.- Apuntadores como receptores de direcciones
El programa de la Fig. 3.3 muestra una aplicación típica de envío 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
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
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
Compilación condicional
Las directivas del preprocesador #if, #ifdef, #ifndef, #else, #elif, #endif,
compilarán selectivamente varias porciones de un programa. La idea general es que si
la expresión después de #if, #ifdef o #ifndef es cierta, entonces el código 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
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
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
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
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.- Compilación condicional
Encabezados creados por el programador (archivos *.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++. Regularmente se encuentran almacenados en el subdirectorio \INCLUDE. Es
posible colocar estatutos en el listado de programas que no son código de
programación 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 incluídas en el
código fuente de los programas antes de compilarse. Sin embargo, el programador
puede diseñar segmentos de código (regularmente con subrutinas) que utiliza
repetidamente en sus programas, es entonces cuando surge la necesidad de crear
archivos de encabezados que sólo incluye en sus programas cada vez que los necesita,
basta con codificar las rutinas y grabarlas en un archivo con extensión 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.
www.itnuevolaredo.edu.mx/takeyas
18
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
4.- 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, sistema operativo y entorno tiene sus propios métodos de
acceder a los recursos del sistema. Para efectos didácticos 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
información para procesar o el programa de control (Fig. 4.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,
comparaciones e instrucciones de bifurcación 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 código actual, el DS el segmento
actual de datos, el ES el segmento extra y el SS el segmento de pila.
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.
Registros de Propósito General
AH
AL
AX
BH
CH
CL
DH
DL
CX
BL
BX
DX
Registros de puntero e índice
SP
Puntero de pila
SI
Ïndice fuente
BP
DI
Puntero base
www.itnuevolaredo.edu.mx/takeyas
Índice destino
19
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
Registros de segmento
CS
Segmento de código
SS
DS
ES
Segmento de pila
Segmento de datos
Segmento extra
Registro de propòsito especial
IP
Registro de indicadores
Puntero de instrucciones
Fig. 4.1. Registros de la CPU
Interrupciones
Una interrupción es un tipo especial de instrucción que provoca la parada de la
ejecución del programa, 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.
Después de que acabe la rutina, 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. La CPU permite a un programa ejecutar una interrupción
software por la instrucción INT. El número que sigue a la instrucción determina el
número de la interrupción. Por ejemplo, INT 21h provoca la interrupción 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 interrupción
se asocia a una categoría de servicios a las que accede que son determinados por el
valor del registro AH. Si se necesita información adicional se pasa en los registros AL,
BX, CX y DX.
Función int86()
La función int86() de Turbo C++ se usa para ejecutar una interrupción de
software. Se declara como
int86(int intnum, union REGS *in, union REGS *out)
El número de la interrupción en esta función es intnum, in es una unión que
contiene los registros que se usarán para pasar la información a los manejadores de la
www.itnuevolaredo.edu.mx/takeyas
20
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
interrupción y out es una unión que guardará los valores devueltos por la interrupción
(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 unión 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 número 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
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
/*
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 tama¤o
// 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 tama¤o
// 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 función int86().
www.itnuevolaredo.edu.mx/takeyas
22
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
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. El programa
de la Fig. 4.4 muestra un ejemplo de la forma de implementar el mouse.
/*
Programa para usar el mouse
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();
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 << "
}
www.itnuevolaredo.edu.mx/takeyas
23
";
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
}
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 botón izquierdo o en BX=2 si se oprimió el botón
derecho.
En la Fig. 4.5 se muestra un encabezado (LIBMOUSE.h) que contiene las
declaraciones necesarias y la mayoría de los servicios necesarios para utilizar el mouse
en un programa. Sólo basta incluirlo como mediante la siguiente línea de código:
#include “LIBMOUSE.h”
Las rutinas contenidas en este encabezado son:
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
*/
*/
*/
*/
*/
*/
*/
*/
/* LIBRERIA ................................................ LIBMOUSE.H
Librer¡a del programa GRAF_ECA (Graficador de Diagramas Electr¢nicos
Bruno L¢pez Takeyas . 86100233 . ISC .
Instituto Tecnol¢gico 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
/* PARA EL CONTENIDO DE REGISTROS*/
24
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
#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
M.C. Bruno López Takeyas
/* ESTRUCTURA DE DATOS DE MOUSE
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,&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)
{
#if zCOMPILER==zQUICKC
inregs.x.ax=1;
int86(zMOUSE,&inregs,&outregs);
#elif zCOMPILER==zTURBOC
www.itnuevolaredo.edu.mx/takeyas
25
*/
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
regs.x.ax=1;
int86(zMOUSE,&regs,&regs);
#endif
return;
M.C. Bruno López Takeyas
/* 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.x.ax=2;
int86(zMOUSE,&inregs,&outregs);
#elif zCOMPILER==zTURBOC
regs.x.ax=2;
/* FUNCION #2 DEL MOUSE
int86(zMOUSE,&regs,&regs);
/* 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,&regs,&regs);
/* 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,&regs,&regs);
/* 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
*/
*/
*/
*/
*/
*/
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
#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,&regs,&regs);
#endif
return;
/*
/*
/*
/*
M.C. Bruno López Takeyas
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,&regs,&regs);
/* LLAMA LA INTERRUPCION 33 HEX
#endif
return;
}
*/
}
*/
*/
*/
*/
Fig. 4.5.- Encabezado LIBMOUSE.H
www.itnuevolaredo.edu.mx/takeyas
27
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
5.- GRAFICACIÓN
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 características como la resolución, número
posible de colores, modo texto o modo gráfico y otros elementos donde cada modo
requiere de cierto equipo (hardware).
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;
existe una cantidad específica de filas y cada fila tiene una cantidad específica de
píxeles. La cantidad de píxeles usada en la pantalla se conoce como resolución. Cada
modo gráfico tiene una resolución particular.
Inicializar el monitor en modo gráfico
Para habilitar el monitor en modo gráfico y utilizar sus píxeles, es necesario incluir
el encabezado GRAPHICS.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(). Dicha función requiere las siguientes declaraciones:
int monitor=DETECT;
int modo;
// 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; // Variable para usar el monitor tipo VGA
int modo=VGAHI; // 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().
El programa de la Fig. 5.1 muestra un ejemplo de inicialización y uso del monitor
en modo gráfico.
www.itnuevolaredo.edu.mx/takeyas
28
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
/*
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)
}
Fig. 5.1.- Inicializar el monitor en modo gráfico
Uso de coordenadas
Una vez que se inicializa el monitor en modo gráfico, las coordenadas tienen al
píxel como unidad de medida. 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.
Las funciones de gráficos tienen como estándar el orden de manejo de
coordenadas como columna, renglón; es decir, primero se anota la columna y después
el renglón para posicionarse en dicha coordenada.
www.itnuevolaredo.edu.mx/takeyas
29
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
Líneas, figuras geométricas, colores y rellenos
Sería muy difícil considerar todas las opciones posibles de todas las funciones de
graficación; sin embargo, en estos apuntes se tratan los temas fundamentales para
implementar este tipo de funciones. Básicamente mostraremos que antes de utilizar un
color, un tipo de línea, de relleno, etc. es necesario definirlo con anterioridad.
El programa de la Fig. 5.2 es un claro ejemplo del uso de líneas, figuras
geométricas elementales, colores y rellenos.
/*
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
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
// en posicion Horizontal de tama¤o 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 tama¤o 7
outtextxy(330,200,"Sanserif");// Despliega el mensaje "Sanserif" en 330,200
getch();
closegraph(); // Termina el modo grafico (vuelve a su modo normal)
return;
}
Fig. 5.2.- Líneas, figuras geométricas, colores y rellenos.
Programa fuente con los escudos del Tec y de ISC
El código fuente del programa de la Fig. 5.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), apoyándose en el encabezado de la Fig. 5.4.
/*
Programa para graficar los escudos del Tec y de ISC
MiniTaller: Tecnicas avanzadas de programacion en Lenguaje C++
Instructor: M.C. Bruno Lopez Takeyas
*/
#include
#include
#include
#include
<graphics.h> // Encabezado con declaraciones de graficos
<conio.h>
<stdio.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
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
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
/* 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
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
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
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
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
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
/*
/*
/*
/*
M.C. Bruno López Takeyas
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,
también 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 apoyándose en las declaraciones de la Fig. 5.5 y las funciones
mostradas en la Fig. 5.6.
www.itnuevolaredo.edu.mx/takeyas
35
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
Declaración
long tamano;
char far *imagen;
FILE *alias_archivo
M.C. Bruno López Takeyas
Uso
Variable de tipo entero largo para calcular el tamaño 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.
Fig. 5.5 .- Declaraciones necesarias para archivar una imagen
Función
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
específico 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 código completo.
Función de manejo de archivos
alias_archivo=fopen(“IMAGEN.IMG”,”wb”)
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
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
/*
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 tama¤o 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 tama¤o 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
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
fcloseall(); // Cierra el archivo
cout << "\n\ntama¤o=" << 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;
}
Fig. 5.6.- Programa para archivar una imagen.
www.itnuevolaredo.edu.mx/takeyas
38
[email protected]
Técnicas avanzadas de programación en Lenguaje C++
M.C. Bruno López Takeyas
BIBLIOGRAFÍA
Barkakati Nabajyoti. “The Waite Group´s. Turbo C Bible”. Howard W. Sams &
Company. Estados Unidos. 1990.
García Badell, J. Javier. "Turbo C. Programación en manejo de archivos". Macrobit.
Deitel y Deitel. “C++ Cómo programar”. Segunda edición. Pearson-Prentice Hall.
Estados Unidos. 1999.
Lafore, Robert. “The Waite Group´s. Turbo C. Programming for the
PC”. Revised Edition. Howard W. Sams & Company. Estados Unidos. 1990.
Schildt, Herbert. “Turbo C. Programación avanzada”. Segunda edición,
McGraw Hill. Estados Unidos. 1990.
Staugaard, Andrew. “Técnicas estructuradas y orientadas a objetos.
Una introducción utilizando C++”. Segunda edición. Prentice Hall.
Estados Unidos. 1998.
www.itnuevolaredo.edu.mx/takeyas
39
[email protected]