PROGRAMACIN ORIENTADA A OBJETOS USANDO C 2 Puntero

PROGRAMACIÓN ORIENTADA A OBJETOS USANDO C++

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

3 Puntero this v La existencia del parámetro implícito permite referenciar directamente los atributos del objeto sin los operadores punto o flecha v Un método No puede referirse al objeto mismo como un todo, sino a cada una de sus partes v El puntero this permite referirse al objeto como tal *this

4 Puntero this v 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 v Se manifiesta como una relación de pertenencia (tiene-un) v Consiste en declarar objetos de una clase A como atributos de otra clase B v El constructor de la clase que contiene objetos de otras clases llamará a los correspondientes constructores v 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 nom. Cur[25]; char cod. Cur[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(nom. Cur, 25); cin. getline(cod. Cur, 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 v 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 v 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 set. Elem(T); void ver. Vector(); 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>: : set. Elem(T e) { v[actual] = e; actual++; } template <class T> void Vector<T>: : ver. Vector() { 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> v. B(8); // Vector de 8 caracteres Vector<int> v. I(6); // Vector de 6 enteros Vector<float> v. F(4); // Vector de 4 reales int i; for(i=0; i<6; i++) v. I. set. Elem(2*i+1); cout << "Vector de enteros" << endl; v. I. ver. Vector(); }

24 Plantillas de clases template <class T, int maximo> class Vector { public: Vector(); ~Vector(); void set. Elem(T); void ver. Vector(); 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> v. B; // Vector de 8 caracteres Vector<int, 6> v. I; // Vector de 6 enteros Vector<float, 4> v. F; // Vector de 4 reales int i; for(i=0; i<4; i++) v. F. set. Elem(i+2. 5); cout << "Vector de reales" << endl; v. F. ver. Vector(); }

27 HERENCIA

28 Herencia v Se expresa como una relación de descendencia (es-un) v Consiste en definir una nueva clase a partir de una existente v v La nueva clase se denomina subclase o clase derivada La clase existente se denomina superclase o clase base v Es la propiedad que permite a los ejemplares de una subclase acceder a los miembros de la superclase

29 Herencia v Las subclases heredan tanto los atributos como los métodos de la superclase v La herencia es transitiva v Una subclase tiene todas las propiedades de la superclase y otras más (extensión) v Una subclase constituye una especialización de la superclase (reducción) v Un método de superclase es anulado por un método con el mismo nombre definido en la subclase

30 Herencia v Un constructor de subclase siempre invoca primero al constructor de su superclase v Un destructor de subclase se ejecuta antes que el destructor de su superclase v No se necesita reescribir el código del comportamiento heredado v La reutilización de software sólo exige conocer la funcionalidad del componente y su interfaz v 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 sum(); int prod(); void ver. M(); void ver. P(); };

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: : ver. M() { Par: : ver. M(); cout << " + " << z << " = " << sum(); } void Trio: : ver. P() { Par: : ver. P(); cout << " * " << z << " = " << prod(); }

34 Herencia int main() { Par *p = new Par(4, 8) ; Trio *t = new Trio(2, 5, 8); (*p). ver. M(); (*p). ver. P(); (*t). ver. M(); (*t). ver. P(); return 0; }