PROGRAMACIÓN ORIENTADA A OBJETOS USANDO C++

Presentación del tema: "PROGRAMACIÓN ORIENTADA A OBJETOS USANDO C++"— Transcripción de la presentación:

1 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: 1. tope = -1; 2. this->tope = -1; 3. (*this).tope = -1

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: f=f1 + f2 c=c1 + c2 v=v+k cout<<f; cin>>c; cout<<v;

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 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; }

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 { 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; };

18 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

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 {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; }

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: f: p: Métodos num: 2 den: 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 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; }

37 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

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

39 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(); }

40 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.

41 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

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

43 PLANTILLAS DE FUNCIONES

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

45 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; }

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]; } void Listar(T v[], int n) cout<<v[i];

48 PLANTILLAS DE CLASES

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

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 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) }