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:
#include "nombre.h"
 Uso en otro proyecto  incluir la respectiva ruta
de acceso:
#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 NO puede 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

Uso de la clase Hora

int main() {
const Hora x(12,3,10);
x.AsignaHora(9); Error
x.AsignaMin(34); Intento de modificar objeto constante
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

Fraccion f;
Fraccion f(3, 7);

 Invocación explícita

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

Constructores

Viola el principio de
Fraccion f; encapsulamiento
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

 Ocultan la asignación explícita Sección de

inicialización
 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

Atributos constantes

 La declaración de atributos constantes se

realiza para impedir que un método efectúe una
modificación de sus valores

Uso de

Inicializador
cuya forma es

atributo(valor)
 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 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 defecto

class Fraccion {
private:
int num;
int den;
public:
Fraccion();
…
};
 30

Constructor por Defecto

 Implementación

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

 Composición

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

Fraccion(int x=0, int y=1)

 Declaraciones permitidas:

Fraccion f;
Fraccion g(3);
Fraccion h(2, 5);
 32

Constructor con Argumentos

 Prototipos
Fraccion(int x)
Fraccion(int x, int y=1)

 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

Constructor de Copia

Alumno a1;

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