Вы находитесь на странице: 1из 34

PROGRAMACIÓN ORIENTADA A

OBJETOS USANDO C++


2

Puntero this

 Variable predefinida para todos los métodos de


la clase (parámetro oculto)
 Es un puntero al objeto sobre el cual está
actuando el método (No es el objeto)
 En la invocación de un método, el objeto es un
parámetro implícito
 El puntero this contiene la dirección del objeto
que activó al método y No es posible modificarlo
3

Puntero this

 La existencia del parámetro implícito permite


referenciar directamente los atributos del
objeto sin los operadores punto o flecha
 Un método No puede referirse al objeto mismo
como un todo, sino a cada una de sus partes
 El puntero this permite referirse al objeto
como tal

*this
4

Puntero this

 Las siguientes sentencias son equivalentes en el


bloque del constructor por defecto de la clase
Par

1. x = 0;
2. this->x = 0;
3. (*this).x = 0;
5

COMPOSICIÓN
DE CLASES
6

Composición de clases

 Se manifiesta como una relación de pertenencia


(tiene-un)
 Consiste en declarar objetos de una clase A
como atributos de otra clase B
 El constructor de la clase que contiene objetos
de otras clases llamará a los correspondientes
constructores
 Un constructor por defecto de la clase llamará
implícitamente a los constructores por defecto
de los objetos declarados como atributos
7

Composición de clases

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

Composición de clases

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

Composición de clases

Alumno::Alumno() {
k = 0;
t = 0;
}
Alumno::Alumno(char *n, char *r, int m, int c) {
nom = new char[strlen(n)+1];
rut = new char[strlen(r)+1];
strcpy(nom, n);
strcpy(rut, r);
mat = m;
carrera = c;
k = 0;
t = 0;
}
10

Composición de clases

Curso::Curso(int t) {
N=t;
cin.getline(nomCur, 25);
cin.getline(codCur, 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;
}
}
11

Composición de clases

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

int main() {
Curso C;
C.Listar();
return 0;
}
12

PLANTILLAS
DE FUNCIONES
13

Plantillas de funciones

 Constituyen un mecanismo para implementar


funciones genéricas

template <class T>


<tipo> <nombre>(<parámetros>) {
//sentencias
}
14

Plantillas de funciones

template <class T>


void Swap(T &a , T &b) {
T aux;
aux = a;
a = b;
b = aux;
}
15

Plantillas de funciones

int 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;
return 0;
}
16

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

Plantillas de funciones

int 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);
return 0;
}
18

PLANTILLAS
DE CLASES
19

Plantillas de clases

 Constituyen un mecanismo para implementar


clases genéricas
template<class T>
class <nombre> {
private:
// Métodos
// Atributos
public:
// Métodos
// Atributos
}
20

Plantillas de clases

template <class T>


class Vector {
public:
Vector(int n);
~Vector();
void setElem(T);
void verVector();
private:
T *v;
int actual;
int maximo;
};
21

Plantillas de clases

template <class T>


Vector<T>::Vector(int n) {
maximo = n;
actual = 0;
v = new T[maximo];
}
template <class T>
Vector<T>::~Vector() {
delete[] v;
}
22

Plantillas de clases

template <class T>


void Vector<T>::setElem(T e) {
v[actual] = e;
actual++;
}
template <class T>
void Vector<T>::verVector() {
int i;
for(i=0; i<actual; i++)
cout << " V[" << i << "] = " << v[i];
cout << endl;
}
23

Plantillas de clases

int main(int argc, char *argv[]) {


Vector<char> vB(8); // Vector de 8 caracteres
Vector<int> vI(6); // Vector de 6 enteros
Vector<float> vF(4); // Vector de 4 reales
int i;
for(i=0; i<6; i++)
vI.setElem(2*i+1);
cout << "Vector de enteros" << endl;
vI.verVector();
}
24

Plantillas de clases

template <class T, int maximo>


class Vector {
public:
Vector();
~Vector();
void setElem(T);
void verVector();
private:
T *v;
int actual;
};
25

Plantillas de clases

template <class T, int maximo>


Vector<T, maximo>::Vector() {
actual = 0;
v = new T[maximo];
}
template <class T, int maximo>
Vector<T, maximo>::~Vector() {
delete[] v;
}
26

Plantillas de clases

int main(int argc, char *argv[]) {


Vector<char, 8> vB; // Vector de 8 caracteres
Vector<int, 6> vI; // Vector de 6 enteros
Vector<float, 4> vF; // Vector de 4 reales
int i;
for(i=0; i<4; i++)
vF.setElem(i+2.5);
cout << "Vector de reales" << endl;
vF.verVector();
}
27

HERENCIA
28

Herencia

 Se expresa como una relación de descendencia


(es-un)
 Consiste en definir una nueva clase a partir de
una existente
 La nueva clase se denomina subclase o clase
derivada
 La clase existente se denomina superclase o
clase base
 Es la propiedad que permite a los ejemplares de
una subclase acceder a los miembros de la
superclase
29

Herencia

 Las subclases heredan tanto los atributos como


los métodos de la superclase
 La herencia es transitiva
 Una subclase tiene todas las propiedades de la
superclase y otras más (extensión)
 Una subclase constituye una especialización de
la superclase (reducción)
 Un método de superclase es anulado por un
método con el mismo nombre definido en la
subclase
30

Herencia

 Un constructor de subclase siempre invoca


primero al constructor de su superclase
 Un destructor de subclase se ejecuta antes que
el destructor de su superclase
 No se necesita reescribir el código del
comportamiento heredado
 La reutilización de software sólo exige conocer
la funcionalidad del componente y su interfaz
 Los métodos heredados se ejecutan más
lentamente que el código especializado
31

Herencia

class Trio : public Par {


private:
int z;
public:
Trio();
Trio(int, int, int);
int sum();
int prod();
void verM();
void verP();
};
32

Herencia

Trio::Trio() : Par() {
z = 0;
}
Trio::Trio(int a, int b, int c) : Par(a, b) {
z = c;
}
int Trio::sum() {
return Par::mas() + z;
}
int Trio::prod() {
return Par::por()*z;
}
33

Herencia

void Trio::verM() {
Par::verM();
cout << " + " << z << " = " << sum();
}
void Trio::verP() {
Par::verP();
cout << " * " << z << " = " << prod();
}
34

Herencia

int main() {
Par *p = new Par(4, 8) ;
Trio *t = new Trio(2, 5, 8);
(*p).verM();
(*p).verP();
(*t).verM();
(*t).verP();
return 0;
}