PROGRAMACIÓN ORIENTADA A OBJETOS USANDO C++

INDICE Puntero this Sobrecarga de operadores Plantilla de funciones Plantillas de Clases Composición de Clases

PUNTERO this

Puntero this Variable predefinida para todas las funciones miembros de la clase. (parámetro oculto) Es un puntero al objeto concreto de la clase al cual se le está aplicando el método. (No es el objeto) En la invocación de una función miembro, el objeto es un parámetro implícito.

Puntero this El puntero this contiene la dirección del objeto que activó al método y NO es posible modificarlo. Al recibir el parámetro implícito, puede referenciar directamente a las variables miembro del objeto sin el operador punto o flecha.

Puntero this Un método NO puede referirse al objeto mismo como un todo, sino que a cada una de sus partes. El puntero this permite referirse al objeto como tal: *this

Puntero this 1. tope = -1; 2. this->tope = -1; 3. (*this).tope = -1 Las siguientes sentencias son equivalentes, dentro del cuerpo del método constructor de la clase stack: 1. tope = -1; 2. this->tope = -1; 3. (*this).tope = -1

SOBRECARGA DE OPERADORES

Sobrecarga de operadores Es posible redefinir algunos de los operadores existentes en C++ para los objetos de una clase determinada. Objetivo: Simplificar al máximo el código a escribir. La definición de la clase será más compleja pero más fácil de utilizar.

Sobrecarga de operadores Operaciones aritméticas para: Fracciones Complejos Vectores, etc. Operadores de flujo: f=f1 + f2 c=c1 + c2 v=v+k cout<<f; cin>>c; cout<<v;

Restricciones No es posible sobrecargar: Operador punto (.) If aritmético (? :) Operador sizeof Operador de resolución de alcance (::) Puntero a un miembro de un objeto (*.)

Restricciones Se puede modificar la definición de un operador, pero NO su gramática (número de operandos, precedencia y asociatividad) Se requiere que, al menos, UN operando sea un objeto de la clase, en la que se ha definido. Es el tipo de operandos lo que determina qué operador utilizar.

El operador sobrecargado: 1. Operador Miembro Operador que modifica el operando implícito (izquierda del operador) Requiere que el primer operando de la función sea un objeto de la clase (izquierda del operador) Contiene sólo UN parámetro a) f1 + f2 b) f5 * f3

Ejemplo class Fraccion {public: Fraccion(int=0 ,int=1 ); // Por defecto void Imprimir(); void SetNum(int); void SetDen(int); int Numerador(); int Denominador(); void Simplificar(); Fraccion operator+(const Fraccion&); private: int num; int den; int MCD(); };

Ejemplo Fraccion operator+(const Fraccion&); { Fraccion g; Fraccion Fraccion::operator+(const Fraccion &f) { Fraccion g; g.num=f.num*den + num*f.den; g.den= den * f.den; g.Simplificar(); return g; }

Ejemplo class Fraccion {public: Fraccion(int=0 ,int=1 ); // Por defecto void Imprimir(); void SetNum(int); void SetDen(int); int Numerador(); int Denominador(); void Simplificar(); Fraccion& operator+(const Fraccion&); private: int num; int den; int MCD(); };

Ejemplo { num = num * y.den + den * y.num; den = den * y.den; Fraccion& operator+ (const Fraccion&); Fraccion& Fraccion::operator+(const Fraccion& y) { num = num * y.den + den * y.num; den = den * y.den; Simplificar(); return *this; };

El operador sobrecargado: 2. Operador Friend Función "Amiga" de la clase Operador actúa sobre varios objetos SIN modificarlos Primer parámetro (objeto de la izquierda). Ahora explícito a) f1 + f2 b) f5 * f3

Ejemplo class Fraccion {public: Fraccion(int=0 ,int=1 ); // Por defecto void Imprimir(); void SetNum(int); void SetDen(int); int Numerador(); int Denominador(); void Simplificar(); friend Fraccion operator+ (const Fraccion&,const Fraccion&); private: int num; int den; int MCD(); };

Ejemplo {Fraccion h; h.num= g.num*f.den+ f.num*g.den friend Fraccion operator+ (const Fraccion&,const Fraccion&); Fraccion operator+(const Fraccion &f, const Fraccion &g) {Fraccion h; h.num= g.num*f.den+ f.num*g.den h.den= g.den*f.den return h; }

SOBRECARGA DE OPERADORES DE RELACIÓN

Ejemplo: Sobrecargar == bool operator==(const Fraccion&); bool Fraccion::operator==(const Fraccion &f) {return (num*f.den==den*f.num); } a) if (f1==f2) b) x= (f1==f2);

SOBRECARGA DEL OPERADOR DE ASIGNACIÓN

Ejemplo: Sobrecargar = Fraccion& operator=(const Fraccion&); Fraccion& operator=(const Fraccion &f) { if (this!=&f) {num= f.num; den= f.den; } return *this; f1= f2;

Diferencia a) El constructor de Copia inicializa memoria no inicializada. Fraccion::Fraccion(const Fraccion& k) {num=k.num; den=k.den; } Fraccion f(3,4); Fraccion g(f);

Diferencia b) El operador de asignación Protege contra la "auto-asignación" Elimina posibles elementos antiguos Inicializa y copia los nuevos elementos Fraccion& operator=(const Fraccion &f) { if (this!=&f) {num= f.num; den= f.den; } return *this;

Variables Dinámicas La implementación de este operador será más interesante cuando el objeto posea variables dinámicas: f: p: Métodos num: 2 den: 3

SOBRECARGA DE OPERADORES << - >> << - >> cout <<f; cout<<"la fracción es:"<<f; cout<<"La suma de"<<f<<" y" <<g<<"es:"<<h; cin>>f;

Sobrecarga: << - >> Sobrecargar operadores de flujos, requiere: a) Que el primer operando sea un objeto de la clase del: Flujo de entrada: istream Flujo de salida : ostream. b) Que el método retorne la dirección del objeto para que se pueda utilizar varias veces en una expresión

Ejemplo: Sobrecargar << friend ostream& operator<< (ostream&,const Fraccion&); ostream& operator <<(ostream &sal, const Fraccion &f) {sal << f.num << " / " <<f.den; return sal; } cout <<f; cout<<"la fracción es:"<<f; cout<<"La suma de"<<f<<" y" <<g<<"es:"<<h;

COMPOSICIÓN DE CLASES

Composición de Clases Relación de pertenencia. Incluir objetos de una clase A como miembros de datos de otra clase B.

Clase Mixto class Mixto {public: Mixto(); Fraccion Equivalente(); float Equivalente(); void Listar(); private: int ent; Fraccion f; };

Clase Curso class Curso {public: Curso(int t=30); void Inscribir(Alumno&); void Listar(); double Promedio(); int Aprobados(); int Reprobados(); private: int N; char nom[25]; char cod[7]; Alumno v[50]; };

Composición de Clases El constructor de la clase que contiene objetos de otras clases llamará a los constructores de cada uno de los objetos contenidos. Un constructor default de la clase, llamará implícitamente a los constructores default de los objetos miembros de una clase que componen la clase inicial

Constructor Alumno Alumno::Alumno() {k=0; t=0;} Alumno::Alumno(char *n, char *r, int m, int c) {strcpy(nom,n); strcpy(rut,r); mat=m; carrera=c; k=0; t=0; }

Invocación explícita al constructor Constructor Curso Curso::Curso(int t) {N=t; cin.getline(nom,25); cin.getline(cod,7); char *x, *y; int z,c; for (int i=0;i<N;i++) { cout<<"NOMBRE: "; cin.getline(x,20); cout<<"RUT : "; cin>>y; cout<<"MAT : "; cin>>z; cout<<"Carr : "; cin>>c; Alumno a(x,y,z,c); v[i]= a; }} Objeto anónimo Invocación explícita al constructor

Listar void Curso::Listar() {for (int i=0;i<N;i++) T[i].Listar(); } void main() {Curso C; C.Listar(); }

Composición de clases class Empleado class Fecha {private: {private: char *nom; char *app; float sueldo; Fecha fnac; Fecha fcontr; public: Empleado(char*, char*, float, int, int, int, int, int, int); void Imprimir(); } objetos de clase Fecha class Fecha {private: int dia; int mes; int año; int ValidaDia(); public: Fecha(int,int,int); void Imprimir(); }

Composición de clases Los constructores inicializan miembros de datos. Éstos se invocan en el constructor de la clase contenedora Por lo tanto, ANTES de inicializar los datos de la clase contenedora (Mixto, Curso, Empleado) deberán inicializarse aquellos datos que sean objetos de otras clases, por medio, de sus constructores.

inicialización de objetos de clase fecha Composición de clases Empleado::Empleado( char *n, char*a, float s, int nd, int nm, int na, int cd, int cm, int ca) : fnac(nd,nm,na), fcontr(cd,cm,ca) { strncpy(nom,n,24); strncpy(app,a,24); sueldo=s; } inicialización de objetos de clase fecha void Empleado::Imprimir() {cout<< "Nom: "<<nom; "Apellido: "<< app<<"Sueldo: "<<s; fnac.Imprimir(); fcontr.Imprimir(); } Llamada a métodos de la clase Fecha

Uso de la clase Empleado #include "empldef.h" void main() {Empleado x("Juan", "Pérez", 650.000,1,10,65,15,10,2000); x.Imprimir(); }

PLANTILLAS DE FUNCIONES

Plantillas de Funciones Mecanismo para implementar funciones genéricas template <classT> tipo nombre(parámetros) {sentencias}

Ejemplo void main() template <class T> {int r=5,s=7; Swap(r,s) cout<<r<<s<<endl; double x=1.1, y=3.3; Swap(x,y); } template <class T> void Swap(T&a , T&b) {T aux; aux= a; a= b; b= aux; }

Plantillas de Funciones void main() { int V[5]; Crear(V,5); Listar(V,5); float X[4]; Crear(X,4); Listar(X,4); char C[6]; Crear(C,6); Listar(C,6); }

Plantillas de Funciones template <class T> void Crear(T v[], int n) {for (int i=0;i<n;i++) cin>>v[i]; } void Listar(T v[], int n) cout<<v[i];

PLANTILLAS DE CLASES

Plantillas de clases Mecanismo para implementar: Clases genéricas template<class T> class nombre {private: Métodos Variables public: }

Plantilla de clases template <class T> class Stack {private: T *p; int top; int largo; bool Full(); public: Stack(int s=10); bool Empty(); bool Push(T); T Pop(); ~Stack(); };

Métodos template <class T> Stack<T>::Stack(int s) {largo = s; top = -1; p=new T[largo]; } template <class T> bool Stack<T>::Push(T e) { if (!Full()) { p[++top]=e; return true; } return false; template <class T> bool Stack<T>::Empty() {return top==-1;} template <class T> Stack<T>::~Stack() {delete [ ] p;}

Uso de clases genéricas void main() { Stack<int> S,S2; Poblar(S); Listar(S); S2=S; Listar(S2); Stack<float> S3; Poblar(S3); Listar(S3); Invertir(S3); Ordenar(S1,S2) }