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; icadena,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