Está en la página 1de 52

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

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 f=f1 + f2
 Complejos c=c1 + c2
 Vectores, etc. v=v+k

Operadores de flujo:
cout<<f;
 Fracciones
cin>>c;
 Complejos
 Vectores, etc. 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 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

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

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: num: 2
den: 3
Métodos
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

Constructor Curso
Curso::Curso(int t)
{N=t; Objeto
cin.getline(nom,25); anónimo
cin.getline(cod,7); Invocación
explícita al
char *x, *y; constructor
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; }}
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 Fecha class Empleado objetos


{private: {private: de
int dia; char *nom; clase
int mes; char *app; Fecha
int año; float sueldo;
int ValidaDia(); Fecha fnac;
public: Fecha fcontr;
Fecha(int,int,int) public:
;
void Imprimir(); Empleado(char*, char*, float, int,
int, int, 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

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);
inicializació
sueldo=s;
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", 650.000,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

template <class T> void main()


void Swap(T&a , T&b) {int r=5,s=7;
{T aux; Swap(r,s)
aux= a; cout<<r<<s<<endl;
a= b; double x=1.1, y=3.3;
b= aux; 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

Clases
Mecanismo para implementar:
genéricas

template<class T>
class nombre
{private:
Métodos
Variables
public:
Métodos
Variables
}
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> template <class T>


Stack<T>::Stack(int s) bool Stack<T>::Push(T e)
{largo = s; { if (!Full())
top = -1; { p[++top]=e;
p=new T[largo];
return true;
}
}
return false;
}
template <class T>
bool Stack<T>::Empty() template <class T>
{return top==-1;} 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)
}

También podría gustarte