programaciÓn orientada a objetos usando c++. 2 puntero this variable predefinida para todos los...

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ÓNDE 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

PLANTILLASDE 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

PLANTILLASDE 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

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

Plantillas de clases

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;

}