PROGRAMACIÓN ORIENTADA A OBJETOS USANDO C++

1. PROGRAMACIÓN ORIENTADA A OBJETOS USANDO C++

2. PROYECTOS EN C++

3. Construcción de un proyecto • Un proyecto se construye separando la interfaz (definición) de la implementación de una clase • La interfaz debe crearse como header (archivo con extensión .h) • Uso en la implementación y en el mismo proyecto: • Uso en otro proyecto  incluir la respectiva ruta de acceso: #include "nombre.h" #include "path\nombre.h"

4. Interfaz // Interfaz de la clase Par en archivo defpar.h class Par { private: // Atributos int x, y; public: // Métodos Par(); Par(int, int); int mas(); int por(); void verM(); void verP(); };

5. Implementación // Implementación de la clase Par en archivo imp.cpp #include <iostream> #include "defpar.h" Par::Par() { x = 0; y = 0; } Par::Par(int a, int b) { x = a; y = b; } int Par::mas() { return x + y; }

6. Implementación int Par::por() { return x*y; } void Par::verM() { cout << x << " + " << y << " = " << mas(); } void Par::verP() { cout << x << " * " << y << " = " << por(); }

7. Uso // Uso de la clase Par en archivo uso.cpp #include "defpar.h " int main() { Par *p = new Par(); Par *q = new Par(4, 8); (*p).verM(); (*p).verP(); (*q).verM(); (*q).verP(); return 0; }

8. FUNCIONES CONSTANTES

9. Métodos constantes • Un método constante NOpuede modificar los atributos del objeto <tipo> <nombre>(<parámetros>) const;

10. Interfaz de la clase Hora class Hora { public: Hora(int=0, int=0, int=0); void AsignaHora(int); void AsignaMin(int); void AsignaSeg(int); void MuestraHora() const; void MuestraMin() const; void MuestraSeg() const; private: int hh; int mm; int ss; };

11. Implementación de la clase Hora Hora::Hora(int h, int m, int s) { hh = (h>=0 && h<24) ? h:0; mm = (m>=0 && m<60) ? m:0; ss = (s>=0 && h<60) ? s:0; } void Hora::AsignaHora(int h) { hh=h; } void Hora::AsignaMin(int m) { mm=m; } void Hora::AsignaSeg(int s) { ss=s; }

12. Implementación de la clase Hora void Hora::MuestraHora() const { cout << hh << " horas "; } void Hora::MuestraMin() const { cout << mm << " minutos "; } void Hora::MuestraSeg() const { cout << ss << " segundos "; }

13. OBJETOS CONSTANTES

14. Objetos constantes • Declaración de variables NO modificables por asignación • Si la variable es un atributo, ninguno de los métodos puede modificarla const <tipo> <variable>;

15. Error Intento de modificar objeto constante Uso de la clase Hora int main() { const Hora x(12,3,10); x.AsignaHora(9); x.AsignaMin(34); x.AsignaSeg(22); Hora y; y.AsignaHora(5); y.AsignaMin(3); y.AsignaSeg(16); return 0; }

16. CONSTRUCTORES

17. Constructores • Un constructor es un método cuyo nombre es el mismo de su clase • Se activa implícitamente para crear un objeto • Permite dar valores iniciales a los atributos • No es una función que retorne un valor • Si en la clase No se define un constructor, el compilador proporciona un constructor de oficio(por omisión)

18. Constructores • Puede sobrecargarse • Invocación implícita • Invocación explícita Fraccion f; Fraccion f(3, 7); Fraccion g = Fraccion(); Fraccion h = Fraccion(4, 9);

19. Viola el principio de encapsulamiento Constructores Fraccion f; f.num=6; Fraccion f(5,3); Fraccion f= Fraccion(5,3); Fraccion *f=new Fraccion; Fraccion *g; g=new Fraccion(2,5);

20. Constructores Fraccion::Fraccion(int x,int y) { SetNum(x); SetDen(y); } Fracción::Fraccion(int x,int y) { num=x; den=y; }

21. Inicializadores Sección de inicialización • Ocultan la asignación explícita • Son de gran utilidad: • Para inicializar objetos constantes • En clases derivadas (herencia) Fraccion::Fraccion(int x,int y) : num(x), den(y) { // puede ir el cuerpo vacío }

22. Uso de Inicializador cuya forma es atributo(valor) Atributos constantes • La declaración de atributos constantes se realiza para impedir que un método efectúe una modificación de sus valores

23. Interfaz de la clase Incremento class Incremento { public: Incremento(int c=0, int k=1); void Increm(); void Decrem(); void Listar() const; private: int cont; const int inc; };

24. Implementación de la clase Incremento Incremento::Incremento(int c, int k): inc(k) { cont=c; } void Incremento::Increm() { cont+=inc; } void Incremento::Decrem() { cont -=inc; } void Incremento::Listar() const { cout<<"contador: "<<cont<<endl; cout<<"incremento: "<<inc<<endl; }

25. Uso de la clase Incremento int main() { Incremento x(1,5); int i; x.Listar(); for (i=1;i<=6;i++) x.Increm(); cout<<"Después de "<< i<<" incrementos: "; x.Listar(); x.Decrem(); x.Listar(); return 0; }

26. Tipos de constructores • Por Defecto • Con Argumentos • De Copia

27. Constructor por Defecto • Un constructor por defecto puede ser: • De Oficio • Sin Parámetros • Con Parámetros

28. Constructor por Defecto • Constructor de Oficio • Existe por omisión • Lo incorpora automáticamente el compilador, si el usuario Nodefine ningún constructor • Inicializa los atributos según los valores por omisión establecidos por el lenguaje

29. Constructor por Defecto class Fraccion { private: int num; int den; public: Fraccion(); … }; • Constructor sin Parámetros • Inicializa los atributos con valores por defecto

30. Constructor por Defecto Fraccion::Fraccion() { num=0; den=1; } • Implementación • Composición FraccionV[100];

31. Constructor por Defecto Fraccion(int x=0,int y=1) • Constructor con Parámetros • Los parámetros formales tienen asignado un valor por defecto en la declaración del método • Declaraciones permitidas: Fraccion f; Fraccion g(3); Fraccion h(2, 5);

32. Constructor con Argumentos Fraccion(int x) Fraccion(int x,int y=1) • Prototipos • Declaraciones permitidas int a=3, b=6, c=9; Fraccion g(a); Fraccion h(b, c);

33. Constructor de Copia • Permite crear un objeto e inicializarlo a partir de otro objeto de la misma clase • Tiene, como único parámetro, un objeto de su clase el cual se utilizará en la inicialización • El compilador provee un constructor de copia de oficio que efectúa la copia de los atributos del objeto original en el nuevo

34. Constructor de Copia • Su único parámetro es una referencia constante a un objeto de la clase Fraccion (const Fraccion &) Fraccion::Fraccion(const Fraccion &k) { num = k.num; den = k.den; } Fraccion f1(f2);

35. Alumno a1; Alumno a2; class Alumno { private: char *nom; int mat; float prom; ... } *nom: mat: 12345 prom:4.7 "Serapio Jento" *nom: mat: 12345 prom:4.7 Constructor de Copia

36. DESTRUCTORES

37. Destructor • Complemento del constructor • No es una función void o que retorne un valor • No puede sobrecargarse pues es único • No posee argumentos • Tiene el mismo nombre de la clase precedido del símbolo ~ ~Clase ()

38. Destructor • Es llamado implícitamente cuando finaliza el bloque que determina el alcance del objeto • Los objetos creados dinámicamente (new) deben eliminarse explícitamente con delete • El compilador provee un destructor, excepto para liberar memoria dinámica Clase::~Clase () { delete [] v; }

39. Interfaz class Alumno { private: char *nom; int matr; double prom; public: Alumno(); Alumno(char *, int); void Listar(); ~Alumno(); };

40. Implementación Alumno::Alumno(char *x, int m=0) { nom = new char[strlen(x)+1]; strcpy(nom, x); matr=m; prom=0.0; } Alumno::~Alumno() { delete [] nom; }

41. Uso int main() { Alumno a("Juan"); Alumno b("María", 1234); a.Listar(); b.Listar(); return 0; }