PROGRAMACIN ORIENTADA A OBJETOS USANDO C++

NDICE
Separacin: Interfaz-Implementacin
Objetos constantes

Funciones miembro constantes

Constructores Destructores

SEPARACIN
INTERFAZ IMPLEMENTACIN USO

Interfaz : Header
Contiene la declarativa (descripcin) de la clase. Uso en el mismo proyecto: #include "nombre.h" Uso en otro proyecto, debe incluir el path hasta el proyecto en el que se encuentra definido:
#include "path\nombre.h"

Interfaz
// Interfaz de la clase Par en el archivo defpar.h #ifndef defpar #define defpar class Par { private: // Atributos int x, y; public: // Mtodos Par(); Par(int, int); int mas(); int por(); void verM(); void verP(); }; #endif

Implementacin
// Implementacin de la clase Par en un archivo .cpp #include <iostream.h> #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; } int Par::por() { return x*y; } void Par::verM() { cout << "\n" << x << " + " << y << " = " << mas(); } void Par::verP() { cout << "\n" << x << " * " << y << " = " << por(); }

Uso
// Uso de la clase Par en un archivo .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; }

OBJETOS CONSTANTES

Objetos constantes
Declaracin de variables NO modificables por asignacin.
Si es una variable miembro, ninguna de las funciones miembro podr modificarla.

const tipo variable;

10

Uso de la clase
void main()

{ const Hora x(12,3,10); Error x.AsignaHora(9); x.AsignaMin(34); Intento de modificar objeto constante x.AsignaSeg(22); cout<<x.MuestraHora()<<endl; Hora y; y.AsignaHora(5); y.AsignaMin(3); y.AsignaSeg(16); cout<<y.MuestraHora()<<endl;

};

11

FUNCIONES CONSTANTES

12

Funciones miembro constantes

La funcin miembro NO puede modificar el objeto.

tipo Nombre(parmetros) const;

13

Ejemplo: Clase hora

class Hora
{public: Hora(int=0, int=0, int=0); void AsignaHora(int); void AsignaMin(int); void AsignaSeg(int); int MuestraHora() const; private: int hh; int mm; int ss; };

// Funcin constante

14

Implementacin
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;} { ss=s;}

void Hora::AsignaSeg(int s)
int Hora::MuestraHora() const
{ return hh;}

15

CONSTRUCTORES

16

Constructores
Crea un objeto de la clase. Da valores iniciales a las variables miembro.
Se invoca en el momento de la instanciacin (creacin) de un objeto. No posee valor de retorno Puede sobrecargarse Si en la clase NO se define un constructor, el compilador proporciona un constructor de oficio (por defecto).

17

Constructores
Invocacin implcita: Creacin de un objeto

Fraccion f; Fraccion f(3,7);

Invocacin explcita: Creacin de un objeto annimo, utilizado para inicializar otro objeto de la clase.

Fraccion g=Fraccion(); Fraccion h = Fraccion(4,9);

18

Constructores
Viola el principio de encapsulacin

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

19

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

Fraccion::Fraccion(int x,int y)
{num=x; den=y; }

20

Inicializadores

Seccin de inicializaci n

Fraccion::Fraccion(int x,int y):num(x),den(y)

{ puede ir el cuerpo vaco }

Son ms eficientes que las asignaciones Son de gran utilidad : Para inicializar objetos contantes. En clases derivadas (herencia)

21

Variables miembro contantes

La declaracin de variables miembro constante es para impedir que una funcin miembro realice una modificacin de su valor
Para que el constructor pueda inicializarla

Inicializador

variable(valor)

22

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

23

Implementacin 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<<"incremn : "<<inc<<endl; }

24

USO: Clase Incremento

void main()
{ Incremento x(1,5); int i; x.Listar(); for (i=1;i<=6;i++) x.Increm(); cout<<"\nDespus de "<< i<<" incrementos: "; x.Listar(); x.Decrem(); x.Listar(); }

25

Tipo de constructores

De oficio Por defecto De copia

26

Constructor de Oficio
Constructor por defecto No posee parmetros Lo define automticamente el compilador, si el usuario NO define ningn constructor

27

Por Defecto
No posee argumentos, o Los argumentos tienen asignado un valor por defecto en la declaracin del mtodo.
Fraccion f;

Es til en la declaracin de una composicin de clases:

Fraccion V[100];

28

Por Defecto
Constructor que NO requiere parmetros
Fraccion( ); Fraccion(int x=0 ,int y=1 ); Declarativas permitidas: Fraccion f; Fraccion g(3); Fraccion h(2,5);

29

De Copia
Permite crear objetos inicializndolo a partir de otro objeto de la misma clase. Posee un nico parmetro que es un objeto de la misma clase cuyos valores se utilizarn para inicializar el nuevo objeto creado. Ejemplo de uso:
Fraccion h(f);

30

De Copia de oficio
El compilador proporciona un constructor de copia de oficio. ste realiza una copia bit a bit de las variables miembro del objeto original al objeto copia.

31

Necesidad de un costructor de copia

Alumno a1; a1: *nom
mat: 12345 prom:4,7 "Esteban Quito"

class Alumno {private: char *nom; int mat; float prom; ... }

Alumno a2(a1); a2: *nom

mat: 12345

prom:4.7

32

De Copia
Este constructor tiene SLO UN argumento que es una referencia constante a un objeto de la clase.
Fraccion (const Fraccion&); Fraccion f1(f2);

33

De Copia

Fraccion::Fraccion(const Fraccion& K)

{num=K.num;
den=K.den; }

34

DESTRUCTORES

35

Destructores
Complemento de los constructores NO posee valor de retorno NO puede sobrecargarse, es nico NO posee argumentos. Tiene el mismo nombre de la clase con un tilde como prefijo:
~Clase ();

36

Destructores
Es llamado implcitamente cuando un objeto va a dejar de existir.
Los objetos creados dinmicamente (new) deben eliminarse en forma explcita con delete. El compilador proporciona un destructor, excepto para liberar memoria dinmica Clase::~Clase ()
{delete [] v;}

37

Destructores
class Alumno
{private: char *nom; int matr; void main() {Alumno a("Juan"); Alumno b("Mara",1234); a.Listar(); b.Listar(); }

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

38

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