AnteriorPosterior

9. Una clase que use la anterior

  Curso: Introducción a C++, por Nacho Cabanes (antiguo)

9. Una clase que use la anterior.


Ahora vamos a crear una nueva clase de objetos que se utilice la anterior. Puede tratarse, por ejemplo, de una clase "ventana", que se encargue de mostrar ventanas en una pantalla de texto.

Cada ventana podrá tener un cierto tamaño, estar en cierta posición y contener una línea de texto. No he contemplado la posibilidad de que se puedan borrar las ventanas y el fondo de la pantalla quede restaurado como estaba, ni de que se pueda escribir más de una línea de texto dentro de la ventana (ni otras muchas).

Así, la cabecera podría ser ésta:
 1: // 
2:
// vent01.h
3:
//
4:
// Introducción a C++
5:
// Jose Ignacio Cabanes
6:
// Clase "Ventana"
7:
// Versión para TC++ (MsDos)
8:
//
9:
/////////////////////////////////////////////
10:

11: #ifndef _VENT1_H
12: #define _VENT1_H
13: #include "pant04.h"
14: // ---------------------------------------------------------
15:
// CLASE : Ventana
16:
// Para dibujar en pantalla ventanas con una línea de texto.
17:
// ---------------------------------------------------------
18:
class Ventana {
19: char maxX, minX; // Coordenadas máxima y mínima (horizontal)
20:
char maxY, minY; // Coordenadas máxima y mínima (vertical)
21:
char msg[80]; // El mensaje que mostrará la ventana
22:
char msgX, msgY; // Coordenadas del mensaje en la ventana
23:
PantallaTM pant; // La pantalla en la que escribir
24:
public:
25: Ventana(PantallaTM p); // Constructores: 3 distintos,
26:
Ventana(PantallaTM p, int x1, // según los parámetros
27:
int y1, int x2, int y2);
28: Ventana(PantallaTM p, int x1,
29: int y1, int x2, int y2, char* texto);
30: int FijaCoords(int x1, // Fija el tamaño
31:
int y1, int x2, int y2);
32: void Escribe(int X,
33: int Y, char *texto); // Escribe mensaje en ciertas coords
34:
void Escribe(int Y,
35: char *texto); // Escribe un mensaje en una línea
36:
void Escribe(char *texto); // Escribe un mensaje centrado
37:
void Muestra(); // Muestra la ventana
38:
};
39: #endif


Hay apenas una novedad interesante: hay 3 métodos constructores distintos y otros 3 métodos "Escribe" distintos, cada uno con distintos parámetros, y cada uno se comporta de forma ligeramente distinta. Es un ejemplo de polimorfismo (en este caso concreto, en que las 3 funciones tienen igual nombre y distintos parámetros, es un caso especial de polimorfismo llamado sobrecarga, se diría que la función Escribe "está sobrecargada").

El desarrollo de la clase "Ventana" podría ser éste:

  1: // 
2:
// vent01.cpp
3:
//
4:
// Introducción a C++
5:
// Cuarto ejemplo
6:
// (usado por "ejcpp04.cpp")
7:
// Versión para TC++ (MsDos)
8:
//
9:
// Curso de C
10:
// Jose Ignacio Cabanes
11:
//
12:
/////////////////////////////////////////////
13:

14: #include "vent01.h"
15: #include <string.h>
16:
17: // ===================================================================
18:
// A continuación viene el desarrollo de las funciones (métodos)
19:
//
20:
// ----------------- Ventana -------------------------------
21:
// Métodos constructores: valores iniciales
22:

23: Ventana::Ventana(PantallaTM p) {
24: maxX = 60; minX = 20;
25: maxY = 20; minY = 6;
26: msgX = 30; msgY = 8;
27: strcpy(msg,"");
28: pant = p;
29: }
30:
31: Ventana::Ventana(PantallaTM p, int x1, int y1, int x2, int y2) {
32: maxX = x2; minX = x1;
33: maxY = y2; minY = y1;
34: msgX = 30; msgY = 8;
35: strcpy(msg, "");
36: pant = p;
37: }
38:
39: Ventana::Ventana(PantallaTM p, int x1, int y1, int x2, int y2,
40: char *texto) {
41: maxX = x2; minX = x1;
42: maxY = y2; minY = y1;
43: msgX = 30; msgY = 8;
44: strcpy(msg, texto);
45: pant = p;
46: }
47: // ----------------- Ventana -------------------------------
48:
// Fija las coordenadas, comprobando si son válidas
49:

50: int
51: Ventana::FijaCoords(int x1, int y1, int x2, int y2) {
52: if ((x1 < pant.LeerMinX()) ||
53: (x2 > pant.LeerMaxX()) ||
54: (y1 < pant.LeerMinY()) ||
55: (y2 > pant.LeerMaxY()) ) return 0;
56: maxX = x2; minX = x1;
57: maxY = y2; minY = y1;
58: return 1;
59: }
60:
61: // ----------------- Ventana -------------------------------
62:
// Escribe un mensaje en ciertas coordenadas
63:

64: void
65: Ventana::Escribe(int X, int Y, char *texto) {
66: msgX = X;
67: msgY = Y;
68: strcpy(msg, texto);
69: }
70:
71: // ----------------- Ventana -------------------------------
72:
// Escribe un texto centrado en una línea
73:

74: void
75: Ventana::Escribe(int Y, char *texto) {
76: char X = (maxX - minX - strlen(texto)) / 2;
77: Escribe(X, Y, texto);
78: }
79: // ----------------- Ventana -------------------------------
80:
// Escribe un texto centrado en la ventana
81:

82: void
83: Ventana::Escribe(char *texto) {
84: char Y = (maxY - minY) / 2;
85: Escribe(Y, texto);
86: }
87: // ----------------- Ventana -------------------------------
88:
// Muestra la ventana
89:

90: void
91: Ventana::Muestra() {
92: int i, j;
93: // Borde superior
94:
for (i=minX; i<=maxX; i++)
95: pant.Escribe(i, minY, "-");
96: // Laterales que bajan
97:
for (i=minY+1; i<=maxY-1; i++) {
98: pant.Escribe(minX, i, "|");
99: pant.Escribe(maxX, i, "|");
100: }
101: // Borde inferior
102:
for (i=minX; i<=maxX; i++)
103: pant.Escribe(i, maxY, "-");
104: // Texto de la ventana
105:
pant.Escribe (minX+msgX, minY+msgY, msg);
106: }


Confío en que en este desarrollo no haya ninguna dificultad. Se apoya en parte en el objeto de clase "PantallaTm", y las rutinas "Escribe" se basan unas en otras. La rutina "Muestra" es sencilla aunque eso hace que tampoco el resultado sea muy lucido.



Finalmente, un ejemplo que usase las clases de objetos "Ventana" y "PantallaTM" podría ser:
 1: 
2:
//
3:
// usavent.cpp
4:
//
5:
// Introducción a C++
6:
// Jose Ignacio Cabanes
7:
// Uso de clase Ventana
8:
// Versión para TC++ (MsDos)
9:
//
10:
/////////////////////////////////////////////
11:

12: #include
"pant04.h"
13: #include
"vent01.h"
14:
15:
// Programa sencillo de ejemplo
16:
PantallaTM pant; // Objeto de la clase "PantallaTexto" mejorada
17:
Ventana vent1(pant); // Primera ventana, vacía
18:
Ventana vent2(pant, // Segunda, con coordenadas ya fijadas
19:
 40, 5, 75, 11);
20:
int main() {
21: pant
.Borra();
22: pant
.Escribe(10,10, "Pantalla de fondo");
23:
if (!vent1.FijaCoords(25, 12, 55, 18)) {
24: pant
.Escribe(10,20, "La ventana no cabe!");
25:
return 0;
26:
}
27: vent1.Escribe
("Texto en la ventana");
28: vent1.Muestra
();
29: vent2.Escribe
(2,2,"Segunda ventana");
30: vent2.Muestra
();
31: pant
.EscribeCent(23, "Texto centrado en la pantalla de fondo");
32:
return 0;
33:
}


En este programa se ve la forma de utilizar los distintos métodos constructores para crear las ventanas, así como las dos llamadas a "Escribe" con distintos parámetros.

Para poner en marcha este programa, deberemos compilarlo creando un fichero de proyeto o indicando al compilador qué fuentes lo componen:

bcc32 usavent.cpp vent01.cpp pant04.cpp pant03.cpp  

El resultado de este ejemplo tiene un aspecto parecido a éste:


                                       ------------------------------------
                                       |                                  |
                                       | Segunda ventana                  |
                                       |                                  |
                                       |                                  |
         Pantalla de fondo             |                                  |
                                       ------------------------------------
                        -------------------------------
                        |                             |
                        |                             |
                        |    Texto en la ventana      |
                        |                             |
                        |                             |
                        -------------------------------

                   Texto centrado en la pantalla de fondo


Tampoco es demasiado vistoso, pero todavía somos principiantes en C++...

Actualizado el: 18-05-2006 19:59

AnteriorPosterior