Manual de Practicas1 - POO3

LICENCIATURA EN SISTEMAS COMPUTACIONALES
MANUAL DE PRÁCTICAS
Programación Orientada a Objetos II 4 Semestre
FECHA DE ELABORACIÓN: Abril 2005
ELABORARON:
NOMBRE FIRMA
LIC. EN COMP. ISAIAS PÉREZ PÉREZ
ING. MARIO ALBERTO MAGAÑA MENDEZ
L.S.C LUIS RAMÓN MACIAS PULIDO
Vo. Bo. PRESIDENTE DE LA ACADEMIA DE SISTEMAS Y SOFTWARE DE BASE
LIC. EN COMP. Luis Islas Hernández
Vo. Bo. SECRETARIO DE LA ACADEMIA DE SISTEMAS Y SOFTWARE DE BASE
ING. Alberto Alfonso Galindo Galindo
Vo. Bo. COORDINADOR DE LA LICENCIATURA EN SISTEMAS COMPUTACIONALES

M. en C. Gonzalo Alberto Torres Samperio
FECHA DE PRÓXIMA REVISIÓN:
Página 1
Página 2
ÌNDICE
PRÁCTICA Página
PRACTICA 1. Creación de un proyecto MFC 3
PRACTICA 2. Conceptos básicos de Visual C++ 9
PRACTICA 3. Ejercicio de gestión de multas 16
PRACTICA 4. Casillas de verificación y radio botones 22
PRACTICA 5. Cuadros de diálogo 29
PRACTICA 6. Ratón y Teclado 36
PRACTICA 7. Programación y Prueba de DLL’s 41
Página 3
NOMBRE DE LA PRÁCTICA : Creación de un proyecto MFC
No. DE PRÁCTICA: 1 2
No. DE SESIONES:
No. DE INTEGRANTES MÁXIMO POR EQUIPO:2
OBJETIVO:
El alumno aprenderá a realizar un proyecto MFC, usando el Asistente de Visual

C++, AppWizard.
Página 4
MARCO TEÓRICO:
El uso del MFC de Visual C++ esta forma de programar nos va a evitar escribir
mucho código, aunque lo de Visual no se refiere a que programes de manera
visual, más bien es para crear aplicaciones visuales. El escribir código no lo vamos
a evitar, aunque si es verdad que escribiremos mucho menos que con un
programa en C o C++ para DOS. Si dispones de un programa anterior creado en C,
para DOS, es mejor que lo construyas de nuevo, porque intentar pasar un
programa DOS a Windows lleva más trabajo que hacerlo nuevo. Aquí los
programas ya no siguen un orden lineal como cuando programábamos para DOS.
Van a existir partes del programa con programación lineal y estructurada, pero
todo orientado a objetos, o mejor
dicho orientado a eventos.
Todos los ejercicios de este curso se van a realizar con Visual C++ versión 6.0.
Para ello vamos a utilizar siempre el mismo proyecto. Además vamos a utilizar
MFC, que nos va ahorrar mucho trabajo a la hora de crear un programa. En el
curso se explicarán las funciones miembro más importantes y a la clase que
pertenecen junto con un ejemplo práctico. Es imprescindible saber ya programar
en C++ aunque sea de otro sistema operativo. Conocer lo que son las clases, los
objetos, la herencia, los tipos de datos de siempre, etc. Pues después de esta
pequeña introducción comencemos.
Página 5
EQUIPO Y SOFTWARE A UTILIZAR:
PC PentiumIII con 120 mb en RAM

Sistema Operativo Windows 2000 Profesional o superior
Visual C++ y Visual Basic (Visual Estudio Profesional o Empresarioal)
PROCEDIMIENTO PARA EL DESARROLLO DE LA PRÁCTICA:
Comenzar un proyecto.
Vamos a utilizar un proyecto de tipo formulario para todos los ejercicios de este
curso. Lo primero que hay que hacer es crear un proyecto base con el
AppWizard. Ejecuta Visual C++ y en el menú File selecciona New. Como puedes
observar se abre un cuadro de diálogo con varias opciones. Selecciona la pestaña
Projects. Nuestro proyecto va a ser MFCappWizard (exe), haz un clic sobre él.
Dale un nombre al proyecto como por ejemplo Ejercicio1. A continuación pulsa
OK en el cuadro de diálogo. Observa que pasamos a otro cuadro de diálogo con
varias opciones, nosotros vamos a seleccionar en el radiobutton single (observa el
gráfico superior). Pasamos al siguiente paso.
Como no vamos a utilizar ninguna base de datos, pues seleccionamos none. El

siguiente paso (el tercero) también none. El paso cuarto se deja por defecto
como está. En el quinto paso hay que seleccionar MFC Estándar por si no
estuviera seleccionado y el radiobutton As a Shared DLL. El último paso donde
aparece una bandera de cuadros (fíjate en el dibujo siguiente) vamos a
seleccionar como clase base CformView. Con esto queda todo el trabajo del
AppWizard terminado. Recuerda los pasos, porque son los que vamos a utilizar
de aquí en adelante para todos los ejercicios de este curso.
LOS MENSAJES DE WINDOWS.
Básicamente un programa hecho para Windows funciona de la siguiente manera.

Se crea una ventana y se le asocia un procedimiento a esa ventana. Windows
funciona manejando mensajes. Cada vez que sucede un evento en Windows, es
decir, cuando se pulsa una tecla, cuando se mueve el ratón, cuando se pulsa un
botón del ratón, cuando se mueve una ventana, cuando se cierra una ventana,
etc. Windows manda un mensaje a la cola de mensajes indicando lo que ha
sucedido.
Página 6
Ejemplo:
Cuando una parte de una ventana es ocultada por otra, cuando esta última se
cierra lo que había detrás hay que volverlo a dibujar. Windows manda un
mensaje WM_PAINT indicando que necesita redibujar una parte de la pantalla. Así
ocurre con todo lo que suceda en Windows. Los que vienen de la programación
DOS, por ejemplo si esperaban una respuesta de teclado por ejemplo para
introducir un nombre, esperaban a que el usuario tecleara el nombre y a
continuación seguía el programa de una forma lineal. En la programación
Windows ya no se espera a que el usuario introduzca los datos, simplemente es
Windows el que informa que el usuario a introducido datos con un mensaje,
nosotros lo que tenemos que hacer es procesar ese mensaje. Todos los mensajes
en Visual C++ comienzan por WM_ aunque internamente sea un valor numérico,
es más fácil recordarlos si empiezan por un nombre.
El procedimiento que lleva una ventana se resuelve con un SWITCH CASE, pero
no hay que contestar a todos los mensajes que genera Windows, hay más de
doscientos. Sólo vamos a contestar a los que utilicemos, los que no utilicemos
dejamos que el sistema operativo los conteste por nosotros.
Es hora de probar el proyecto ejercicio1, recién creado. Pulsa CONTROL+F5.
Detrás de todo esto el AppWizard a creado todo un programa para nosotros sin
escribir una sola línea de código. Imagina si hubieras tenido que programar todos
esos botones línea a línea. No cabe duda que vamos a utilizar MFC para todas
nuestras aplicaciones. Este proyecto no hace nada, ya que no hemos utilizado ni
una línea de código.
RECURSOS GRAFICOS DE VISUAL C++.
Los recursos gráficos que nos proporciona Visual C++ y que vamos a utilizar se
almacenan en un archivo llamado igual que el ejercicio de nuestro proyecto, pero
con la extensión. RC. Este primer ejercicio por lo tanto se va a llamar
EJERCICIO1.RC. Fíjate en el WORKSPACE de Visual C++. Tienes tres pestañas con
las clases, recursos y ficheros de tu primer proyecto. El WORKSPACE es la
ventana situada a la izquierda del todo. Mira cada una de ellas. Nos vamos a fijar
de momento en la pestaña central, la de recursos, la que tiene un icono con una
palmera y un Sol. Tienes siete carpetas de recursos. Por orden y de arriba abajo
son: ACCELERATOR, DIALOG, ICON, MENU, STRING TABLE, TOOLBAR,
VERSION.
ACCELERATOR:
Para crear teclas virtuales aceleradoras. Ejemplo: Podemos aquí seleccionar una
Página 7
combinación de teclas para acceder a los menús que tenga nuestro programa.
DIALOG:
Por defecto hay dos diálogos dentro de la carpeta. IDD_ABOUTBOX e

IDD_EJERCICIO1_FORM. En este último se encuentra nuestro formulario principal.
Haz doble clic con el ratón sobre IDD_EJERCICIO1_FORM para acceder al
formulario. Este formulario va ser nuestra área de cliente en nuestra aplicación,
la ventana que se va a ver cuando ejecutemos el programa.
ICON:
Son los iconos que va a llevar nuestro programa. Pequeños gráficos que llevan
las ventanas o los cuadros de diálogo.
MENU:
Aquí se encuentra el menú del programa.

STRING TABLE:
Con este recurso se muestran los mensajes que aparecen en la barra de estado
del programa. Estos mensajes son los que aparecen cuando situamos el ratón
encima de la barra de herramientas, en el menú.
TOOLBAR:
Es la barra de herramientas que aparece encima del formulario con los botones
típicos: Nuevo, Abrir, Guardar, Copiar, etc.
VERSION:
Añade comentarios al programa, versión, compañía, autor, etc.

Todos estos recursos están agrupados en un fichero RC. La razón es sencilla. Te
imaginas que todos los iconos, mapas de bits, una vez creado el programa
tuvieras que buscarlos y añadirlos al proyecto terminado, seguro que alguno se
te olvidaría. Con Visual C++ no hay que preocuparse de distribuir los elementos
del programa porque ya van empaquetados en el fichero de recursos. Si tu
programa incorpora diez iconos, estos van empaquetados en el fichero de
recursos, no debes preocuparte en absoluto de ubicarlos en tu trabajo una vez
terminado.
Página 8
Página 9
CONCLUSIONES
BIBLIOGRAFÍA:
Básica :
Microsoft Visual C++ 6.0, Manual del programador.. Beck Zaratian. Mc. Graw-Hill
Complementaria:
Visual C++5 para desarrolladores. David Bennett. Editorial Prenctice-Hall. 1998
Página 10
NOMBRE DE LA PRÁCTICA : Conceptos básicos de Visual C++
No. DE SESIONES:
OBJETIVO:
El alumno aprenderá y usará el formulario, variables, código a botones y cuadros de mensaje.
Página 11
MARCO TEÓRICO:
El manejo de formularios, variables y botos en un lenguaje visual es muy

importante. Ya que es la base de la elaboración de presentaciones en VC++, el
cual nos proporciona este tipo de herramientas las cuales tienes por objetivo
creación misma de la clase representativa, así como la introducción de eventos o
funciones para la elaboración de tareas especificas como eventos.
Página 12

PRIMEROS PASOS CON EL FORMULARIO.
Selecciona la carpeta DIALOG del WORKSPACE y haz doble clic en

IDD_EJERCICIO1_FORM. A la derecha tienes el formulario con un texto estático
que dice: A HACER: Coloca aquí controles de cuadro de diálogo. Márcalo y
suprímelo. Tienes que tener una barra de herramientas con los controles que te
proporciona el compilador. Tienes para hacer texto estático como el que has
borrado, introducción de texto, botones y todos los controles necesarios que lleva
un formulario o un cuadro de diálogo.
En nuestro primer ejercicio lo que vamos hacer es escribir un texto en una caja
de diálogo y mostrarlo en otra al pulsar un botón.
Crea dos EDITBOX. Para saber cual es, sitúa el ratón encima de los controles y sin
mover el puntero espera a que salga la leyenda con el nombre del recurso. Es el
Página 13
que tiene la ab con la raya vertical a un lado. Luego crea dos botones uno que
ponga mostrar y el otro salir.
Con el botón derecho del ratón podemos acceder a las propiedades del recurso
que queramos del formulario. Haz un clic sobre uno de los botones del formulario
y pulsa el botón derecho del ratón. En el menú emergente que sale selecciona
PROPERTIES, son las propiedades del botón, el identificador del botón, texto del
botón, etc. En CAPTION puedes cambiar el nombre del botón. Con los EDITBOX
pasa los mismo, con el botón derecho podemos acceder a las propiedades. A uno
de los EDITBOX, en estilo le vamos a seleccionar como READ ONLY. Marca esa
casilla de chequeo y observa el EDITBOX. Ahora en este control no podemos
escribir, es de solo lectura, aparece el fondo en gris en lugar de blanco. Puedes
ejecutar el programa tal y como está (CONTROL+F5). Detrás de todo esto que
escribimos al principio se ha construido una aplicación aunque nuestros controles
todavía no hagan nada.
CONECTA VARIABLES A LOS CONTROLES.
Puedes conectar o asociar variables a los controles con ayuda del APP
CLASSWIZARD. De la misma manera que accedíamos a las propiedades de los
controles, podemos acceder al CLASSWIZARD. Elige el EDITBOX que habíamos
dejado de solo lectura y pulsa el botón derecho. Selecciona APP CLASSWIZARD.
Lo que hace APP CLASSWIZARD es conectar componentes con código de
programa. Dentro del APP CLASSWIZARD selecciona variables miembro, porque
lo que vamos hacer es añadir una variable, a ese control, a continuación haz clic
en el botón AñADIR VARIABLE. Por defecto el nombre de la variable va a
comenzar por m_, te recomiendo no lo cambies para recordar que se trata de una
variable miembro. Llámala
por ejemplo m_dato1, categoría
VALUE y el tipo CString. Haz lo
mismo con el otro EDITBOX y
llama a la variable m_dato2.
El último EDITBOX con la
variable m_dato2 recuerda
del control hacerlo READ ONLY
en las propiedades.
Página 14
AÑADE CÓDIGO A UN BOTÓN.
Para añadir código a un botón haz doble clic sobre el botón que hayas puesto en
el formulario. Observa como se abre un cuadro de diálogo con un nombre para la
función miembro llamada Onbutton1 o con el número que sea si es que hay más
botones. Pulsa OK y entre las llaves escribes el código que va a ejecutar el botón.
Ejemplo:
void CEjercici1View::OnButton3()
{
// TODO: Add your control notification handler code here
}
Todo lo que escribas entre las llaves es lo que va a suceder cuando pulses el
botón en el formulario. Pues como lo que queríamos es que lo que escribas en el
EDITBOX1 salga en el EDITBOX2 escribimos entonces el siguiente código.
{
UpdateData(true);
m_dato2=m_dato1;
UpdateData(false);
}
Página 15
La primera línea tiene una función miembro hasta ahora desconocida pero que va
a ser muy útil en el futuro.
UpdateData(): Esta función requiere un parámetro con dos valores, verdadero o
falso. Con UpdateData(true) lo que hacemos es coger lo que haya en el
formulario y volcarlo a las variables que tenga asociadas. Por ejemplo: Lo que el
usuario haya escrito en el EDITBOX lo lleva a la variable miembro que tenga
asociada, en nuestro caso a m_dato1, que es de tipo CString. La siguiente línea
es conocida, simplemente le pasamos lo que tenga m_dato1 a m_dato2. Al final
volvemos a utilizar UpdateData(false). Con esto último lo que conseguimos es el
efecto contrario a TRUE, es decir, mandamos el contenido de las variables
miembro al formulario. Recuerda que con CLASSWIZARD creamos variables
miembro asociadas a los controles y con UpdateData() recuperamos o llevamos
los valores escritos o que escribamos.
Todo este código se encuentra en el fichero EJERCICIO1VIEW.CPP. Ahora lo que
vamos añadir es un botón de salida para poder regresar al sistema operativo.
Como ya sabes como crear una función miembro de un botón es la hora de
hacerlo. Haz doble clic sobre el botón que quieres utilizar para salir al sistema
operativo y crea una función miembro. El código que tienes que escribir es el
siguiente:
{
PostQuitMessage(0);
}
Otra función miembro que no hemos visto hasta ahora es PostQuitMessage(0);
Con ella mandamos un mensaje a Windows indicando que queremos abandonar
el programa y regresar al sistema operativo. Ejecuta tu programa con
CONTROL+F5 y escribe algo en el EDITBOX y observa el funcionamiento. Rápido
verdad.
MOSTRAR UN MESSAGE BOX.
Un MESSAGE BOX es un diálogo básico con información con uno o varios botones
con un aviso para el usuario. La función devuelve un entero con el tipo de
respuesta del usuario.
int MessageBox(mensaje, titulo, estilo);
El mensaje es una cadena con el texto que va aparecer en el MESSAGEBOX.

Título es, el título de la ventana y el estilo, el estilo del MESSAGEBOX, en el
Página 16
ejemplo MB_YESNO es el estilo, muestra dos botones uno para aceptar y otro
para cancelar. Existen diversos estilos. El entero que devuelve nos sirve para
identificar que botón se ha pulsado. Modifica el programa del ejercicio1 con el
código siguiente.
{
int respuesta;
char mensaje[80];
sprintf(mensaje,"¿Deseas realmente salir?");
respuesta=MessageBox(mensaje,"¡¡¡Aviso!!!",MB_YESNO);
if(respuesta==IDYES)
PostQuitMessage(0);
}
Ahora nuestro botón de regreso al sistema operativo pide confirmación al usuario

antes de abandonar el programa.
Página 17
CONCLUSIONES
BIBLIOGRAFÍA:
Básica :
Complementaria:
Página 18
NOMBRE DE LA PRÁCTICA : Ejercicio de gestión de multas
No. DE SESIONES:
OBJETIVO:
El alumno aprenderá y realizará un primer ejercicio demostrativo en Visual C++.
Página 19
MARCO TEÓRICO:
Realizar operaciones en un sistema es de importancia ya que existen varias formas

de hacer lo con la programación orientada a objetos los el objetivo se cumple
utilizando las clases y funciones propuestas.
Página 20

EJERCICIO GESTIÓN DE MULTAS.
Tenemos que calcular los días que han transcurrido desde que nos pusieron la
multa. Si la multa está comprendida entre 1 y 90 días añadimos un 5% de
recargo. De 91 a 180 días un 10% de recargo. De 181 a 250 días 15% de recargo
y más de 250 días el 20% de recargo. Los 20 primeros días no van a contar
Aquí es muy útil el uso de CTimeSpan para calcular y operar con días. Pues
manos a la obra. Tenemos que declarar todos los datos que va a llevar el
programa. En OnInitialUpdate() escribimos el siguiente código
void CMultasView::OnInitialUpdate()
{
CTime fecha;
fecha=fecha.GetCurrentTime();
m_annomulta=1999;
m_mesmulta=1;
m_diamulta=1;
m_valorinicial=1000;
m_fecha=fecha.Format("%d/%m/%Y");
CFormView::OnInitialUpdate();
GetParentFrame()->RecalcLayout();
ResizeParentToFit();
}
Declaramos un objeto fecha de la clase CTime y obtenemos la fecha actual. Por

defecto vamos a inicializar la fecha más antigua de las multas en el 01/01/1999
para poder realizar cálculos a partir de entonces, esta fecha se puede cambiar.
También el importe mínimo de la multa que en nuestro programa va a ser 1000
ptas. Formateamos la fecha y la mandamos a m_fecha que es de tipo CString, los
demás son de tipo long excepto el valor de la multa que es de tipo int
Página 21
Pues bien, con esto ya están inicializados los datos y obtenida la fecha del
sistema. Ahora como necesitamos un botón para hacer los cálculos lo
implementamos, el código que lleva es el siguiente.
void CMultasView::OnButtonCalcular()
{
UpdateData(true);
int recargo;
CTime fecha;
fecha = fecha.GetCurrentTime();
//controlar que la fecha no se desborde
if(m_mesmulta>12 || m_mesmulta <1) m_mesmulta=1;
if(m_diamulta>31 || m_diamulta <1) m_diamulta=1;
if(m_annomulta>fecha.GetYear() || m_annomulta <1980) m_annomulta=1980;
//obtener la fecha de la multa
CTime fechamulta(m_annomulta,m_mesmulta,m_diamulta,0,0,0);
CTimeSpan dife;
//calcula la diferencia de fechas y obtiene los días
dife = fecha - fechamulta;
m_diasrecargo=dife.GetDays();
m_importemulta=m_valorinicial;
//calcula los recargos por días.
if(m_diasrecargo>20 && m_diasrecargo<=90)
{
recargo=m_valorinicial*5/100;
m_importemulta=m_valorinicial+recargo;
}
{
}
{
}
if(m_diasrecargo>250)
{
Página 22
}
UpdateData(false);
}
Los objetos creados de la clase CTimeSpan se diferencian de los de CTime en que

los primeros recuperan, en lugar de fechas, días entre fechas, meses entre
fechas, etc. El código de abajo muestra la manera de obtener los días
transcurridos entre dos fechas. Ten cuidado con dife.GetDays() que devuelve los
días transcurridos al realizar la resta dife = fecha – fechamulta. No devuelve el
día que es, sino los días que hay entre fecha y fecha.
CTimeSpan dife;
//calcula la diferencia de fechas y obtiene los días
dife = fecha - fechamulta;
m_diasrecargo=dife.GetDays();
Otro objeto nuevo CTime

fechamulta(m_annomulta,m_mesmulta,m_diamulta,0,0,0);
Aquí le pasamos una fecha válida para poder realizar los cálculos. Todos los
valores que le pasamos son de tipo long, en el siguiente orden: año, mes, día,
hora, minuto, segundo. Ahora fecha multa tiene un dato válido para operar con
él.
Donde controlamos que la fecha no se desborde, simplemente si lo que

escribimos, se sale de un valor lógico, automáticamente actualizamos con un
valor válido. Observa el trozo de
código un poco más atrás.
Página 23
Página 24
CONCLUSIONES
BIBLIOGRAFÍA:
Básica :
Complementaria:
Página 25
NOMBRE DE LA PRÁCTICA : Casillas de verificación y radio botones.
No. DE SESIONES:
OBJETIVO:
El alumno aprenderá y usará algunos de los controles estandar.
Página 26
MARCO TEÓRICO:
Página 27

CASILLAS DE VERIFICACIÓN Y RADIO BOTONES.

Existe una función llamada GetDlgItem(identificador del control) de la clase
CWnd, que nos sirve para obtener punteros a controles. Transferimos al puntero
el control, junto con todos sus métodos.
Ejemplo:
CEdit *caja = (CEdit *) GetDlgItem(IDC_EDIT1);
La línea anterior crea un puntero de tipo CEdit que apunta al control IDC_EDIT1,
en el caso del ejercicio anterior, apunta al EDITBOX donde se muestra la hora.
Este puntero tiene ahora todos lo métodos y propiedades de CEdit.
caja->SetFocus();
Situamos el foco en IDC_EDIT1, es decir, que el primer elemento que va a salir
remarcado es IDC_EDIT1, podemos elegir el que queramos. Mira que no
utilizamos el punto para acceder a los métodos, sino que utilizamos el operador
flecha, ya que caja se trata de un puntero.
Para poder controlar las casillas de verificación, es necesario preguntar por su
estado para hacer determinadas operaciones. Por ejemplo una casilla de
verificación, que cambie un valor de pesetas a euros, si está marcada muestra el
dinero en euros. Se me ocurre entonces hacer un ejercicio que el valor que haya
en la casilla lo pase a euros.
Para preguntar por una casilla de verificación, tenemos que obtener un puntero a
esa casilla. Los botones, radio botones y casillas de verificación, podemos
acceder a ellos a través de la clase CButton
Crea un proyecto nuevo llamado conversión y añade un EDITBOX, un botón para
calcular, un botón para salir y un EDITBOX para mostrar la conversión y por
supuesto una casilla de verificación.
El primer EDITBOX es el que vamos a utilizar para escribir la cantidad. El otro
EDITBOX lo vamos a utilizar de solo lectura, para mostrar la conversión. Por
último el botón de salir.
CButton *casilla = (CButton *) GetDlgItem(IDC_CHECK1);
int estado;
estado=casilla->GetCheck();
Página 28
La función GetCheck() que

pertenece a la clase CButton nos
devuelve verdadero o falso en
función de lo que tenga la casilla
de verificación. Hay dos maneras
de hacer esto, podemos crear
una variable miembro con
ClassWizard de tipo Control y
preguntar directamente por esa
variable o con punteros como el
ejemplo. Para que el programa funcione es necesario pulsar en calcular. Aunque
se puede implementar con un temporizador para que se pregunte por el valor de
la casilla de verificación y actúe en consecuencia. Es el programador el que tiene
que decidir que manera utilizar. A continuación tienes el código que convierte en
euros una cantidad al pulsar el botón. Nada más pulsar el botón pregunta por la
casilla de verificación, si está marcada o no. Existen además dos variables
miembro de tipo double que se llaman m_calcular y m_valor. m_calcular tiene la
cantidad a convertir y m_valor su valor en euros.
void CConversionView::OnButtonCalcular()
{
CButton *casilla = (CButton *) GetDlgItem(IDC_CHECK_CONVERSION);
int estado;
UpdateData(true);
if(estado)
//está pulsada la casilla de verificación
m_calcular=m_valor/166.386;
else
m_calcular=m_valor;
UpdateData(false);
}
Si por el contrario quieres que la conversión sea automática, sin necesidad de
pulsar ningún botón, debes implementar una función miembro de esa casilla,
haciendo doble clic encima de la casilla de verificación. Observa el aspecto del
programa.
Página 29
void CConversionView::OnCheck2()
{
CButton *casilla = (CButton *) GetDlgItem(IDC_CHECK2);
int estado;
UpdateData(true);
if(estado)
//está pulsada la casilla de verificación
m_calcular=m_valor/166.386;
else
m_calcular=m_valor;
UpdateData(false);
}
Observa que el código es el mismo que el que lleva el botón calcular, pero ahora
el código va en la función OnCheck2() .
Como he comentado antes, hay una manera más fácil de implementar una casilla
de verificación. Creas una variable miembro asociada a la casilla de verificación
de tipo control y preguntas directamente por ella.
if(m_estado)
En el siguiente ejercicio vamos a utilizar los radio botones para hacer un
programa que convierta metros en varias medidas del sistema métrico decimal.
Como siempre vamos a crear un proyecto nuevo como los anteriores, llamado
métrico. El programa va a llevar varios radio botones con las conversiones del
sistema métrico decimal y una casilla para escribir los metros. Además como ya
sabemos conseguir el estado de un control, si está pulsado o no, vamos hacer lo
contrario. Dejar marcado nada más arrancar el radio botón de los metros. El
funcionamiento es el siguiente: Escribimos los metros y mostramos el resultado
en otro EDITBOX de solo lectura.
El programa es el siguiente:
void CMetricoView::OnInitialUpdate()
{
CButton *radio = (CButton*) GetDlgItem(IDC_RADIOMETRO);
radio->SetCheck(1); //ponemos el radio boton de metros por defecto.
m_valor=1;
m_resultado=1;
}
...
void CMetricoView::OnButtonsalir()
Página 30
{
PostQuitMessage(0);
}
void CMetricoView::OnRadiomiriametro()
{
UpdateData(true);
m_resultado=m_valor/10000;
UpdateData(false);
}
void CMetricoView::OnRadiokilometro()
{
UpdateData(true);
UpdateData(false);
}
void CMetricoView::OnRadiohectometro()
{
// TODO: Add your control notification handler
code here
UpdateData(true);
UpdateData(false);
}
void CMetricoView::OnRadiodecametro()
{
// TODO: Add your control notification handler
code here
UpdateData(true);
UpdateData(false);
}
void CMetricoView::OnRadiometro()
{
UpdateData(true);
m_resultado=m_valor;
UpdateData(false);
}
void CMetricoView::OnRadiodecimetro()
Página 31
{
// TODO: Add your control //notification handler code here
UpdateData(true);
m_resultado=m_valor*10;
UpdateData(false);
}
void CMetricoView::OnRadiocentimetro()
{
// TODO: Add your control //notification handler code here
UpdateData(true);
UpdateData(false);
}
void CMetricoView::OnRadiomilimetro()
{
UpdateData(true);
UpdateData(false);
}
CONCLUSIONES
Página 32
BIBLIOGRAFÍA:
Básica :
Complementaria:
NOMBRE DE LA PRÁCTICA : Cuadros de diálogo
No. DE SESIONES:
OBJETIVO:
El alumno aprenderá y manipulará los cuadros de diálogo.

Página 33
Página 34
MARCO TEÓRICO:
Página 35

LOS CUADROS DE DIALOGO.

Los cuadros de diálogo pertenecen a la clase base CDialog . Nos ofrece un
interfaz para manejar cuadros de diálogo. ClassWizard simplifica el proceso,
valida los datos e intercambia los datos entre el cuadro y la memoria. Los
cuadros de diálogo son parecidos a los formularios que hemos visto hasta ahora.
Estos tienen dos componentes: La plantilla de diálogos, que va en el fichero

resource.rc o también llamada plantilla de recursos gráficos y una clase derivada
de CDialog que la creamos con ClassWizard. Vamos a crear los proyectos igual
que antes, pero en el menú Insert de Visual C++ seleccionamos resource e
insertamos un diálogo. Una vez insertado el recurso diálog abrimos ClassWizard.
Nos obliga a crear una nueva clase. La creamos con un nombre. Han sucedido
varias cosas hasta aquí. Se ha creado un fichero nuevo llamado como la
clase.cpp y otro llamado como la clase.h Ahora debemos hacer un include en el
fichero CNombreView.cpp para que tenga efecto nuestra llamada al diálogo.
(#include "nombre.h"); El nombre.h es el nombre que le hayamos dado a la clase
base del diálogo. Puedes verlo en el Workspace, se han añadido dos archivos
nuevos, uno en source y otro en header.
Existen dos tipos de diálogo, modal y no modal. El más sencillo es el modal. Por
lo tanto es el que vamos a utilizar. Uno se distingue del otro en que cuando está
activo, la ventana principal permanece inactiva hasta que lo cerremos. Los no
modales pueden interactuar con la ventana principal. Existe una función llamada
OnInitDialog() que nos va a servir para inicializar datos en el diálogo. Es similar
a OnInitialUpdate() y va asociada al mensaje de Windows WM_INITDIALOG.
Por defecto nos crea un diálogo con dos botones, que podemos implementar de
la misma manera, que los que hemos hecho en el formulario, haciendo doble clic
sobre ellos. Se crean dos funciones miembros OnOk() y OnCancel() El primero
responde a un mensaje de tipo notificación de control. Recoge los valores del
diálogo y cierra el diálogo. El otro responde a un mensaje de notificación, cierra
el diálogo, pero no recoge ningún valor.
Página 36
La implementación de las funciones es la siguiente:
void dial::OnOK()
{
// TODO: Add extra validation here
CDialog::OnOK();
}
void dial::OnCancel()
{
// TODO: Add extra cleanup here
CDialog::OnCancel();
}
Para crear un objeto de la clase de ese diálogo simplemente hacemos lo de

siempre. La clase es el nombre que le diste cuando creaste el recurso, se llama
de la misma manera que el archivo.cpp que sirvió para almacenar el diálogo. Si
por ejemplo al crear con ClassWizard la clase de ese diálogo la llamaste dial, El
objeto lo creamos dial dialogo; No olvides poner la directiva #include "dial.h" al
principio del fichero proyectoView.cpp. Vamos hacer un ejercicio que nos pida un
nombre de usuario y una contraseña para poder entrar al programa. Para que la
contraseña salga con asteriscos lo puedes señalar al crear un EDITBOX, poniendo
el estilo, de tipo password. Vamos a tener tres oportunidades de fallar en el
diálogo.
Es decir, a la tercera vez regresamos al sistema operativo. Si ya tienes pensado

como hacerlo, no se te ocurra meter el diálogo en un bucle que cuente hasta
tres, porque cuelgas el programa y llamas sucesivamente al diálogo, utiliza un
contador y pregunta por él.
Fichero dial.h
// Dialog Data
//{{AFX_DATA(dial)
enum { IDD = IDD_DIALOG1 };
CString m_clave;
CString m_usuario;
int contador;
//}}AFX_DATA
El entero de color rojo nos va a servir para llevar la cuenta de las veces que
podemos fallar antes de volver al sistema operativo.
Página 37
Fichero dial.cpp
dial::dial(CWnd* pParent /*=NULL*/)
: CDialog(dial::IDD, pParent)
{
//{{AFX_DATA_INIT(dial)
m_clave = _T("");
m_usuario = _T("");
contador=3; }
//}}AFX_DATA_INIT
Para llamar al díalogo y ponerlo en

funcionamiento implantamos las siguientes
líneas.
void CDialogoView::OnInitialUpdate()
{
dial dialogo;
dialogo.DoModal();
}
En el fichero dial.cpp inicializo contador con el valor 3, pues estos van a ser los
intentos que puedo tener. m_clave y m_usuario son dos variables de tipo CString
que van a contener la clave y el usuario, esto se implementa con ClassWizard en
el recurso diálogo que hemos creado.
Ahora viene el código que tenemos que ejecutar cuando pulsemos el botón.
Fichero dial.cpp
void dial::OnOK()
{
// TODO: Add extra validation here
UpdateData(true);
if(m_usuario=="luis" && m_clave == "reloj")
CDialog::OnOK();
if(contador==1)
{
CDialog::OnOK();
PostQuitMessage(0);
}
contador--;
Página 38
m_usuario= "";
m_clave= "";
UpdateData(false);
}
void dial::OnCancel()
{
// TODO: Add extra cleanup here
CDialog::OnCancel();
PostQuitMessage(0);
}
Cuando pulsemos el botón de aceptar, bajamos a las variables lo que hayamos

escrito en el diálogo, el usuario y la clave. Para este ejemplo el usuario es luis y la
clave reloj. Con CDialog::OnOK(); cerramos el diálogo.
Por tanto si hemos fallado, no cerramos el diálogo y restamos uno al contador de

intentos fallidos (contador--;). Puede darse el caso de que te equivoques más de
tres veces, entonces entra en el if(contador==1) así que cierra el diálogo y
mandamos un mensaje al sistema operativo indicando que queremos regresar.
Por último el botón cancel devuelve el control al sistema operativo, es decir,

cierra nuestro programa. Un detalle importante es la forma que se visualiza
nuestro diálogo, procura que no tenga ningún botón de cerrar porque sino de
nada sirve validar el nombre y clave de usuario. Observa la figura, ves como no
tiene ningún botón de cerrar. Esto lo puedes hacer en las propiedades del
diálogo, botón derecho, en el estilo, que no esté marcado system menú.
Página 39
CONCLUSIONES
Página 40
BIBLIOGRAFÍA:
Básica :
Complementaria:
NOMBRE DE LA PRÁCTICA : Ratón y Teclado
No. DE SESIONES:
OBJETIVO:
El alumno aprenderá a realizar eventos utilizando los dispositivos de entrada como el Ratón y el Teclado
Página 41
Página 42
MARCO TEÓRICO:
Todas las aplicaciones, realizadas en una internas visual son de gran ayuda para
la programación o internas de programación, no podía faltar la realizar internas
para dibujar en un cuadro de dialogo utilizando los principales medios de entrada
como son el ratón y el teclado.
Página 43

Diseño visual del programa :
Se comienza con desarrollar o crear la interfase del programa para realizar y agregar los eventos de dibujo,
primeramente se agregan los siguientes electos:
Button: El cual se agrega con las herramientas de Controls.
Static Text: También agregado con Controls
Enseguida de agrega el evento de BN_CLICKED a el botton que contiene la internas, el cual servirá como botón
de salida o terminación.
En seguida se da el evento a el cuado de dialogo para poder utilizar el ratón y así dibujar sobre el, este evento
será WM_MOUSEMOVE , y el código agregado es el siguiente:
If ((nFlags & MK_LBUTTON) = = MK_LBUTTON )

{
CClientDC dc(this);
dc.SetPixel(point.x,
point.y,
RGB(0,0,0) );
}
de esta manera le decimos que cuando se presione el botón izquierdo del Ratón comience a dibujar.
Este código nos dibuja líneas las cuales si el Ratón es pasado rápidamente , la línea se dibuja con puntos o líneas
discontinuas.
Ese es un error el cual se corrige implementando el siguiente código:
Página 44
En la carpeta de CDibujar.h se debe de introducir dos variables las cuales servirán de punto de referencia.
int m_PrevX;
int m_PrevY;
des pues se modifica la funcion OnMouseMove(), en el archivo principal .cpp. colocando el siguiente código:
dc.MoveTo ( m_PrevX, m_PrevY );

dc.LineTo ( point.x, point.y);
m_PrevX = point.x;
m_PrevY = point.y;
y poniendo entre comentarios el código anterior
// dc.SetPixel(point.x,
// point.y,
// RGB(0,0,0) );
con esto resolvemos el problema de las líneas punteadas pero aun así las líneas se unen los puntos de donde
empieza la línea a donde termina ese también es un problema.
El cual resolveremos agregando código al evento WM_LBUTTONDOWN.
Para el cual primero creamos la función, en la clase principal y agregamos lo siguiente:
m_PrevX = point.x;
m_PrevY = point.y;
con esto resolvemos el problema y listo la función de dibujar se ejecuta de manera precisa.
Página 45
CONCLUSIONES
BIBLIOGRAFÍA:
Básica :
Complementaria:
Página 46
NOMBRE DE LA PRÁCTICA : Programación y Prueba de DLL’s
No. DE SESIONES:
OBJETIVO:
Proporcionar al alumno nuevos recursos de programación, que le permitan resolver

problemas específicos con una mayor eficacia, al conjuntar las características propias
de los diferentes lenguajes de programación (Visual C++ y Visual Basic) Se mostrará,
cómo mediante las bibliotecas de enlace dinámico, es posible usar las clases definidas
en Visual C, desde Visual Basic.
Página 47
MARCO TEÓRICO:
Las librerías de enlace dinámico son uno de los elementos principales del sistema operativo
Windows. En su concepto básico, se tratan de archivos ejecutables independientes que contienen
funciones y recursos que pueden ser llamados por los programas y por otras DLL para realizar
ciertos trabajos. Una DLL no puede ser ejecutada en forma independiente, entra en acción hasta
que un programa ú otra DLL llama a una de las funciones de la librería. El término "enlace
dinámico" se refiere al hecho de que el código que contiene la DLL se incorpora al programa
ejecutable que la llama sólo hasta el momento en que es requerido, en tiempo de ejecución, al
contrario del enlace estático que es el que se lleva a cabo durante el proceso de enlazado para
crear un programa Windows.
#define EXPORT extern "C" __declspec(dllexport)
La palabra clave EXPORT indica que las funciones están disponibles para otros programas
externos a la DLL, además se utiliza la palabra clave __declspec con el atributo dllexport para
garantizar que las funciones sean exportables a otros programas que así las requieran, con ésto al
compilar la DLL se crea un archivo de definición en donde queda especificado cuales son las
funciones disponibles para otros programas en una DLL, en otras palabras, se trata del punto de
entrada a las funciones de la DLL.
Otro punto importante a considerar es la convención de llamadas a función. Lenguajes como

C/C++ utilizan la convención __cdecl que se caracteriza por incluir un código que sirve para
realizar labores de limpieza previa (inicialización con valor igual a cero) en el stack. En
comparación, las funciones de la API de Windows utilizan la convención __stdcall la cual realiza un
decorado de los nombres de función utilizando un símbolo de subrayado seguido de @#nn donde
#nn representa el número total de bytes que se requieren en los parámetros de la función. Tanto
en la convención __cdecl como en __stdcall los argumentos de las funciones se pasan al stack de
derecha a izquierda. Se estará Usted preguntando ¿Y qué importancia tiene todo ésto? Pues bién,
resulta que en Windows se declara a las convenciones de llamadas a función WINAPI, PASCAL y
CALLBACK como de tipo __stdcall y resulta que Visual Basic utiliza la convención de tipo PASCAL
la cual no distingue entre letras mayúsculas y minúsculas, al contrario de la convención utilizada
por C/C++ que es sensible al tamaño de caja de las letras, por lo tanto los argumentos utilizados
en nuestras funciones entran en conflicto al tratar de utilizarlas desde Visual Basic. Para resolver
este inconveniente se requiere establecer una equivalencia de exportación, de ésta manera se
definen los valores de exportación así:
EXPORTS
FUNCION1=funcion1 @1
FUNCION2=funcion2 @2
Al momento de utilizar la DLL desde Visual Basic, naturalmente que debemos especificar el
nombre de las funciones, luego Visual Basic hará una conversión, por ejemplo para la función:
funcion1() Visual Basic la convertirá en una llamada similar a esta: FUNCION2() lo cual
obviamente no será reconocido por la DLL, pero como especificamos los valores de exportación
Página 48
adecuados, la llamada a función solicitada por Visual Basic será interpretada correctamente.
Usando la DLL desde Visual Basic
Lo primero que necesitamos conocer es la ruta completa para acceder a la DLL. Usted puede
colocar la DLL en el mismo directorio del proyecto Visual Basic donde esté trabajando. Para llamar a
las funciones incluidas en la DLL utilizamos la siguiente instrucción dentro de la sección de
declaraciones generales:
Private Declare Function funcion1 Lib "Rutadll\Archivo.dll" (…) As tipo_dato
Finalmente, si Usted lo desea puede colocar la DLL en el directorio System o System32 de

Windows y entonces bastará con especificar el nombre de la DLL en la declaración de las
respectivas funciones, sin embargo es recomendable mantener separados los archivos de trabajo y
no tocar nada que tenga que ver con el sistema operativo, con el fin de evitar conflictos.
Página 49

1. Arranque Visual C++.

2. Ejecute la orden New del menú File.
3. En la pestaña Projects elija la opción MFC AppWizard (dll).
4. En el cuadro de diálogo Project name coloque Saludo.
5. Use Location para ubicar la ruta en que será guardado el proyecto.
6. Después de hacer clic en OK, haga clic sobre el botón Finísh, y nuevamente sobre el botón OK.
7. Seleccione el archivo Saludo.cpp, de la ventana WorkSpace, pestaña FileView, Saludo
files\Source files y agrege al final, el siguiente código:
extern "C" __declspec(dllexport) int __stdcall Saludo(char *charSaludo)
{
#ifdef _AFXDLL
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
strncpy(&charSaludo[8], "Visual C++", 10);

charSaludo[18] = NULL;
return strlen(charSaludo);
}
8. Del menú Build elija la opción Batch Build, y haga clic sobre el botón Rebuild All.
9. Arranque Visual Basic.
10. Del menú Archivo, elija Nuevo proyecto.
11. Seleccione Exe estándar y haga clic en aceptar.
12. Agregue un módulo y guarde el proyecto.
13. En el módulo agregue el siguiente código:
Public declare function Saludo Lib “Ruta\Saludo.DLL” (ByVal strSaludo as string) as Long
14. En el formulario agrege un cuadro de texto y un botón de comando
15. En el botón de comando coloque el siguiente código:
Dim strSaludo As String
strSaludo = "Saluda:"
strSaludo = strSaludo & String(19 - Len(strSaludo), " ")
Saludo strSaludo
Text1.Text = strSaludo
Página 50
16. Ejecute la aplicación.
CONCLUSIONES
BIBLIOGRAFÍA:
Básica :
Complementaria:
Página 51

Manual de Practicas1 - POO3

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Manual de Practicas1 - POO3

Uploaded by

Copyright:

Available Formats

LICENCIATURA EN SISTEMAS COMPUTACIONALES

FECHA DE ELABORACIÓN: Abril 2005

LIC. EN COMP. ISAIAS PÉREZ PÉREZ

ING. MARIO ALBERTO MAGAÑA MENDEZ

L.S.C LUIS RAMÓN MACIAS PULIDO

Vo. Bo. PRESIDENTE DE LA ACADEMIA DE SISTEMAS Y SOFTWARE DE BASE

LIC. EN COMP. Luis Islas Hernández

Vo. Bo. SECRETARIO DE LA ACADEMIA DE SISTEMAS Y SOFTWARE DE BASE

ING. Alberto Alfonso Galindo Galindo

Vo. Bo. COORDINADOR DE LA LICENCIATURA EN SISTEMAS COMPUTACIONALES

FECHA DE PRÓXIMA REVISIÓN:

NOMBRE DE LA PRÁCTICA : Creación de un proyecto MFC

No. DE INTEGRANTES MÁXIMO POR EQUIPO:2

El alumno aprenderá a realizar un proyecto MFC, usando el Asistente de Visual

EQUIPO Y SOFTWARE A UTILIZAR:

PC PentiumIII con 120 mb en RAM

PROCEDIMIENTO PARA EL DESARROLLO DE LA PRÁCTICA:

Como no vamos a utilizar ninguna base de datos, pues seleccionamos none. El

LOS MENSAJES DE WINDOWS.

Básicamente un programa hecho para Windows funciona de la siguiente manera.

RECURSOS GRAFICOS DE VISUAL C++.

Por defecto hay dos diálogos dentro de la carpeta. IDD_ABOUTBOX e

Aquí se encuentra el menú del programa.

Añade comentarios al programa, versión, compañía, autor, etc.

Visual C++5 para desarrolladores. David Bennett. Editorial Prenctice-Hall. 1998

NOMBRE DE LA PRÁCTICA : Conceptos básicos de Visual C++

No. DE INTEGRANTES MÁXIMO POR EQUIPO:2

El alumno aprenderá y usará el formulario, variables, código a botones y cuadros de mensaje.

El manejo de formularios, variables y botos en un lenguaje visual es muy

EQUIPO Y SOFTWARE A UTILIZAR:

PC PentiumIII con 120 mb en RAM

PROCEDIMIENTO PARA EL DESARROLLO DE LA PRÁCTICA:

PRIMEROS PASOS CON EL FORMULARIO.

Selecciona la carpeta DIALOG del WORKSPACE y haz doble clic en

CONECTA VARIABLES A LOS CONTROLES.

AÑADE CÓDIGO A UN BOTÓN.

MOSTRAR UN MESSAGE BOX.

int MessageBox(mensaje, titulo, estilo);

El mensaje es una cadena con el texto que va aparecer en el MESSAGEBOX.

Ahora nuestro botón de regreso al sistema operativo pide confirmación al usuario

Visual C++5 para desarrolladores. David Bennett. Editorial Prenctice-Hall. 1998

NOMBRE DE LA PRÁCTICA : Ejercicio de gestión de multas

No. DE INTEGRANTES MÁXIMO POR EQUIPO:2

El alumno aprenderá y realizará un primer ejercicio demostrativo en Visual C++.

Realizar operaciones en un sistema es de importancia ya que existen varias formas

EQUIPO Y SOFTWARE A UTILIZAR:

PC PentiumIII con 120 mb en RAM

PROCEDIMIENTO PARA EL DESARROLLO DE LA PRÁCTICA:

EJERCICIO GESTIÓN DE MULTAS.

Declaramos un objeto fecha de la clase CTime y obtenemos la fecha actual. Por

Los objetos creados de la clase CTimeSpan se diferencian de los de CTime en que

Otro objeto nuevo CTime

Donde controlamos que la fecha no se desborde, simplemente si lo que

Visual C++5 para desarrolladores. David Bennett. Editorial Prenctice-Hall. 1998

NOMBRE DE LA PRÁCTICA : Casillas de verificación y radio botones.

No. DE INTEGRANTES MÁXIMO POR EQUIPO:2

El alumno aprenderá y usará algunos de los controles estandar.

EQUIPO Y SOFTWARE A UTILIZAR:

PC PentiumIII con 120 mb en RAM

PROCEDIMIENTO PARA EL DESARROLLO DE LA PRÁCTICA:

CASILLAS DE VERIFICACIÓN Y RADIO BOTONES.

La función GetCheck() que

Visual C++5 para desarrolladores. David Bennett. Editorial Prenctice-Hall. 1998