3. Constructores y destructores
Curso: Introducción a C++, por Nacho Cabanes (antiguo)
3. Constructores y destructores
Este primer fuente ya hace algo, pero queda mucho por
mejorar: nos podría interesar comprobar si un cierto texto va a caber en la
pantalla, con algo como
if (pant.LeerMaxX() > 40)
pant.Escribe(45,8, "Hola");
(si la pantalla tiene más de 40 letras en la horizontal,
escribir el texto). Esto todavía no lo podemos hacer, porque no tenemos el
valor del tamaño horizontal de la pantalla. Quien ya haya programado en C, se
puede sentir tentado a dale un valor inicial haciendo
class PantallaTexto {
char maxX=80, minX=1; // Coordenadas máxima y mínima
(horizontal)
[...]
pero esto no es válido en C++. Eso sí, tenemos otra opción más elegante: podemos definir un método que se ponga en funcionamiento nada más crearse el objeto, y que será el encargado de dar valores iniciales a las variables, de reservar memoria dinámica si fuera necesario, etc. Este es el método CONSTRUCTOR, que se definiría de la siguiente forma:
PantallaTexto::PantallaTexto() {
maxX = 80; minX = 1;
maxY = 25; minY = 1;
}
(es decir, tiene como nombre el mismo que la clase a la
que pertenece, y no devuelve valor de ningún tipo.
Si hubieramos reservado memoria dinámica (no es nuestro caso), también nos interesaría utilizar un método DESTRUCTOR, que liberase esta memoria cuando el objeto se deja de utilizar, y que tendría un aspecto parecido a esto:
PantallaTexto::~PantallaTexto() {
// Aquí liberaríamos
el espacio reservado, etc.
}
(es decir, el mismo nombre que la clase pero precedido por
~ ).
Pues ahora ya vamos a crear nuestra clase "PantallaTexto", pero esta vez un poco más completa.
En C++, lo habitual (y lo que se debe hacer, siendo purista) es dividir la definición de un objeto en dos partes:
* Las variables (atributos) y los prototipos de las funciones (métodos) se suelen definir en un fichero de cabecera (los que en C tenían extensión .h, y que en C++ sería preferible indicar con extensión .hpp ó .hh, aunque la mayoría de gente no lo hace).
* Los detalles concretos de cómo trabaja cada función (el desarrollo) se definen en un fichero fuente normal (los que en C tenían extensión .c, y que en C++ tendrán extensión .cpp ó .cc ó .C).
A pesar de ello, en este ejemplo todavía incluiremos todo junto en un único
fichero, para tener una visión de conjunto algo mejor, y será a partir de
siguiente cuando empecemos a hacer las cosas con más corrección.
Eso sí, aprovecharemos para ampliar un poco las funcionalidades de la clase: ahora no sólo podremos leer el valor máximo de X, sino también el mínimo, y los valores correspondientes de Y.
1: //
2: // pant02.cpp
3: //
4: // Introducción a C++
5: // Jose Ignacio Cabanes
6: //
7: // Segundo ejemplo (en un sólo fuente)
8: // Versión para TC++ (MsDos)
9: //
10: /////////////////////////////////////////////
11:
12: #include <conio.h>
13:
14: // ---------------------------------------------------------
15: // CLASE : PantallaTexto
16: // Oculta el funcionamiento de la pantalla en modo texto.
17:
18: class PantallaTexto {
19: char maxX, minX; // Coordenadas máxima y mínima (horizontal)
20: char maxY, minY; // Coordenadas máxima y mínima (vertical)
21:
22: public:
23: PantallaTexto(); // Método constructor
24: void Borra(); // Borra toda la pantalla
25: void Escribe(int X,
26: int Y, char *texto); // Escribe un mensaje en ciertas coordenadas
27: int LeeTecla(); // Espera una tecla y la devuelve
28: int LeerMaxX(); // Devuelve coordenada X máxima
29: int LeerMinX(); // Devuelve coordenada X mínima
30: int LeerMaxY(); // Devuelve coordenada Y máxima
31: int LeerMinY(); // Devuelve coordenada Y mínima
32: ~PantallaTexto(); // Método destructor
33: };
34:
35: // ==========================================================================
36: // A continuación viene el desarrollo de las funciones (métodos)
37:
38:
39: // ----------------- PantallaTexto -------------------------
40: // Método constructor: valores iniciales
41:
42: PantallaTexto::PantallaTexto() {
43: maxX = 80; minX = 1;
44: maxY = 25; minY = 1;
45: }
46:
47:
48: // ----------------- PantallaTexto - Borra -----------------
49: // Borra toda la pantalla
50:
51: void
52: PantallaTexto::Borra() {
53: clrscr();
54: }
55:
56: // ----------------- PantallaTexto - Escribe ---------------
57: // Escribe un mensaje en ciertas coordenadas
58:
59: void
60: PantallaTexto::Escribe(int X, int Y, char *texto) {
61: gotoxy(X, Y);
62: cputs(texto);
63: }
64:
65:
66: // ----------------- PantallaTexto - LeeTecla --------------
67: // Espera una tecla y la devuelve
68:
69: int
70: PantallaTexto::LeeTecla() {
71: return getch();
72: }
73:
74:
75: // ----------------- PantallaTexto - LeerMaxX ---------------
76: // Devuelve la coordenada horizontal máxima
77:
78: int
79: PantallaTexto::LeerMaxX() {
80: return maxX;
81: }
82:
83:
84: // ----------------- PantallaTexto - LeerMinX ---------------
85: // Devuelve la coordenada horizontal máxima
86:
87: int
88: PantallaTexto::LeerMinX() {
89: return minX;
90: }
91:
92:
93: // ----------------- PantallaTexto - LeerMaxY ---------------
94: // Devuelve la coordenada vertical máxima
95:
96: int
97: PantallaTexto::LeerMaxY() {
98: return maxY;
99: }
100:
101:
102: // ----------------- PantallaTexto - LeerMinY ---------------
103: // Devuelve la coordenada vertical mínima
104:
105: int
106: PantallaTexto::LeerMinY() {
107: return minY;
108: }
109:
110: // ----------------- PantallaTexto -------------------------
111: // Método destructor: no usado esta vez
112:
113: PantallaTexto::~PantallaTexto() {
114: // Aquí liberaríamos el espacio reservado, etc.
115: }
116:
117:
118: // ==========================================================================
119: // Finalmente: un programa sencillo de ejemplo
120:
121: main() {
122: PantallaTexto pant; // Definimos un objeto de la clase "PantallaTexto"
123:
124: pant.Borra();
125: pant.Escribe(30,14, "Hola");
126: pant.LeeTecla();
127: return 0;
128: }
Actualizado el: 07-05-2006 06:25