Introducción a clases Programación Orientada a Objetos

Clases Una clase es un tipo de datos que incluye datos llamados miembros y funciones llamados métodos. La clase es una plantilla a partir de la cual se pueden definir variables conocidas como objetos. Los objetos son instancias o ejemplares de alguna clase. Las clases en C++ se pueden declarar como estructuras ( struct ) o como clases ( class ), en el primer caso sus miembros serán por omisión públicos y en el segundo serán privados.

Motivación Considere el concepto de fecha definido como una estructura y las funciones que manipulan esta estructura: struct Fecha{ int d, m, a; }; void inicia_fecha(Fecha& d,int dd, int mm, int aa){ d.d = dd; d.m = mm; d.a = aa; } void suma_anyo(Fecha& d,int n){ d.a += n; } void suma_mes(Fecha& d,int n){ d.m += n; } void suma_dia(Fecha& d,int n){ d.d += n; } void imprime(Fecha d){ cout << d.d << "/" << d.m << "/" << d.a << endl; }

Es posible escribir una función main como la siguiente que manìpule una variable de tipo Fecha sin usar las funciones definidas anteriormente. main(){ Fecha hoy; inicia_fecha(hoy,14,2,2013); suma_anyo(hoy,1); imprime(hoy); hoy.d += 5; hoy.a = hoy.d*hoy.m; imprime(hoy); system("pause"); }

La clase Fecha Declaramos las funciones como miembros de la estructura para ligarlas con los datos de una fecha. struct Fecha{ int d, m, a; void inicia_fecha(int dd, int mm, int aa); void suma_anyo(int n); void suma_mes(int n); void suma_dia(int n); void imprime(); }; Miembros dato Métodos

La declaración de las funciones debe especificar el nombre de la estructura a la que pertenecen. void Fecha::inicia_fecha(int dd, int mm, int aa){ d = dd; m = mm; a = aa; } void Fecha::suma_anyo(int n){ a += n; } void Fecha::suma_mes(int n){ m += n; } void Fecha::suma_dia(int n){ d += n; } void Fecha::imprime(){ cout << d << "/" << m << "/" << a << endl; }

Con estas declaraciones todavía es posible ejecutar la función main vista anteriormente con algunas modificaciones. Para invocar los métodos se utiliza el operador “.”. La invocación se conoce como envío de un mensaje. main(){ Fecha hoy; hoy.inicia_fecha(14,2,2013); hoy.suma_anyo(1); hoy.imprime(); hoy.d += 5; hoy.a = hoy.d*hoy.m; hoy.imprime(); system("pause"); } Envío de mensajes al objeto hoy.

Para restringir la manipulación de variables de tipo Fecha solo a través de las funciones definidas, debemos declarar (definir) una clase (class) en lugar de una estructura (struct). Cualquier intento de referenciar los campos d, m, a de la clase generará un mensaje de error. class Fecha{ int d, m, a; public: void inicia_fecha(int dd, int mm, int aa); void suma_anyo(int n); void suma_mes(int n); void suma_dia(int n); void imprime(); }; Modificador de acceso

Métodos poner y obtener Dado que los miembros dato son privados, es necesario definir métodos públicos para obtener o poner el valor de estos. La clase Fecha con métodos para poner y obtener los miembros dato es la siguiente. class Fecha{ int d, m, a; public: void inicia_fecha(int dd, int mm, int aa); void suma_anyo(int n); void suma_mes(int n); void suma_dia(int n); void imprime(); int obtieneDia(); int obtieneMes(); int obtieneAnyo(); void ponDia(int n); void ponMes(int n); void ponAnyo(int n); };

La clase Grados Construyamos una clase para manipular cantidades en grados, minutos y segundos. Supondremos solo valores enteros para estas cantidades. La siguiente es una primera declaración de la clase. class Grados{ int grad, min, seg; public: void poner(int g, int m, int s); void sumar(Grados a); void escribe(); };

void Grados::poner(int g, int m, int s){ //este método pone valores a los miembros del objeto grad = g; min = m; seg = s; } void Grados::sumar(Grados a){ //este método suma al objeto otro objeto seg += a.seg; if(seg>=60){ min += seg/60; seg = seg%60; } min += a.min; if(min>=60){ grad += min/60; min = min%60; } grad += a.grad; }

void Grados::escribe(){ //este método despliega los valores de grados, minutos y segundos cout << grad << "g" << min << "'" << seg << "\"\n"; } La siguiente función main crea dos objetos de clase Grados y suma el segundo al primero. main(){ Grados a,b; a.poner(30,45,35); b.poner(3,18,34); a.escribe(); b.escribe(); a.sumar(b); a.escribe(); system("pause"); } 30º45’35” 3º18’34” Despliega: 34g4’9”

Los métodos que consten de pocas líneas es conveniente que se escriban como funciones en línea en la declaración de la clase, como se muestra: class Grados{ int grad, min, seg; public: void poner(int g, int m, int s) {grad=g;min=m;seg=s;}; void sumar(Grados a); void escribe(){ cout<<grad<<"g"<<min<<"'"<<seg<<“\"\n“; };

Constructores Un constructor es un método que se ejecuta al crear variables de alguna clase. La definición de constructores permite controlar desde un inicio los valores almacenados en los objetos. Los constructores pueden ser funciones sobrecargadas, es decir, puede haber varios constructores para una clase. Los constructores en C++ son métodos que tiene el mismo nombre que la clase y no llevan ningún tipo de retorno.

La siguiente versión de la clase Grados tiene dos constructores, uno sin parámetros y otro con tres parámetros. class Grados{ int grad, min, seg; public: Grados(){grad=0;min=0;seg=0;}; Grados(int g, int m, int s){grad=g;min=m;seg=s;}; void poner(int g, int m, int s){grad=g; min=m; seg=s;}; void sumar(Grados a); void escribe(){cout<<grad<<"g"<<min<<"'“<<seg<< "\"\n";}; };

La siguiente función main crea dos objetos. El objeto a se crea con el constructor con parámetros y b con el constructor sin parámetros. main(){ Grados a(30,45,35),b; b.poner(3,18,34); a.escribe(); b.escribe(); a.sumar(b); a.escribe(); system("pause"); }

Listas de inicialización Otra forma de especificar los constructores es mediante una lista de inicialización. La lista de inicialización consta de una lista de los miembros de la clase con valores encerrados entre paréntesis, como se muestra. class Grados{ int grad, min, seg; public: Grados():grad(0),min(0),seg(0){}; Grados(int g, int m, int s):grad(g),min(m),seg(s){}; void poner(int g,int m,int s){grad=g;min=m;seg=s;}; void sumar(Grados a); void escribe(){cout<<grad<<"g"<<min<<"'"<<seg<<"\"\n";}; }; Lista de inicialización

Constructor de copia Un constructor de copia acepta como parámetro un objeto de la clase y lo copia en el objeto actual. Estos constructores sólo tienen un argumento, que es una referencia a un objeto de su misma clase. En general, los constructores copia tienen la siguiente forma para sus prototipos: tipo_clase::tipo_clase(const tipo_clase &obj); Si no se define un constructor de copia el compilador crea un constructor de copia oficial. El constructor de copia puede llevar más parámetros además de la referencia a un objeto de su misma clase.

Constructor de copia de Grados class Grados{ int grad, min, seg; public: Grados():grad(0),min(0),seg(0){}; Grados(const Grados& a):grad(a.grad),min(a.min), seg(a.seg) {}; Grados(int g, int m, int s):grad(g),min(m),seg(s){}; void poner(int g, int m, int s){grad=g;min=m;seg=s;}; void sumar(Grados a); void escribe(){cout<<grad<<"g"<<min<<"'"<<seg<< "\"\n";}; }; Constructor de copia

La siguiente función main muestra el uso del constructor de copia. Note que la instrucción c = b, llama al constructor de copia. main(){ Grados a(30,45,35),b(a),c = b; a.escribe(); b.escribe(); c.escribe(); a.sumar(b); a.escribe(); system("pause"); } Constructor de copia

Destructores Un destructor es un método que se invoca cuando un objeto deja de existir, por ejemplo al salir de una función con un objeto local. Los destructores tienen el mismo nombre que los constructores pero se les antepone el símbolo ~. Los destructores no llevan parámetros ni regresan ningún valor. Los destructores se utilizan para eliminar datos credos por el objeto tales como variables dinámicas.

Ejemplo de destructor La siguiente versión de la clase Grados incluye un destructor. El destructor solo despliega un mensaje en la pantalla. class Grados{ int grad, min, seg; public: Grados():grad(0),min(0),seg(0){}; Grados(int g, int m, int s):grad(g),min(m),seg(s){}; ~Grados(){cout << "Destructor invocado.\n";}; void poner(int g, int m, int s){grad=g;min=m;seg=s;}; void sumar(Grados a); void escribe(){cout<<grad<<"g"<<min<<"'"<<seg<<"\"\n";}; };

La siguiente función prueba la ejecución del destructor. void pruebaDestructor(){ Grados a; a.escribe(); } main(){ Grados a(30,45,35),b; b.poner(3,18,34); a.escribe(); b.escribe(); a.sumar(b); a.escribe(); pruebaDestructor(); system("pause"); } ¿Por qué aparece dos veces el letrero “Destructor invocado.” ?

Asignación dinámica de memoria Es común la creación de objetos de forma dinámica. Para crear usamos el operador new y para destruir el operador delete. No es necesario utilizar las bibliotecas estándar para este propósito. main(){ Fecha *hoy; hoy = new Fecha; hoy->inicia_fecha(14,2,2013); hoy->imprime(); hoy->suma_anyo(1); hoy->imprime(); delete hoy; system("pause"); }

El apuntados this El apuntador this representa un apuntador a un objeto cuya función miembro esta siendo ejecutada. Es una apuntador al objeto en si.

Ejemplo de this #include using namespace std; class CDummy { public: int isitme(CDummy& param); }; int CDummy::isitme(CDummy& param){ if(&param == this) return true; else return false; } main(){ CDummy a; CDummy* b = &a; if ( b->isitme(a) ) cout << "yes, &a is b"; system("pause"); return 0; }

Miembros estáticos Se pueden declarar datos o métodos estáticos. Un miembro dato estático solo almacena un valor para todos los objetos de la clase. Se comporta como una variable global, pero con acceso restringido. Se utiliza por ejemplo, para llevar una cuenta del número de objetos declarados de alguna clase. Las variables static pueden existir aun sin la declaración de ningún objeto de la clase.

Ejemplo de miembro static #include using namespace std; class CDummy { public: static int n; CDummy () { n++; }; ~CDummy () { n--; }; }; int CDummy::n=0; int main () { CDummy a; CDummy b[5]; CDummy * c = new CDummy; cout << a.n << endl; delete c; cout << CDummy::n << endl; system("pause"); return 0; }

Clase Racional La siguiente clase permite definir operaciones con números racionales. Un número racional consta de dos componentes enteras, el numerador y el denominador. La clase implementa las operaciones de suma, resta, multiplicación, división y simplificación de racionales. Además definimos 3 constructores y un método para desplegar racionales. Separaremos la clase racional en dos archivos. Un archivo de encabezado (.h) y un archivo de implementación (.cpp).

Racional.h class Racional{ int num,den; public: Racional(){num = 0;den = 1;}; Racional(int a){num = a;den = 1;}; Racional(int a,int b){num=a;den=b;simplifica();}; void suma(Racional a); void resta(Racional a); void miltiplica(Racional a); void divide(Racional a); void simplifica(); void escribe(); };

Racional.cpp /*Clase Racional: Implementación*/ #include #include "racional.h" using namespace std; void Racional::suma(Racional a){ num = num*a.den+den*a.num; den = den*a.den; simplifica(); } void Racional::resta(Racional a){ num = num*a.den-den*a.num; den = den*a.den; simplifica(); }

Racional.cpp (cont.) void Racional::miltiplica(Racional a){ num = num*a.num; den = den*a.den; simplifica(); } void Racional::divide(Racional a){ num = num*a.den; den = den*a.num; simplifica(); } void Racional::escribe(){ cout << num << "/" << den << "\n"; }

Racional.cpp (cont.) void Racional::simplifica(){ int a,b,res; if(num>den){ a = num; b = den; } else{ a = den; b = num; } while(b != 0){ res = a%b; a = b; b = res; } num = num/a; den = den/a; }

Archivo main #include #include "racional.h" using namespace std; main(){ Racional r(5),s(12,36); r.escribe(); s.escribe(); r.suma(s); r.escribe(); system("pause"); }