Clases

CLASES
Introducción
• Permite crear objetos que pueden ser empleados del mismo modo que los tipos básicos
• Permite definir un objeto de forma concreta y precisa que no tiene contraparte obvia con los tipos
básicos
• Permite diseñar los objetos de una aplicación de acuerdo a lo que se está desarrollando con lo que
se puede entender y modificar de mejor manera la aplicación
Ejemplo : Implementación del concepto de fecha por medio de una estructura (struct) junto con el conjunto
de funciones para manipularlas :
En C :
struct fecha { int dÃ−a, mes, año };
fecha hoy ;
void fijar_fecha (fecha*, int, int, int);
void siguiente_fecha (fecha*);
void imprimir_fecha(const fecha*);
// ...
No existen conexiones explÃ−citas entre las funciones y el tipo de datos.
C++ nos permite hacer lo siguiente :
struct fecha {
int dÃ−a, mes, año;
void fijar(int, int, int);
void obtener(int*, int*, int*);
void siguiente();
void imprimir();
};
Las funciones miembros se invocan de la siguiente manera :
fecha hoy;
fecha mi_aniversario;
1
void f ()
{
mi_aniversario.fijar(30, 12,1975);
hoy.fijar(22,9,1997);
mi_aniversario.imprmir();
hoy.siguiente();
}
Diferentes estructuras pueden tener funciones miembro con el mismo nombre, es preciso especificar el
nombre de la estructura al definir una función miembro :
void fecha::siguiente()
{
if(++dÃ−a > 28) {
// resolver esta parte
}
}
En una función miembro, los nombres de los miembros se pueden emplear sin hacer una referencia
explÃ−cita a un objeto, en ese caso se refieren al miembro del objeto que efectivamente llamó a la función.
DEFINICIÃ N DE CLASES
La definición de tipo struct no poseen miembros privados y no restringen el acceso de otra funciones a los
objetos. La definición de una clase nos permite implementar esta posibilidad .
class fecha {
int dÃ−a, mes, año;
public :
void fijar(int, int, int);
void obtener(int*, int*, int*);
void siguiente();
void imprimir();
};
2
La palabra reservada public nos separa la definición de la clase en dos partes. Sólo las funciones miembro
pueden acceder a los nombres definidos en la primera parte, que se denomina privada.
La parte pública consiste es la interfase de los objetos de la clase, esto le permite “comunicarse” con el resto
de los componentes de un programa.
Las funciones que no son miembros no podrán utilizar los miembros privados de la clase fecha.
Ventajas de limitar el acceso :
• cualquier problema que exista con una fecha que tome un valor ilegal habrá que buscarlo en el
código de alguna función miembro
• un cambio de comportamiento de un objeto habrá que efectuarlo a través de las funciones
miembro
• examinando la definición de la funciones miembros un usuario podrá aprender su manejo
AUTOREFERENCIA
Una función miembro puede hacer referencia directa a miembros del objeto al cual invoca.
class X {
int m;
public :
int leerm() { return m };
};
void f( X aa, X bb)
{
int a = aa.leerm();
int b = bb.leerm();
//.....
}
El puntero this se define de la siguiente forma :
X * const this;
this se inicializa de modo que siempre tenga la dirección del objeto al cual se llamó a la función miembro.
This tiene una posición constante, varÃ−a el objeto al que apunta.
class X {
int m;
3
public :
int leerm() { return this->m };
};
La utilización de this puede ser útil en la implementación de listas doblemente vinculada :
class double_link_list {
double_link_list* prev; // puntero al nodo anterior
double_link_list* next; // puntero al siguiente nodo
public :
void agrega(double_link_list*);
};
void double_link_list*:: anexar(double_link_list* p)
{
p->next = next; // o sea p-> next = this-> next
p->prev = this; // uso explÃ−cito de this
next->pre = p; // o sea this->next->pre = p
next = p; // this->next = p
}
double_link_list* cabeza_lista;
void f(double_link_list* a, double_link_list* b)
{
//...
cabeza_lista->agregar(a);
cabeza_lista->agregar(b);
}
Inicialización
Constructores : funciones que se emplean para inicializar objetos de una clase.
4
Si no se declara existe un por omisión (default). Tienen el mismo nombre de la clase.
class fecha {
// ...
fecha(int, int, int);
};
Si el constructor tiene argumentos habrás que pasarselos :
fecha hoy = fecha(22, 9, 1997);
fecha navidad(25,12,0) // forma abreviada de llamar al
// constructor
fecha mi_aniversario; // error se deben pasar los
// argumentos
Se pueden declarar varios constructores empleando la sobrecarga de nombre de funciones :
class fecha {
int dÃ−a, mes, año;
public :
// ....
fecha(int, int, int); // dÃ−a, mes, año
fecha(int, int); // dÃ−a, mes; año actual fecha(int); // dÃ−a; mes y año actuales
fecha(); // fecha por omisión : hoy
fecha (const char*) // fecha como cadena de
}; // caracteres
Cuando los constructores difieren lo suficiente en cuanto a sus tipos de argumentos, el compilador selecciona
el correcto :
fecha hoy(4);
fecha primavera(“21 de setiembre”);
fecha alguien(5,11);
fecha ahora; // inicializado por omisión
5
Hay que cuidar de poner los constructores que sean necesarios realmente para no producir un programa poco
legible. Utilizar constructores por omisión puede ser muy importante.
class fecha {
int dÃ−a, mes ,año;
public:
// ...
fecha(int d=0; int m=0; int y=0);
// ...
};
fecha::fecha(int d, int m, int a)
{
dÃ−a = d ? d : hoy.dÃ−a;
mes = m ? m : hoy.mes;
año = a ? a : hoy.año;
// verificar que la fecha sea válida
// ...
}
Un objeto de una clase sin constructores se puede inicializar asignándole otro objeto de esa clase. Esto se
puede hacer aún cuando se hayan declarado constructores. Por ejemplo:
fecha f = hoy; // inicialización por asignación
Constructor por omisión: copia de otro objeto de la misma clase. La copia se efectúa miembro por
miembro.
CARACTERÃ STICAS Y REGLAS DE LOS CONSTRUCTORES
• El nombre del constructor debe ser el mismo que el de su clase
• No debe tener ningun tipo de retorno ni siquiera void
• Una clase puede tener distintos tipos de constructores o ninguno, el compilador asigna uno
automáticamente a esa clase
• Un constructor predeterminado es aquel que no tiene ningún tipo de parámetro o posee una lista de
parámetros donde todos ellos son predeterminados
// constructor sin parámetros
6
class punto {
double x;
double y;
public:
punto();
……
};
// la misma clase con constructor con argumentos
// predeterminados
class punto {
double x;
double y;
public:
punto(double xval=0, double yval=0);
……
};
• El constructor de copia permite crear una instancia de clase usando una instancia existente
class punto {
double x;
double y;
public:
punto();
punto(double xval, double yval);
punto(const punto& pt);
……
};
7
Ejemplo de construcciones :
punto p1; // llama al constructor predeterminado
punto p2(1.1, 1.3); // llama al constructor con dos
// argumentos
punto p3(p2);
Construcción y destrucción
Los objetos se pueden crear como :
• Objetos automáticos : se crean cuando se llega a su declaración durante la ejecución de un
programa, se destruyen cuando se sale del bloque en que aparecen
• Objetos estáticos : se crean al principio del programa y se destruyen cuando se sale del mismo
• Objetos dinámicos : se crean a partir del almacenamiento disponible, se crean con new se eliminan
con delete
• Objetos miembro : se crean como miembros de otra clase o como elemento de un arreglo
Variables locales :
• constructor se ejecuta cuando se pasa por la declaración de la variable
• destructor se ejecuta cuando se sale del bloque de esa variable
Los destructores se ejecutan en el orden inverso al de su construcción
void f(int i) Construcción Destrucción
{
tabla aa;
tabla bb;
if(i>0) {
tabla cc;
//…
}
//…
}
void h()
8
{
tabla t1(100); // constructor
tabla t2 = t1; // posibles problemas
tabla t3(200); // constructor
t3 = t2; // problemas
} // En este ejemplo el constructor se llama 2 veces y el
// destructor 3 veces
Almacenamiento disponible
main()
{
tabla *p= new tabla(100);
tabla *q= new tabla(200);
delete p;
delete p; // posible error de ejecución
}// nunca se eliminó a q y se destruyó a p dos veces
No existen garantÃ−as que un destructor llamado con new se llame a su destructor alguna vez
No eliminar no significa nada excepto desperdicio de espacios
Arreglo de objetos de clase
Para declarar un arreglo de objetos de una clase con un constructor debe tener un constructor por omisión tal
que pueda llamarse con una lista de argumentos vacÃ−a
tabla tab[10];
Cuando se destruye se debe llamar al constructor para cada elemento de un arreglo cuando este se destruye
void f()
{
tabla* t1= new tabla;
tabla* t2= new tabla[10];
delete t1; // una tabla no hay problemas
9
delete t2; // problemas 10 tablas delete[] t2;
}
CLASES AMIGAS
En algunos casos es necesario que una función que no es miembro de una clase pueda acceder a los
miembros privados de la clase en estos casos se denomina a la función amiga (friend).
vector multiplicar(const matriz& m, const vector &v)
{
vector r;
for(int i=0; i<3; i++) {// r[i]=m[i]*v;
r.elem(i)=0;
for (int j=0; j<3; j++)
r.elem(i)+=m.elem(i,j)*v.elem(j);
}
return r
}
class matriz;
class vector {
float v[4];
//…
friend vector multiplicar(const matriz&,const vector&);
};
class matriz {
vector v[4];
//…
friend vector multiplicar(const matriz&,const vector&);
};
La función friend no tiene nada particular excepto el derecho de acceder a la parte privada de una clase.
10
Una función friend se puede declarar tanto en la parte privada como en la pública de una clase.
La función amiga se declara explÃ−citamente en la clase en la cual es amiga â ´ forma parte de la interfase
de esa clase tanto como una función miembro. Se debe tener en cuenta que en la función friend no se puede
emplear el puntero this, por lo tanto se debe referenciar explÃ−citamente el miembro del objeto con el que se
está trabajando.
vector multiplicar(const matriz& m, const vector &v)
{
vector(int i=0; i<3; i++) {
r.v[i]=0;
for (int j=0; j<3; j++)
r.v[i]+=m.v[i][j]*v.v[j];
}
return r
}
Una función miembro de una clase puede ser amiga de otra
class X {
//…
void f();
};
class Y {
//…
friend void X::f();// la función miembro f de X es
// amiga de Y
};
Para declarar que todas las funciones miembros de una clase son amigas de otras tenemos :
class X {
…
friend class Y; // todas las funciones miembros de Y
11
… // son amigas de X
};
Distinción de Nombres de Miembros
El operador determinación de alcance :: sirve para distinguir los nombres de los miembros de una clase y
otros nombres.
class X{
int m;
public :
int leem() const{return m;}
void fijam (int m) {X::m=m;}
};
El argumento m oculta al miembro m nos referimos a él con el nombre calificado X::m.
Si se emplea un nombre precedido por el operador :: nos referimos a un nombre global.
class mi_archivo {
//…
public:
int open(const char*, const char*)
};
int mi_archivo::open(const char*nombre, const char*espec)
{
//…
if(::open(nombre, bandera)) { open del S.O.
//…
}
}
Limpieza
Está relacionado con los destructores, estos garantizan la liberación de memoria al desechar objetos del
12
tipo.
Destructor de la clase X : ~X (complemento del destructor)
class pila_caract {
int tam;
char* superior;
char* s;
public:
pila_caract(int tm) {superior=s=new char[tam=tm];}
~pila-caract() {delete s;} //destructor
void meter(char c) {*superior++ = c;}
char sacar() {return *--superior}
};
Clases anidadas
class conjunto {
struct miembro_conj{
int miembro;
miembro_conj* siguiente;
miembro_conj(int m, miembro_conj* n) {
miembro=m; siguiente=n; }
};
miembro-conj* primero;
public:
conjunto() { primero=0; }
insertar(int m) {
primero=new miembro_conj(m,primero);}
};
13
Una clase anidada queda oculta dentro de una clase
Miembro_conj m1(,0) //error!! miembro_conj no está en el
// alcance global
Este recurso no es útil cuando la clase anidada no es simple
Otra alternativa es :
class miembro_conj{
friend class conjunto;// solo tienen acceso los miembros
// de conjunto
int miembro;
miembro_conj* siguiente;
miembro_conj(int m, miembro_conj* n)
{miembro=m, siguiente=n}
// muchos otros miembros útiles
};
class conjunto {
miembro_conj * primero;
public:
conjunto() {primero=0;}
insertar(int m) {
primero=new miembro_conj(m,primero);
}
};
Es posible acceder al nombre de una clase miembro desde afuera de la clase que encierra. Por ejemplo :
class X{
struct M1{int m;};
public:
14
struct M2 {int m;};
M1 f(M2);
};
void f()
{
M1 a; // error!! M1 no está en el alcance
M2 b; //error!! M2 no está en el alcance
X::M1 a; // error!! X::M1 es privado
X::M2 d; // correcto
}
Otros modos de hacerlo :
M1 X::f(M2 a) // error el nombre M1 está fuera del alcance
X::M1 X::f(M2 a) // correcto
X::M1 X::f(X::M2 a)// correcto pero sobra el tercer X::
Miembros estáticos
Una clase es un tipo, no un objeto de datos, cada objeto de datos tiene su propia copia de los miembros de
datos de la clase. Por medio de la declaración static un miembro de la clase tendrá un sola copia y no una
por cada objeto.
class tarea {
// …
static tarea* cadena_tareas;
static void planificar(int);
// …
};
static es solo una declaración el objeto debe estar definido más adelante, en algún lugar del programa :
tarea* tarea::cadena_tareas = 0;
void tarea::planificar(int p) { /* … */}
15
La palabra static no es necesaria ni está permitida en la definición de un miembro estático
Punteros a miembros
Para obtener la dirección de un miembro de una clase :
&nombre_clase::nombre_miembro
Para tener un puntero a un miembro de una clase tenemos :
X::*
#include <iostream.h>
struct cl
{
char *val
void imprimir(int x) { cout << val<<x<<'\n'}
cl(char* v) {val = v;}
};
typedef void(cl::*PMFI) (int);
int main()
{
cl z1(“z1”);
cl z2(“z2”);
cl *p=&z2;
PMFI pf=&cl::imprimir;
z1.imprimir(1);
(z1.*pf)(2);
z2.imprimir(3);
(p->*pf)(4);
}
EJEMPLO DE UNA IMPLEMENTACIÃ N
16
Supongamos una tabla de sÃ−mbolos de un programa (generalmente compuesta por los nombres de
variables), supongamos una primera forma como estructura :
struct nombre {
char* cadena;
nombre* sig;
double valor;
};
y ahora implementada como clase :
// archivo tabla.h
class tabla {
nombre* tab;
public:
tabla() { tab = 0; }
nombre* buscar{char*, int = 0);
nombre* insertar(char*s) { return buscar(s,1); }
};
ahora estamos en condiciones de declarar más de una tabla, tener un apuntador a una tabla. Por ejemplo :
#include “tabla.h”
tabla globales;
tabla palabra_clave;
tabla* locales;
main()
{
locales = new tabla;
//...
}
Y ahora vamos a ver una implementación de tabla::buscar() que emplea una búsqueda lineal a través de
17
una lista vinculada de nombres de la tabla :
#include <string.h>
nombre* tabla::buscar(char* p, int ins)
{
for (nombre* n=tab; n; n=n->siguiente)
if(strcmp(p,n->cadena) == 0) return n;
if(ins == 0) error (“no se encuentra el nombre”);
nombre* nn = new nombre;
nn->cadena = new char(strlen(p)+1);
strcpy(nn->cadena, p);
nn->valor = 1;
nn->siguiente = tab;
tab = nn;
return nn;
}
Supongamos ahora que queremos mejorar la clase tabla para utilizar una búsqueda por dispersión :
clase tabla {
nombre** tab;
int tam;
public:
tabla(int tam = 15);
~tabla();
nombre* buscar (char*, int = 0);
nombre* insertar(char *s) { return buscar(s,1); }
};
La estructura de datos y el constructor fueron modificados para reflejar las nuevas necesidades. La inclusión
de un tamaño especÃ−fico en el constructor es porque la búsqueda por dispersión necesita tener un
18
tamaño. La asignación de un tamaño por omisión es necesaria para que el código anterior siga siendo
válido.
tabla::tabla(int tm)
{
if(tm < 0) error(“tabla de tamaño negativo”);
tab = new nombre*[tam=tm];
for (int i=0; i<tm; i++) tab[i]= 0;
}
tabla::~tabla()
{
for (int i=0; i<tam; i++) {
nombre* sig;
for (nombre* n = tab[i]; n; n=sig) {
sig = n->siguiente;
delete n->cadena;
delete n;
}
}
delete tab;
}
Ahora especificamos la función buscar :
nombre* tabla::buscar(const char* p, int ins)
{
int ii = 0;
char* pp = p;
while (*pp) ii = ii<< 1^*pp++;
if( ii<0 ) ii = -ii;
19
ii %=tam;
for (nombre* n=tab[ii]; n; n= n->siguiente) if(strcmp(p,n->cadena) == 0) return n;
if (ins == 0) error(“no se encuentra el nombre”); nombre* nn= new nombre;
nn->cadena = new char{strlen(p)+1};
strcpy(nn->cadena,p);
nn->valor = 1;
nn->siguiente = tab[ii];
tab [ii] = nn;
return nn;
}
Objetos de clase como miembros
class tabla{
nombre ** tab;
int tam;
public:
tabla(int tm=15);
~tabla();
nombre* buscar(char*, int=0);
nombre* insertar(char* s) { return buscar(s,1); }
};
class defclase{
tabla miembros;
int num_miembros;
....
public:
defclase(int tamaño);
20
~defclase();
};
Defclase debe contener una tabla de miembros de tamaño tamaño. Como se llama al constructor de
tablas?
defclase::defclase(int tamaño): miembros(tamaño)
{
num_miembros= tamaño;
}
El constructor de miembros se llama antes del cuerpo del constructor especificando su lista de parámetros.
Si tenemos más miembros como en el siguiente caso:
class defclase{
tabla miembros;
tabla amigas;
int num_miembros;
....
public:
defclase(int tamaño);
~defclase();
};
defclase::defclase(int tamaño): miembros(tamaño),
amigas(tamaño), num_miembros (tamaño)
{
...
}
Si un constructor de un miembro no necesita argumentos no es necesario especificar el constructor de
miembros en la lista de argumentos, por ejemplo:
defclase::defclase(int tamaño): miembros(tamaño),
21
num_miembros (tamaño)
{
...
}
AquÃ− se llama al constructor por omisión (sin argumentos) por lo tanto el miembro amigas tendrá
un tamaño de 15
Universidad Tecnológica Nacional - Santa Fe - Departamento Sistemas Curso : Desarrollos de Programación en C++
22