PROGRAMACIÓN ORIENTADA A OBJETOS USANDO C++. 2 PROYECTOS EN C++

Presentación del tema: "PROGRAMACIÓN ORIENTADA A OBJETOS USANDO C++. 2 PROYECTOS EN C++"— Transcripción de la presentación:

1 PROGRAMACIÓN ORIENTADA A OBJETOS USANDO C++

2 2 PROYECTOS EN C++

3 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 4 // 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(); }; Interfaz

5 5 // Implementación de la clase Par en archivo imp.cpp #include #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; } Implementación

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

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

8 8 FUNCIONES CONSTANTES

9 9 Métodos constantes  Un método constante NO puede modificar los atributos del objeto ( ) const;

10 10 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; }; Interfaz de la clase Hora

11 11 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; } Implementación de la clase Hora

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

13 13 OBJETOS CONSTANTES

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

15 15 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; } Error Intento de modificar objeto constante Uso de la clase Hora

16 16 CONSTRUCTORES

17 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 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 19 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); Constructores Viola el principio de encapsulamiento

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

21 21 Inicializadores  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 } Sección de inicialización

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

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

24 24 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; } Implementación de la clase Incremento

25 25 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; } Uso de la clase Incremento

26 26 Tipos de constructores  Por Defecto  Con Argumentos  De Copia

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

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

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

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

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

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

33 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 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 35 Constructor de Copia class Alumno { private: char *nom; int mat; float prom;... } Alumno a2; *nom: mat: 12345 prom:4.7 *nom: mat: 12345 prom:4.7 Alumno a1; "Serapio Jento"

36 36 DESTRUCTORES

37 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 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 39 class Alumno { private: char *nom; int matr; double prom; public: Alumno(); Alumno(char *, int); void Listar(); ~Alumno(); }; Interfaz

40 40 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; } Implementación

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