programaciÓn orientada a objetos usando c++. 2 indice puntero this sobrecarga de operadores...
TRANSCRIPT
PROGRAMACIÓN ORIENTADA A OBJETOS USANDO C++
2
INDICE
Puntero this
Sobrecarga de operadores
Plantilla de funciones
Plantillas de Clases
Composición de Clases
3
PUNTERO
this
4
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.
5
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.
6
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
7
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:
8
SOBRECARGA
DE
OPERADORES
9
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.
10
Sobrecarga de operadores
Operaciones aritméticas para:
Fracciones Complejos Vectores, etc.
Operadores de flujo: Fracciones Complejos Vectores, etc.
cout<<f;
cin>>c;
cout<<v;
f=f1 + f2
c=c1 + c2
v=v+k
11
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 (*.)
12
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.
13
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
14
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();
};
15
Ejemplo
Fraccion operator+(const Fraccion&);
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;}
16
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();
};
17
Ejemplo
Fraccion& operator+ (const Fraccion&);
Fraccion& Fraccion::operator+(const Fraccion& y){ num = num * y.den + den * y.num; den = den * y.den; Simplificar(); return *this; };
18
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
El operador sobrecargado:
19
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();
};
20
Ejemplo
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;}
21
SOBRECARGA DE
OPERADORES DE
RELACIÓN
22
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);
23
SOBRECARGA DEL
OPERADOR DE
ASIGNACIÓN
24
Ejemplo: Sobrecargar =
Fraccion& operator=(const Fraccion&);
Fraccion& operator=(const Fraccion &f){ if (this!=&f) {num= f.num; den= f.den;
} return *this;}
f1= f2;
25
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);
26
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;}
27
Variables Dinámicas
La implementación de este operador será más interesante cuando el objeto posea variables dinámicas:
p:
Métodos
f:num: 2den: 3
28
SOBRECARGA DE
OPERADORES
<< - >>cout <<f;
cout<<"la fracción es:"<<f;cout<<"La suma de"<<f<<" y" <<g<<"es:"<<h;
cin>>f;
29
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
30
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;
31
COMPOSICIÓN
DE
CLASES
32
Composición de Clases
Relación de pertenencia.
Incluir objetos de una clase A como miembros de datos de otra clase B.
33
Clase Mixto
class Mixto{public:
Mixto();Fraccion Equivalente();float Equivalente();void Listar();
private:int ent;Fraccion f;
};
34
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];
};
35
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
36
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;
}
Constructor Alumno
37
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; }}
Constructor Curso
Objeto anónimo
Invocación explícita al constructor
38
void Curso::Listar(){for (int i=0;i<N;i++) T[i].Listar(); }
Listar
void main(){Curso C; C.Listar();}
39
Composición de clases
class Fecha{private:
int dia;int mes;int año;int ValidaDia();
public:Fecha(int,int,int);void Imprimir();
}
class Empleado{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
objetos de
clase Fecha
40
Éstos se invocan en el constructor de la clase contenedora
Los constructores inicializan miembros de datos.
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.
Composición de clases
41
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;
}
void Empleado::Imprimir()
{cout<< "Nom: "<<nom; "Apellido: "<< app<<"Sueldo: "<<s;
fnac.Imprimir();
fcontr.Imprimir();
}
inicialización de objetos de clase
fecha
Composición de clases
Llamada a métodos de la clase Fecha
42
#include "empldef.h"
void main(){Empleado x("Juan", "Pérez", 650.000,1,10,65,15,10,2000);
x.Imprimir();
}
Uso de la clase Empleado
43
PLANTILLAS
DE
FUNCIONES
44
Plantillas de Funciones
Mecanismo para implementar funciones genéricas
template <classT>
tipo nombre(parámetros)
{sentencias}
45
Ejemplo
template <class T>void Swap(T&a , T&b){T aux; aux= a; a= b; b= aux; }
void main(){int r=5,s=7; Swap(r,s) cout<<r<<s<<endl; double x=1.1, y=3.3; Swap(x,y); cout<<r<<s<<endl;}
46
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);}
47
Plantillas de Funciones
template <class T>void Crear(T v[], int n){for (int i=0;i<n;i++) cin>>v[i];}
template <class T>void Listar(T v[], int n){for (int i=0;i<n;i++) cout<<v[i];}
48
PLANTILLAS
DE
CLASES
49
Plantillas de clases
Mecanismo para implementar:
template<class T>class nombre{private: Métodos Variables public: Métodos Variables }
Clases genéricas
50
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();};
51
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;}
52
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)
}
Uso de clases genéricas