PROGRAMACIÓN ORIENTADA A OBJETOS USANDO C++

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

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

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;

COMPOSICIÓN DE CLASES

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

Composición de clases class Mixto { public: Mixto(); Fraccion Equivalente(); float Equivalente(); void Listar(); private: int ent; Fraccion f; };

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

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;

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

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

PLANTILLAS DE FUNCIONES

Plantillas de funciones Constituyen un mecanismo para implementar funciones genéricas template <class T> <tipo> <nombre>(<parámetros>) { //sentencias }

Plantillas de funciones template <class T> void Swap(T &a , T &b) { T aux; aux = a; a = b; b = aux; }

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

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) cout << v[i];

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

PLANTILLAS DE CLASES

Plantillas de clases Constituyen un mecanismo para implementar clases genéricas template<class T> class <nombre> { private: // Métodos // Atributos public: }

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

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

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

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

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

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

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

HERENCIA

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

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

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

Herencia class Trio : public Par { private: int z; public: Trio(); Trio(int, int, int); int sum(); int prod(); void verM(); void verP(); };

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;

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

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