Академический Документы
Профессиональный Документы
Культура Документы
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 función............................................................................ 13
Paso de argumentos por referencia............................................................................ 14
Compilación condicional.............................................................................................. 16
Encabezados creados por el programador (archivos *.h)........................................... 18
5.- Graficación
Resolución................................................................................................................... 28
Inicializar el mo nitor en modo gráfico.......................................................................... 28
Uso de coordenadas.................................................................................................... 29
Líneas, figuras geométricas, colores y rellenos.......................................................... 30
Programa fuente con los escudos del Tec y de ISC................................................... 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
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 takeyas@itnuevolaredo.edu.mx
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.
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).
www.itnuevolaredo.edu.mx/takeyas 5 takeyas@itnuevolaredo.edu.mx
Técnicas avanzadas de programación en Lenguaje C++ M.C. Bruno López Takeyas
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.
www.itnuevolaredo.edu.mx/takeyas 6 takeyas@itnuevolaredo.edu.mx
Técnicas avanzadas de programación en Lenguaje C++ M.C. Bruno López Takeyas
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).
www.itnuevolaredo.edu.mx/takeyas 8 takeyas@itnuevolaredo.edu.mx
Técnicas avanzadas de programación en Lenguaje C++ M.C. Bruno López Takeyas
Modelos de memoria
La Fig. 2.1 muestra la ventana de configuración de los modelos de memoria del
compilador.
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 takeyas@itnuevolaredo.edu.mx
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.
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 takeyas@itnuevolaredo.edu.mx
Técnicas avanzadas de programación en Lenguaje C++ M.C. Bruno López Takeyas
Guardar configuración
Una vez que se modifica la configuración del compilador, es necesaria grabarla
para mantenerla en compilaciones futuras (Fig.
2.4
www.itnuevolaredo.edu.mx/takeyas 11 takeyas@itnuevolaredo.edu.mx
Técnicas avanzadas de programación en Lenguaje C++ M.C. Bruno López Takeyas
3.- SUBRUTINAS
? 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 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 takeyas@itnuevolaredo.edu.mx
Técnicas avanzadas de programación en Lenguaje C++ M.C. Bruno López Takeyas
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.
a=PROCESO(3, 5.25);
www.itnuevolaredo.edu.mx/takeyas 13 takeyas@itnuevolaredo.edu.mx
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.
/*
Programa para el paso de argumentos por referencia
#include <conio.h>
#include <iostream.h>
void main(void)
{
int x=3;
clrscr();
cout << "\n\r Antes de la rutina x=" << x;
getch();
return;
}
www.itnuevolaredo.edu.mx/takeyas 14 takeyas@itnuevolaredo.edu.mx
Técnicas avanzadas de programación en Lenguaje C++ M.C. Bruno López Takeyas
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 3 x
1402
1403
1404
1405 1401 y
/*
Programa para ordenar un arreglo (pasandolo por referencia)
#include <conio.h>
#include <stdio.h>
#include <iostream.h>
www.itnuevolaredo.edu.mx/takeyas 15 takeyas@itnuevolaredo.edu.mx
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();
printf("\n\r");
for(i=0;i<TOP;i++)
printf("%2d ",B[i]);
return;
}
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;
}
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 takeyas@itnuevolaredo.edu.mx
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
#include <conio.h>
#include <stdio.h>
#include <iostream.h>
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
www.itnuevolaredo.edu.mx/takeyas 17 takeyas@itnuevolaredo.edu.mx
Técnicas avanzadas de programación en Lenguaje C++ M.C. Bruno López Takeyas
printf("\n\r");
for(i=0;i<TOP;i++)
printf("%2d ",B[i]);
return;
}
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;
}
#include “c:\\tarea\\CAPTURA.h”
www.itnuevolaredo.edu.mx/takeyas 18 takeyas@itnuevolaredo.edu.mx
Técnicas avanzadas de programación en Lenguaje C++ M.C. Bruno López Takeyas
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:
BH BL DH DL
BX DX
BP DI
Puntero base Índice destino
www.itnuevolaredo.edu.mx/takeyas 19 takeyas@itnuevolaredo.edu.mx
Técnicas avanzadas de programación en Lenguaje C++ M.C. Bruno López Takeyas
Registros de segmento
CS SS
Segmento de código Segmento de pila
DS ES
Segmento de datos Segmento extra
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
www.itnuevolaredo.edu.mx/takeyas 20 takeyas@itnuevolaredo.edu.mx
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;
};
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
www.itnuevolaredo.edu.mx/takeyas 21 takeyas@itnuevolaredo.edu.mx
Técnicas avanzadas de programación en Lenguaje C++ M.C. Bruno López Takeyas
/*
Programa para desaparecer el cursor usando la funcion int86()
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\n\n\n\r<<< Oprima cualquier tecla para aparecer el cursor >>>";
getch();
cout << "\n\n\n\n\n\rApareciendo el cursor ...";
cout << "\n\n\n\n\r<<< Oprima cualquier tecla para aparecer el cursor >>>";
getch();
return;
}
www.itnuevolaredo.edu.mx/takeyas 22 takeyas@itnuevolaredo.edu.mx
Técnicas avanzadas de programación en Lenguaje C++ M.C. Bruno López Takeyas
/*
Programa para usar el mouse
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";
if(regs.x.bx==1)
{
gotoxy(20,12); cout << "Boton izquierdo";
gotoxy(20,12); cout << " ";
}
if(regs.x.bx==2)
{
gotoxy(40,12); cout << "Boton derecho";
gotoxy(40,12); cout << " ";
}
www.itnuevolaredo.edu.mx/takeyas 23 takeyas@itnuevolaredo.edu.mx
Técnicas avanzadas de programación en Lenguaje C++ M.C. Bruno López Takeyas
}
return;
}
El programa de la Fig. 4.4 inicializa primero el mouse invocando la INT 33h con
el servicio AL=1. Contiene un ciclo que mientras no se oprima cualquier tecla, monitorea
constantemente el status del mouse invocando la INT 33h con el servicio AL=3, la cual
devuelve en BX=1 si se oprimió el 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”
www.itnuevolaredo.edu.mx/takeyas 24 takeyas@itnuevolaredo.edu.mx
Técnicas avanzadas de programación en Lenguaje C++ M.C. Bruno López Takeyas
#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
www.itnuevolaredo.edu.mx/takeyas 25 takeyas@itnuevolaredo.edu.mx
Técnicas avanzadas de programación en Lenguaje C++ M.C. Bruno López Takeyas
www.itnuevolaredo.edu.mx/takeyas 26 takeyas@itnuevolaredo.edu.mx
Técnicas avanzadas de programación en Lenguaje C++ M.C. Bruno López Takeyas
#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; /* FUNCION #7 DEL MOUSE */
regs.x.cx=Mptr->MouseMinX; /* COLOCA LA MINIMA COORDENADA x */
regs.x.dx=Mptr->MouseMaxX; /* COLOCA LA MAXIMA COORDENADA x */
int86(zMOUSE,®s,®s); /* LLAMA LA INTERRUPCION 33 HEX */
#endif
return;
}
www.itnuevolaredo.edu.mx/takeyas 27 takeyas@itnuevolaredo.edu.mx
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.
www.itnuevolaredo.edu.mx/takeyas 28 takeyas@itnuevolaredo.edu.mx
Técnicas avanzadas de programación en Lenguaje C++ M.C. Bruno López Takeyas
/*
Programa para inicializar el monitor en modo grafico
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)
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 takeyas@itnuevolaredo.edu.mx
Técnicas avanzadas de programación en Lenguaje C++ M.C. Bruno López Takeyas
/*
Programa para graficar figuras geometricas, lineas, texto, colores y rellenos
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());
www.itnuevolaredo.edu.mx/takeyas 30 takeyas@itnuevolaredo.edu.mx
Técnicas avanzadas de programación en Lenguaje C++ M.C. Bruno López Takeyas
getch();
closegraph(); // Termina el modo grafico (vuelve a su modo normal)
return;
}
/*
Programa para graficar los escudos del Tec y de ISC
MiniTaller: Tecnicas avanzadas de programacion en Lenguaje C++
Instructor: M.C. Bruno Lopez Takeyas
*/
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)
getch();
closegraph(); // Termina el modo grafico (vuelve a su modo normal)
return;
}
Fig. 5.3.- Programa fuente con los escudos del Tec y de ISC
www.itnuevolaredo.edu.mx/takeyas 31 takeyas@itnuevolaredo.edu.mx
Técnicas avanzadas de programación en Lenguaje C++ M.C. Bruno López Takeyas
www.itnuevolaredo.edu.mx/takeyas 32 takeyas@itnuevolaredo.edu.mx
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;
}
www.itnuevolaredo.edu.mx/takeyas 33 takeyas@itnuevolaredo.edu.mx
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 takeyas@itnuevolaredo.edu.mx
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;
}
www.itnuevolaredo.edu.mx/takeyas 35 takeyas@itnuevolaredo.edu.mx
Técnicas avanzadas de programación en Lenguaje C++ M.C. Bruno López Takeyas
Declaración Uso
long tamano; Variable de tipo entero largo para calcular el tamaño 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.
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)
www.itnuevolaredo.edu.mx/takeyas 36 takeyas@itnuevolaredo.edu.mx
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
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)
setlinestyle(DOTTED_LINE,1,1);
rectangle(250,130,390,270);
www.itnuevolaredo.edu.mx/takeyas 37 takeyas@itnuevolaredo.edu.mx
Técnicas avanzadas de programación en Lenguaje C++ M.C. Bruno López Takeyas
cout << "\nAnote las coordenadas donde desea desplegar la imagen ...";
cout << "\n\nColumna="; cin >> columna;
cout << "\n\nRenglon="; cin >> renglon;
www.itnuevolaredo.edu.mx/takeyas 38 takeyas@itnuevolaredo.edu.mx
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.
www.itnuevolaredo.edu.mx/takeyas 39 takeyas@itnuevolaredo.edu.mx