programaciÓn orientada a objetos usando c++. 2 proyectos en c++

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 de la clase Par en archivo defpar.hclass Par { private: // Atributos int x, y; public: // Métodos Par(); Par(int, int); int mas(); int por(); void verM(); void verP();};

Interfaz

5

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

Implementación

6

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

Implementación

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

FUNCIONES CONSTANTES

9

Métodos constantes

Un método constante NO puede modificar los atributos del objeto

<tipo> <nombre>(<parámetros>) const;

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

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

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

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

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;

}

ErrorIntento de modificar objeto constante

Uso de la clase Hora

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

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

Fraccion::Fraccion(int x,int y) {SetNum(x);SetDen(y);

}

Fracción::Fraccion(int x,int y) {num=x; den=y;

}

Constructores

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

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

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

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

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

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 No define ningún constructor

Inicializa los atributos según los valores por omisión establecidos por el lenguaje

29

Constructor por Defecto

Constructor sin Parámetros Inicializa los atributos con valores por

defectoclass Fraccion {

private:int num;int den;

public:Fraccion();…

};

30

Constructor por Defecto

Implementación

Composición

Fraccion::Fraccion() {num=0;den=1;

}

Fraccion V[100];

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

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

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

Constructor de Copia

class Alumno { private: char *nom;

int mat;float prom;...

}

Alumno a2;

*nom:mat: 12345prom:4.7

*nom:mat: 12345prom:4.7

Alumno a1;

"Serapio Jento"

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

class Alumno {private:

char *nom; int matr; double prom;

public:Alumno();Alumno(char *, int);void Listar();~Alumno();

};

Interfaz

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

int main() {Alumno a("Juan");

Alumno b("María", 1234); a.Listar(); b.Listar();

return 0;}

Uso