Professional Documents
Culture Documents
El
paradigma
orientado
a
objetos
se
enfoca
a
las
caractersticas
de
comportamiento
y
estructura
de
las
entidades
como
unidades
completas,
lo
que
nos
permite
disear
software
de
manera
modular
y
con
un
alto
manejo
de
estructuras
de
datos
complejas.
El
paradigma
de
programacin
orientado
a
objetos
se
apoya
en
los
siguientes
conceptos:
Abstraccin
(de
datos)
involucra
la
formulacin
de
un
concepto
(clase)
poniendo
atencin
en
las
similitudes
y
diferencias
entre
las
entidades
de
un
conjunto,
para
extraer
las
caractersticas
esenciales
que
lo
distingan
y
evitar
las
caractersticas
no
relevantes.
Y
as,
se
establece
una
sola
representacin
del
concepto
que
tenga
esas
caractersticas
pertinentes.
Es
la
capacidad
de
crear
tipos
de
datos
definidos
por
el
usuario
extrayendo
las
propiedades
esenciales
de
un
concepto,
sin
preocuparse
de
los
detalles
exactos
de
la
implementacin.
Algunos
simplemente
lo
definen
como
la
capacidad
de
enfocarse
en
lo
esencial.
Encapsulacin
asegura
que
los
usuarios
de
un
objeto
no
alteren
de
manera
inesperada
el
contenido
de
un
objeto;
solo
sus
mtodos
internos
estn
autorizados
para
acceder
a
ellos
y
su
interfaz
pblica
especifica
como
otros
objetos
podran
interactuar
con
l.
La
abstraccin
y
la
encapsulacin
estn
representadas
por
la
clase.
La
clase
es
una
abstraccin,
porque
define
los
atributos
y
mtodos
de
un
determinado
conjunto
de
objetos
con
caractersticas
comunes,
y
es
una
encapsulacin
por
que
constituye
una
caja
negra
que
encierra
tanto
los
datos
que
almacena
como
los
mtodos
que
permiten
manipularlos.
Polimorfismo
es
la
propiedad
que
permite
a
una
operacin
tener
diferente
comportamiento
en
diferentes
objetos.
Es
decir,
diferentes
objetos
reaccionan
de
manera
diferente
al
mismo
mensaje
(de
modo
que
un
mismo
mtodo
pueda
tener
mltiples
implementaciones).
Herencia
es
la
capacidad
de
definir
una
nueva
clase
a
partir
de
otra.
De
esta
forma,
la
reutilizacin
de
cdigo
esta
garantizada.
Las
clases
estn
clasificadas
en
una
jerarqua
estricta,
donde
la
clase
padre
es
conocida
como
superclase
y
la
clase
hijo
como
clase
derivada.
Esto
significa
que
la
clase
derivada
dispone
de
todos
los
atributos
y
mtodos
de
su
superclase.
Los
anteriores
conceptos
son
los
pilares
fundamentales
de
la
programacin
orientada
a
objetos
y
describen
de
manera
precisa
su
funcionamiento.
La
construccin
de
programas
orientados
a
objetos
permite
facilitar
la
comunicacin,
incrementar
la
productividad
y
la
consistencia
en
los
modelos
computacionales,
as
como
facilitar
la
modificacin
de
los
programas
y
reducir
la
complejidad
y
el
esfuerzo
de
resolucin
de
problemas.
1.1
Definicin
de
clase,
atributo,
mtodo
y
objeto
Recuerde
que
las
clases
son
abstracciones
de
entidades
presentes
en
un
dominio
determinado
de
problemas,
y
que
las
clases
estn
compuestas
de
diversos
componentes
que
involucran
el
comportamiento
del
modelo
a
plasmar,
as
pues
definiremos
brevemente
esos
componentes.
Una
clase
es
un
tipo
de
dato
definido
por
el
usuario
(dato
abstracto),
es
muy
similar
a
una
estructura,
ya
que
especifica
los
datos
que
se
vern
involucrados
en
la
construccin
del
programa,
pero
adems
deber
contemplar
la
implementacin
de
las
funciones
que
debern
interactuar
con
dichos
datos.
Con
frecuencia
se
dice
que
la
clase
es
equivalente
a
la
generalizacin
de
un
objeto.
Se
dice
que
los
datos
o
atributos
contenidos
en
la
clase
son
el
conjunto
de
caractersticas
que
definen
las
propiedades
de
un
objeto
especifico,
generalmente
se
conocen
como
variables
del
objeto.
Y
por
otro
lado,
las
funciones
o
mtodos
son
pequeos
programas
altamente
independientes
asociados
a
los
datos
especficos
de
la
clase.
De
manera
que
stos
son
los
componentes
necesarios
para
construir
un
objeto
cualquiera.
As
pues,
los
objetos
son
cajas
negras
que
mantienen
ocultas
propiedades
estructurales
llamadas
atributos,
y
propiedades
de
comportamiento
llamadas
mtodos.
De
esta
forma,
los
objetos
son
entonces
instancias
o
ejemplares
de
una
clase.
Como
una
forma
de
estandarizar
la
nomenclatura
de
clases,
se
especifican
dos
reglas
muy
sencillas.
Los
nombres
de
las
clases
debern
iniciar
con
mayscula
y
escribirse
en
singular,
y
los
nombres
de
los
atributos
y
los
mtodos
debern
escribirse
preferentemente
con
minsculas.
Abstraccin de Datos
La
Abstraccin
de
datos
involucra
la
formulacin
de
un
concepto
(clase)
poniendo
atencin
en
las
similitudes
y
diferencias
entre
las
entidades
de
un
conjunto,
para
extraer
las
caractersticas
esenciales
que
lo
distingan
y
evitar
las
caractersticas
no
relevantes.
Y
as,
se
establece
una
sola
representacin
del
concepto
que
tenga
esas
caractersticas
pertinentes.
Algunos
simplemente
lo
definen
como
la
capacidad
de
enfocarse
en
lo
esencial.
2.1
Tipos
de
datos
definidos
por
el
usuario
en
C
(datos
abstractos)
Es
muy
comn
emplear
las
estructuras
de
datos
como
tipos
de
datos
definidos
por
el
usuario,
adems
de
que
resultan
muy
tiles
ya
que
a
partir
de
ellas
podemos
definir
un
nuevo
tipo
de
dato
que
podr
estar
compuesto
de
elementos
de
otros
tipos
y
en
algunos
casos
quizs
de
ms
estructuras.
Por
otro
lado,
las
funciones
juegan
un
papel
trascendental
en
la
definicin
de
datos,
ya
que
es
posible
construir
funciones
que
manejen
esos
tipos
de
datos
definidos
por
el
usuario,
lo
que
puede
aumentar
y
simplificar
el
diseo
de
programas
ya
que
las
funciones
pueden
estar
asociadas
a
un
tipo
de
dato
en
especial.
En
el
siguiente
ejemplo
se
muestra
como
podemos
construir
un
programa
a
partir
de
estructuras,
y
despus
desarrollar
las
funciones
necesarias
para
poder
interactuar
con
dichas
estructuras.
Construimos
una
estructura
llamada
Horaria
que
define
3
valores
hora,
minuto,
segunda.
El
programa
principal
genera
una
variable
de
tipo
estructura
Horario
a
la
cual
se
le
asignan
valores
iniciales
y
que
posteriormente
es
enviada
por
referencia
(&)
a
las
funciones
Militar()
y
Standar(),
que
se
encargan
de
mostrar
la
hora
en
formato
universal
y
estndar.
#include
<iostream>
using
namespace
std;
/*
tipo
Horario
definido
por
el
usuario
mediante
una
estructura
simple
*/
struct
Horario
{
int
hora,
minuto,
segundo;
};
/*
declaracin
de
prototipos
*/
void
Militar
(
Horario
&
);
//
reciben
una
referencia
por
alias
void
Standar
(
Horario
&
);
int
main(){
Horario
Mexico;
//
variable
tipo
Horario
Mexico.hora
=
14;
//
asignan
valores
a
los
miembros
Mexico.minuto
=
57;
Mexico.segundo
=
0;
cout
<<
"La
hora
en
Mexico
es
";
Cada
vez
que
se
construye
un
objeto
de
una
clase,
se
crea
una
instancia
de
esa
clase.
En
general,
los
trminos
objetos
e
instancias
de
una
clase
se
pueden
utilizar
indistintamente.
Una
clase
es
una
coleccin
de
objetos
similares
(generalizacin)
y
un
objeto
es
una
instancia
o
ejemplar
de
una
definicin
de
una
clase.
Las
clases,
en
lenguaje
C++,
son
el
tipo
de
dato
abstracto
que
nos
permite
realizar
el
proceso
de
abstraccin
de
manera
eficiente
ya
que
nos
abocamos
al
diseo
especifico
de
la
clase
esbozando
sus
caractersticas
mas
importantes
describiendo
nicamente
los
prototipos
de
las
funciones
miembro
(declaracin)
y
posteriormente
desarrollamos
la
implementacin
de
cada
una
de
las
funciones
miembro
para
esa
clase
en
especial
(definicin).
Para
el
diseo
de
clases
en
C++
emplearemos
la
palabra
clave
class
y
especificamos
el
nombre
de
la
clase,
posteriormente
declaramos
los
miembros
y
los
mtodos
(funciones
miembro)
de
la
clase.
Adicionalmente
por
el
momento
emplearemos
dos
etiquetas
que
nos
indicaran
el
tipo
de
acceso
a
los
miembros
de
la
clase,
public
y
private.
Los
datos
miembro
public
(pblicos)
sern
vistos
desde
cualquier
punto
fuera
de
la
clase
y
los
datos
private
(privados)
estarn
nicamente
disponibles
por
los
mtodos
pertenecientes
a
la
clase.
A
continuacin
se
presenta
la
estructura
gramatical
de
la
declaracin
e
implementacin
de
clases
en
C++:
//
declaracin
del
dato
abstracto
class
<Nombre-clase>
{
//
declaracin
de
variables
miembro
o
propiedades
[private:|public:|protected:]
tipo
<lista-de-variables>;
//
declaracin
de
funciones
miembro
o
mtodos
[private:|public:|protected:]
<tipo-de-regreso>
<funcin-miembro>([lista-argumentos]);
};
//
implementacin
de
la
funcin
<tipo-de-regreso>
<Nombre-clase>::<funcin-miembro>([lista-argumentos])
{
//
declaracin
de
variables
locales
//
cuerpo
de
la
funcin
}
Retomaremos
el
ejemplo
visto
en
la
seccin
anterior
y
lo
replantearemos
para
su
solucin
mediante
clases.
Primeramente
disearemos
la
estructura
indispensable
para
su
funcionamiento
(declaracin),
empleando
la
tcnica
de
abstraccin,
y
nos
ocuparemos
de
colocar
los
elementos
indispensables
para
su
funcionamiento.
En
los
lenguajes
orientados
a
objetos
como
C++
existe
la
posibilidad
de
que
una
misma
funcin
pueda
ser
declarada
varias
veces,
con
la
nica
restriccin
de
que
el
nmero
de
argumentos
puede
variar
desde
ningn
argumento
hasta
n.
A
esta
caracterstica
de
las
funciones
se
le
llama
sobrecarga
de
funciones,
y
es
muy
til
cuando
se
necesita
inicializar
un
objeto
de
varias
maneras.
Veamos
un
ejemplo
nuevamente
con
la
clase
Horario
que
hemos
empleado:
class
Horario
{
private:
int
hora,
minuto,
segundo;
public:
Horario();
//
constructor
por
defecto
Horario(int,
int,
int);
//
constructor
general
void
ajuste(int,
int,
int);
void
Militar();
void
Standar();
};
/*
constructor
por
defecto,
sin
argumentos
*/
Horario::Horario()
{
hora
=
minuto
=
segundo
=
0;
}
/*
constructor
general,
con
argumentos
*/
Horario::Horario(int
h,
int
m,
int
s)
{
ajuste(h,m,s);
}
Una
vez
definidas
las
funciones
constructoras,
estamos
en
posibilidad
de
generar
objetos
de
la
clase
Horario.
Ahora,
lo
que
haremos
ser
declarar
un
par
de
objetos
de
ste
tipo
y
emplearemos
dos
modos
diferentes
de
declaracin
para
cada
objeto;
uno
para
un
objeto
llamado
mex
el
cual
no
cuenta
con
argumentos
y
otro
llamado
usa
con
argumentos
de
entrada.
El
objeto
mex
ser
construido
empleando
el
constructor
sin
argumentos,
mientras
que
el
objeto
usa
ser
construido
empleando
el
constructor
con
argumentos.
El
compilador
es
el
encargado
de
manejar
la
sobrecarga,
ya
que
en
base
al
nmero
de
argumentos
del
objeto,
el
compilador
determinar
a
que
funcin
le
corresponde
encargarse
de
la
construccin
del
objeto.
int
main(
void
)
{
Horario
mex,
usa(13,30,0);
cout
<<
Horario
en
Mxico
;
mex.Standar();
//
00:00:00
AM
cout
<<
Horario
en
USA
;
usa.Standar();
//
01:30:00
PM
system(pause);
return
0;
}
Tambin
es
posible
tener
constructores
que
tengan
valores
predeterminados,
y
as
podemos
crear
un
solo
constructor
que
permita
recibir
ninguno
o
varios
argumentos.
Cada
argumento
que
ingrese
ser
asignado
de
izquierda
a
derecha
en
los
argumentos
de
la
implementacin
del
constructor
de
la
clase,
los
valores
que
no
sean
ingresados
sern
asignados
segn
el
valor
de
la
declaracin.
class
Horario
{
private:
int
hora,
minuto,
segundo;
public:
Horario(int
=
0,
int
=
0,
int
=
0);
//
constructor
predeterminado
void
ajuste(int,
int,
int);
void
Militar();
void
Standar();
};
Horario::Horario(int
h,
int
m,
int
s)
{
//
constructor
predeterminado
ajuste(h,m,s);
}
De
esta
forma
podremos
declarar
objetos
con
el
numero
de
argumentos
que
se
requiera
para
el
constructor,
por
ejemplo
podramos
decidir
que
unos
objetos
inicialicen
sin
argumentos
y
otros
con
uno,
dos
o
tres
argumentos
para
el
caso
de
la
clase
Horario.
int
main(
void
)
{
Horario
mex,
usa(13),
can(15,1,1);
cout
<<
Horario
en
Mxico
;
mex.Standar();
//00:00:00
AM
cout
<<
Horario
en
USA
;
usa.Standar();
//01:00:00
PM
cout
<<
Horario
en
Canada
;
can.Standar();
//03:01:01
PM
system(pause);
return
0;
}
Adems
de
los
constructores
antes
mencionados
existe
un
tipo
de
constructor
llamado
constructor
de
copia,
que
consiste
en
crear
un
nuevo
objeto
a
partir
de
otro
objeto
ya
existente.
Para
ello
sera
necesario
asignar
todas
las
variables
miembro
del
objeto
existente
al
objeto
de
recin
construccin.
class
Horario
{
private:
int
hora,
minuto,
segundo;
public:
Horario(int
=
0,
int
=
0,
int
=
0);
Horario(
const
Horario
&
);
//
constructor
de
copia
void
ajuste(int,
int,
int);
void
Militar();
void
Standar();
};
Horario::Horario(
const
Horario
&x
)
{
//
constructor
de
copia
hora
=
x.hora;
//
asigna
los
valores
x
al
propietario
de
la
llamada
minuto
=
x.minuto;
segundo
=
x.segundo;
}
Los
constructores
de
copia
son
muy
tiles
cuando
necesitamos
construir
una
replica
exacta
de
un
objeto
ya
definido
previamente,
por
lo
que
su
construccin
depende
de
un
objeto
como
argumento.
int
main(
void
)
{
Horario
mex(13,30),
usa(
mex
);
//
usa
se
construye
a
partir
de
mex
cout
<<
Horario
en
Mxico
;
mex.Standar();//
01:30:00
PM
cout
<<
Horario
en
USA
;
usa.Standar();//
01:30:00
PM
cin.get();
return
0;
}
Como
ya
hemos
visto,
las
formas
de
disear
los
constructores
varia
segn
las
necesidades
y
creatividad
del
programador.
Una
buena
abstraccin
del
problema
y
un
eficiente
diseo
de
las
funciones
miembro
pueden
resultar
en
el
desarrollo
de
una
clase
eficiente,
funcional
y
optima,
que
cubra
las
necesidades
para
las
que
fue
desarrollada.
Ejemplo:
A
continuacin
veremos
una
clase
llamada
Vector,
e
implementaremos
un
par
de
constructores
(predeterminado
y
de
copia),
adems
veremos
la
manera
en
como
puede
ser
implementado
el
mtodo
destructor
que
como
se
menciono
anteriormente,
es
la
contraparte
de
los
constructores,
y
tienen
el
propsito
de
liberar
el
espacio
dinmico.
Los
destructores
son
ejecutados
una
vez
que
se
ha
perdido
el
alcance
de
un
objeto,
es
decir
son
la
ultima
funcin
que
se
ejecutar.
#include
<iostream>
using
namespace
std;
class
Vector
{
private:
int
nelem;
//
tamao
del
vector
int
*
lista;
//
puntero
para
el
vector
dinmico
public:
Vector(
int
=
1
);
//
inicializa
con
1
elemento
Vector(
const
Vector
&
);
//
constructor
de
copia
~Vector();
//
destructor
void
capturar();
//
captura
los
elementos
del
vector
void
mostrar();
void
ordenar();
void
suma(
const
Vector
&,
const
Vector
&
);
//
suma
de
vectores
};
/*
constructor
predeterminado
*/
Vector::Vector(
int
x
)
{
nelem
=
x;
//
asignamos
a
n
el
numero
de
elementos
lista
=
new
int
[
nelem
];
//
construimos
el
vector
dinmico
for(
int
i
=
0;
i
<
nelem;
i++
)
llamada
por
lo
que
sus
propiedades
no
necesariamente
deben
ser
referenciadas,
pero
es
posible
hacerlo,
empleando
el
puntero
this.
De
manera
que
el
puntero
this
es
la
direccin
de
un
objeto
pasado
como
parmetro
implcito
a
la
funcin
miembro.
As
que
es
posible
referirnos
a
los
miembros
del
objeto
propietario
de
la
llamada
con
el
puntero
this
prescindiendo
de
l,
mas
adelante
veremos
a
detalle
la
utilidad
del
puntero
this.
Prestemos
ahora
atencin
a
la
operacin
de
suma
realizada
dentro
del
procedimiento
y
observe
que
cada
elemento
del
vector
A
es
sumado
con
cada
elemento
del
vector
B
y
el
resultado
es
depositado
en
la
lista
de
valores
del
propietario
de
la
llamada.
De
esta
manera
podramos
crear
un
objeto
de
tipo
Vector
para
manipular
sus
datos
y
ms
adelante
en
caso
de
necesitar
una
copia
exacta
del
objeto
lo
haramos
a
travs
de
su
constructor
de
copia,
inclusive
es
posible
realizar
una
suma
de
ambos
vectores
y
depositarlo
en
un
tercero
llamado
C.
Al
finalizar
el
programa
el
mtodo
destructor
se
encargara
automticamente
de
liberar
el
espacio
asignado
a
cada
objeto
de
tipo
Vector.
int
main(
void
)
{
Vector
R(10),
C;
R.capturar();
R.mostrar();
Vector
S(
R
);
//
crea
una
copia
exacta
de
R
en
S
C.suma(
R
,
S
);
//
realiza
una
suma
de
R
y
S
en
C
C.mostrar();
system(pause);
return
0;
}
Nota:
Se
deja
como
ejercicio
para
el
lector
implementar
los
mtodos
mostrar
(que
imprime
los
elementos
del
vector)
y
ordenar
(que
ordena
los
elementos
bajo
el
mtodo
de
seleccin).
Puntero this
El
puntero
this
es
un
atributo
especial
del
objeto,
el
cual
guarda
la
direccin
de
memoria
del
objeto
para
poder
referirse
a
si
mismo
en
cualquier
momento,
esto
es
usado
por
la
manera
de
distribuir
los
objetos
en
memoria:
los
atributos
de
cada
objeto
son
independientes
de
los
de
otro
objeto,
pero
los
mtodos
son
compartidos
por
todos
los
objetos
declarados
del
mismo
tipo
de
clase,
as
cuando
se
llama
un
mtodo
del
objeto,
implcitamente
se
manda
como
parmetro
el
puntero
this
de
ese
objeto
para
que
el
mtodo
sepa
a
que
atributos
referirse
a
la
hora
de
procesarlos.
En
C++
se
define
this
dentro
de
un
objeto
como
un
puntero
al
objeto
en
que
est
contenido.
Se
declara
implcitamente
como:
class_name
*this;
El
puntero
this
se
inicializa
para
apuntar
al
objeto
para
el
cual
se
llama
a
la
funcin
miembro.
Este
puntero
es
muy
til
cuando
se
trabaja
con
punteros
y
especialmente
en
listas
enlazadas,
cuando
se
necesita
referenciar
un
puntero
al
objeto
que
se
est
insertando
en
la
lista.
Programacin I | 2016
La
palabra
this
est
disponible
para
este
propsito
y
puede
ser
utilizada
en
cualquier
objeto.
Realmente
la
forma
apropiada
de
referenciar
a
cualquier
variable
en
una
lista
es
a
travs
del
uso
del
puntero
predefinido
this,
escribiendo
this
->
nombre
del
miembro,
pero
el
compilador
supone
que
se
est
usando,
y
podemos
omitir
el
puntero.
Tambin
hay
que
tomar
en
cuenta
que:
El
tipo
de
este
apuntador
this
depende
del
tipo
del
objeto
al
cual
apunta
y
que
no
puede
ser
declarado
explcitamente,
es
decir,
es
declarado
y
definido
por
el
compilador.
Un
uso
del
apuntador
this
es
impedir
que
un
objeto
sea
asignado
a
s
mismo.
Es
una
variable
local,
es
decir,
que
no
puede
ser
usado
explcitamente
fuera
de
la
clase.
Cualquier
miembro
de
la
clase
puede
hacer
referencia
a
cualquiera
de
los
otros
elementos
miembro
de
la
misma.
Las
funciones
miembro
de
una
clase
tienen
acceso
no
restringido
a
cualquiera
de
los
datos
miembro
de
esa
clase.
El
acceso
a
los
datos
y
funciones
miembro
de
una
clase
fuera
de
ella
esta
restringido
por
los
identificadores
de
acceso
que
se
utilizan
para
controlar
la
visibilidad
de
los
miembros
de
una
clase
fuera
del
mbito
de
la
misma.
De
esta
forma
los
miembros
de
una
clase
pueden
ser
pblicos,
privados
o
protegidos.
Las
palabras
reservadas
(etiquetas)
public,
private
y
protected
se
utilizan
para
controlar
el
modo
de
acceso
a
miembros
de
la
clase.
Dentro
de
una
declaracin
de
clase,
cada
una
de
estas
etiquetas
de
acceso
se
puede
utilizar
para
preceder
a
una
o
ms
declaraciones
de
los
miembros
de
una
clase:
pblico:
los
miembros
pblicos
son
accesibles
desde
cualquier
parte
del
programa.
privado:
los
miembros
privados
slo
pueden
ser
utilizados
por
las
funciones
miembro
de
la
clase
y
las
funciones
amigas
de
la
clase.
protegido:
los
miembros
protegidos
significan
que
slo
se
puede
acceder
a
ellos
por
funciones
miembro
dentro
de
la
misma
clase
y
por
funciones
miembro
de
clases
derivadas
de
esta
clase.
Los
objetos
son
instancias
de
una
clase
y
se
emplean
como
cualquier
variable.
La
principal
diferencia
es
que
pueden
llamar
a
cualquier
funcin
que
pertenezca
a
la
clase.
Durante
la
ejecucin
del
programa,
los
objetos
interactan
pasndose
mensajes
y
respuestas.
Es
fundamental
darse
cuenta
de
que
un
objeto
no
necesita
conocer
el
funcionamiento
interno
de
los
dems
objetos
para
poder
interactuar
con
ellos.
Podemos
crear
en
un
programa
tantas
instancias
de
una
clase
(objetos)
como
sean
necesarios.
Programacin I | 2016
Clases y estructuras
Como
recordara
las
estructuras
son
tipos
de
datos
definidos
por
el
usuario
y
pueden
ser
definidas
y
empleadas
en
cualquier
programa
estructurado.
Las
estructuras
tambin
pueden
formar
parte
de
los
elementos
de
una
clase
y
declarar
variables
de
ese
tipo
(estructura).
Las
reglas
de
acceso
a
miembros
de
una
variable
tipo
estructura
son
exactamente
las
mismas
que
en
la
programacin
estructurada
en
C.
A
continuacin
veremos
un
ejemplo
de
una
clase
que
emplea
estructuras
y
a
su
vez
declararemos
un
vector
dinmico
de
tipo
estructura
que
manipular
los
datos
contenidos
en
el
arreglo.
Los
objetos
Histogram
podrn
capturar
datos
relativos
al
nombre
de
una
ciudad
y
el
numero
de
robos
ocurridos
en
ella,
posteriormente
mostrara
los
datos
en
forma
de
tabular
y
el
nmero
de
robos
para
cada
ciudad
ser
expresado
adicionalmente
con
un
histograma.
Desarrollaremos
los
siguientes
mtodos:
Histogram(
int
):
mtodo
constructor
que
recibe
como
parmetro
el
numero
de
casillas
que
se
habilitaran
para
los
datos
del
vector
dinmico.
El
constructor
se
encargara
de
realizar
el
ciclo
para
definir
el
tamao
del
vector
y
asignar
valores
iniciales
a
cada
componente
del
vector.
captura(
):
mtodo
encargado
de
capturar
los
datos
entidad
y
frecuencia
de
robos.
histogram(
):
mtodo
encargado
de
mostrar
los
datos
del
vector
y
el
histograma
relativo
a
la
frecuencia
de
robos
en
cada
entidad.
Finalmente
para
este
problema
ser
deseable
insertar
un
mtodo
destructor
que
se
encargue
de
liberar
el
espacio
del
vector
dinmico
creado
por
el
constructor.
Los
mtodos
destructores
tiene
el
mismo
nombre
que
los
constructores,
con
la
diferencia
de
que
se
antepone
el
carcter
~
(tilde)
al
nombre
del
destructor
y
no
se
le
asignan
argumentos.
A
continuacin
veremos
la
manera
en
como
declararemos
la
clase
Histogram
y
elaboraremos
la
implementacin
de
cada
uno
de
los
mtodos
miembros
que
se
estarn
involucrados
en
la
clase
y
as
podremos
asegurar
el
buen
funcionamiento
de
la
misma:
#include
<iostream>
using
namespace
std;
#include
<string.h>
class
Histogram
/*
declaracin
de
la
clase
Histogram
*/
{
private:
struct
datos
{
char
entidad[5];
int
frecuencia;
};
Programacin I | 2016
datos
*vector;
int
num;
//
conserva
el
numero
de
elementos
del
vector
public:
Histogram(
int
);
~Histogram();
void
captura();
void
histogram();
};
Histogram::Histogram(
int
n
)
{
/*
implementacin
de
la
clase
*/
num
=
n;
vector
=
new
datos
[n];
for
(int
i=0;
i<num;
i++)
{
strcpy(vector[i].entidad,
"");
vector[i].frecuencia
=
0;
}
}
Histogram::~Histogram()
{
delete
[]
vector;
}
void
Histogram::captura()
{
for(
int
i
=
0;
i
<
num;
i++
)
{
cout
<<
"Ciudad
"
<<(i+1)<<
"
->
";
cin.ignore();
cin.get(vector[i].entidad,'\n');
cout
<<
"Robos
->
";
cin
>>
vector[i].frecuencia;
}
}
void
Histogram::histogram()
{
cout
<<"Num\t"<<"Ciudad\t"<<"Robos\t"<<"Histograma"<<endl;
for(
int
i
=
0;
i
<
num;
i++
)
{
cout
<<
(i+1)<<'\t'<<vector[i].entidad<<'\t'
<<vector[i].frecuencia<<'\t';
for(int
j=0;
j<vector[i].frecuencia;
j++)
cout
<<
'*';
cout
<<
endl;
}
}
Finalmente
emplearemos
la
clase,
construyendo
un
objeto
Histogram
que
recibir
una
cantidad
especifica
de
elementos
para
el
vector.
Posteriormente
empleamos
los
mtodos
captura(
)
y
histogram(
),
para
interactuar
con
el
objeto.
Cuando
se
alcance
el
final
de
la
funcin
main,
el
destructor
entrara
en
operacin
y
liberara
el
espacio
dinmico
asignado
por
el
constructor.
Programacin I | 2016
int
main()
{
int
num;
cout
<<
"cuantos
datos
";
cin
>>
num;
Histogram
vector(num);
vector.captura();
vector.histogram();
cin.ignore();
system(pause);
return
0;
}
Observe
que
la
construccin
de
la
clase
resulta
un
poco
mas
compleja
pero
a
la
larga
resulta
mas
intuitiva
ya
que
lo
que
se
construye
dentro
de
la
clase
es
un
vector
dinmico
de
tipo
estructura
que
posteriormente
es
manipulado
de
una
manera
mas
tradicional.
Programacin I | 2016
#include
<iostream>
using
namespace
std;
#include
<string.h>
class
Histogram
{
private:
class
Datos
{
public:
char
entidad[5];
int
frecuencia;
Datos(){
//
constructor
de
Datos
strcpy(entidad,
"");
//
podemos
implementar
la
funcin
en
frecuencia
=
0;
//
la
declaracin
si
no
excede
las
6
lneas
}
};
Datos
*vector;
//
puntero
a
un
objeto
de
tipo
Datos
int
num;
public:
Histogram(
int
)
{
//
constructor
Histograma
~Histogram(){
delete
[]
vector;
}
void
captura();
void
histogram();
};
Histogram::Histogram(int
n)
{
//
constructor
Histogram
num
=
n;
vector
=
new
Datos
[n];
//
crea
un
arreglo
dinmico
de
Datos
}
/*
el
resto
de
las
funciones
son
idnticas
a
la
clase
previa
(1.6)
*/
Observe
que
el
constructor
de
Histogram
nicamente
define
el
vector
dinmico
indicando
el
tipo
y
la
dimensin,
de
manera
que
automticamente
ser
llamado
el
constructor
de
Datos
para
cada
casilla
del
arreglo
de
objetos
llamado
vector.
Este
fenmeno
ocurre
solamente
en
C++,
pues
se
trata
de
objetos
simples
y
no
referencias
como
en
el
caso
de
Java.
A
continuacin
observamos
que
el
empleo
de
la
clase
es
muy
similar
al
ejemplo
visto
con
las
estructuras.
int
main()
{
int
num;
cout
<<
"cuantos
datos
";
cin
>>
num;
Histogram
vector(num);
vector.captura();
vector.histogram();
system(pause);
return
0;
}
Programacin I | 2016
Programacin I | 2016
Una
vez
que
el
objeto
ya
no
es
utilizado
o
es
obsoleto
se
elimina
con
el
operador
delete.
Una
de
las
principales
caractersticas/beneficios
de
emplear
objetos
dinmicos
es
el
ahorro
en
espacio
de
memoria,
ya
que
no
contamos
con
un
recolector
de
basura
automtico
que
libere
el
espacio
que
ya
no
se
utiliza
como
en
el
caso
de
Java.
Programacin I | 2016
9.2
Funciones
y
datos
estticos
(
static
)
Cada
objeto
de
una
clase
tiene
sus
propios
datos
miembro.
Aunque
en
ciertos
casos
es
deseable
que
todos
los
objetos
de
una
clase
compartan
una
sola
copia
de
una
variable
en
especial.
Por
esta
razn
se
utilizan
las
variables
de
tipo
static,
que
presentan
informacin
a
nivel
de
clase.
A
continuacin
mostraremos
un
ejemplo
de
su
declaracin,
suponga
que
se
requiere
una
clase
Nave,
que
ser
la
responsable
de
crear
tantos
objetos
tipo
Nave
como
sea
necesario
para
un
juego
de
video.
De
tal
manera
que
ser
necesario
tener
una
variable
que
sea
la
responsable
de
llevar
el
conteo
del
numero
total
de
naves
existentes,
de
tal
manera
que
al
momento
de
que
sean
destruidas
se
decrementa
el
nmero
de
naves
a
ser
visualizadas.
#include
<iostream>
using
namespace
std;
class
Nave
{
int
id;
//
es
privada
por
defecto
(default)
public:
static
int
total;
Nave()
{
total++;
}
~Nave()
{
total--;
}
};
int
Nave::total
=
0;
int
main()
{
Nave
a;
Nave
*b
=
new
Nave;
cout
<<
"
numero
de
naves
"
<<
a.total;
delete
b;
cout
<<
"
numero
de
naves
"
<<
Nave::total;
system(pause);
return
0;
}
An
cuando
los
datos
miembro
static
parezcan
variables
globales,
estos
tienen
alcance
de
clase.
Los
miembros
static
pueden
existir
incluso
si
no
se
tiene
ningn
objeto
de
la
clase,
el
acceso
a
estos
miembros
puede
ser
a
travs
del
operador
de
alcance
de
miembros
::.
Tambin
es
posible
crear
funciones
static,
slo
que
estas
funciones
nicamente
podrn
alcanzar
miembros
del
mismo
tipo.
Programacin I | 2016
#include
<iostream>
using
namespace
std;
class
Nave
{
int
id;
//
es
privada
por
defecto
(default)
public:
static
int
total;
Nave()
{
total++;
}
~Nave()
{
total--;
}
inline
static
int
cuenta()
{
return
total;
}
};
int
Nave::total
=
0;
int
main()
{
Nave
a;
Nave
*b
=
new
Nave;
cout
<<
"
numero
de
naves
"
<<
a.cuenta();
delete
b;
cout
<<
"
numero
de
naves
"
<<
Nave::cuenta();
system(pause);
return
0;
}
9.3
Funciones
y
objetos
constantes
(
const
)
Algunos
objetos
o
variables
quizs
no
requieren
modificaciones,
para
estos
casos
se
emplea
el
modificador
const,
que
especfica
que
un
objeto
o
variable
no
puede
ser
modificado.
Un
caso
tpico
en
programacin
seria
el
uso
de
una
variable
const
como
PI,
cuyo
valor
siempre
debe
ser
constante
y
nunca
modificado:
const
double
PI
=
3.141592;
Este
tipo
de
variables
pueden
ser
declaradas
de
manera
global
o
a
nivel
de
funcin,
segn
se
requiera
y
solo
pueden
ser
inicializadas.
Tambin
es
posible
crear
objetos
constantes,
de
la
misma
manera
que
las
variables
const,
debern
ser
inicializados
y
sus
datos
miembro
no
podrn
ser
modificados.
El
nico
inconveniente
es
que
los
compiladores
de
C++
no
permiten
las
llamadas
de
funciones
miembro
a
objetos
const,
a
menos
que
las
funciones
miembro
por
si
mismas
tambin
sean
declaradas
const
(las
funciones
miembro
const
no
pueden
modificar
al
objeto).
Veamos
nuevamente
un
ejemplo
con
la
clase
Horario,
modificando
nicamente
las
funciones
que
regresan
valor
(
Hora(),
Minuto(),
Segundo()
).
Programacin I | 2016
#include
<iostream>
using
namespace
std;
class
Horario
{
private:
int
hora,
minuto,
segundo;
public:
Horario(
int
=
0,
int
=
0,
int
=
0);
//
constructor
predeterminado
void
ajuste(int,
int,
int);
//
permite
ajuste
de
valores
inline
void
Hora(int
h)
//
asigna
una
nueva
hora
{
hora
=
(h
>=
0
&&
h
<
24)
?
h
:
0;
}
inline
void
Minuto(int
m)
//
asigna
un
nuevo
minuto
{
minuto
=
(m
>=
0
&&
m
<
60)
?
m
:
0;
}
inline
void
Segundo(int
s)
//
asigna
un
nuevo
segundo
{
segundo
=
(s
>=
0
&&
s
<
60)
?
s
:
0;
}
inline
int
Hora()
const
//
regresa
la
hora
{
return
hora;
}
inline
int
Minuto()
const
//
regresa
los
minutos
{
return
minuto;
}
inline
int
Segundo()
const
//
regresan
los
segundos
{
return
segundo;
}
void
Militar()
const;
//
despliega
en
formato
HHMM
void
Standar();
//
despliega
en
formato
HH:MM:SS
AM/PM
};
La
implementacin
del
resto
de
las
funciones
seria
de
la
siguiente
manera,
observe
como
la
funcin
Militar(
)
se
declaro
cosnt
y
se
implementa
de
la
misma
manera:
Horario::Horario(int
hr,
int
min,
int
seg)
{
ajuste(hr,
min,
seg);
}
void
Horario::ajuste(int
h,
int
m,
int
s)
{
Hora(h);
Minuto(m);
Segundo(s);
}
void
Horario::Militar()
const
{
cout
<<
(hora
<
10
?
"0":"")
<<
hora
<<
(minuto
<
10
?
"0":"")
<<
minuto
<<
"\n";
}
void
Horario::Standar(){
cout
<<
(
(
hora
==
0
||
hora
==
12
)
?
12
:
hora
%
12
)
<<
":"
<<
(
minuto
<
10
?
"0":""
)
<<
minuto
<<
":"
<<
(segundo
<
10
?
"0":""
)
<<
segundo
<<
(
hora
<
12
?
"
AM"
:
"
PM");
return;
}
Programacin I | 2016
Ahora
usaremos
la
clase
Horario
en
un
programa
generando
un
par
de
objeto,
ahora
y
medioDia;
observe
el
comportamiento
que
presentan
los
objetos
de
tipo
const
al
emplear
mtodos
normales.
int
main()
{
Horario
ahora(6);
const
Horario
medioDia(12);
cout
<<
"horario
actual
";
ahora.Militar();
cout
<<
"\n";
/*
no
se
puede
modificar
un
objeto
const
aun
cuando
sus
funciones
miembro
no
sean
const
*/
medioDia.Hora(16);
//
error
no
accesible
cout
<<
"ahora.Hora
"
<<
ahora.Hora()
<<
"\n";
cout
<<
"medioDia.minuto
"
<<
medioDia.Minuto()
<<
"\n";
/*
mismo
caso
*/
medioDia.Standar();
//
error
no
accesible
ahora.Standar();
system(pause);
return
0;
}
Los
objetos
const
solo
pueden
ser
disponibles
en
sus
partes
const.
Los
objetos
estndar
pueden
acceder
a
cualquiera
de
los
mtodos,
incluso
a
los
const.
Debido
a
esta
caracterstica
es
ms
comn
no
emplear
funciones
de
tipo
const,
aunque
esto
depender
directamente
del
diseador
de
la
clase.
9.3
Funciones
y
clases
amigas
(
friend
)
En
ocasiones
es
necesario
tener
una
funcin
miembro
que
no
forme
parte
de
una
clase,
pero
que
permita
manipular
los
datos
privados
de
la
misma,
para
este
caso
se
emplean
las
funciones
amigas.
Una
funcin
amiga
(freind)
de
una
clase
se
define
fuera
del
alcance
de
la
clase,
pero
tiene
derechos
de
acceso
a
los
miembros
privados
de
la
clase.
Una
funcin
o
una
clase
completa
puede
ser
declarada
como
amiga.
A
continuacin
veremos
un
ejemplo
con
una
clase
denominada
Complejo,
que
define
el
comportamiento
de
un
numero
complejo.
Veremos
que
la
funcin
suma
regresa
un
valor
de
tipo
complejo,
as
que
es
necesario
declarar
dicha
funcin
como
amiga
(freind)
de
la
clase
para
que
pueda
manipular
de
manera
independiente
el
contenido
de
los
objetos
de
tipo
complejo.
Programacin I | 2016
#include
<iostream>
using
namespace
std;
class
Complejo
{
private:
double
real,
imag;
friend
Complejo
suma(Complejo,
Complejo);
public:
Complejo(double
r
=
0,
double
i
=
0)
{
real
=
r;
imag
=
i;
}
Complejo(
const
Complejo
&c
)
{
real
=
c.real;
imag
=
c.imag;
}
inline
void
mostrar(){
cout
<<
real
<<
(imag
>
0
?
"
+
":"
-
")<<
imag
<<
"i\n";
}
void
captura();
};
Complejo
suma(Complejo
x,
Complejo
y)
{
double
r
=
x.real
+
y.real;
double
i
=
x.imag
+
y.imag;
return
Complejo(
r
,
i
);
}
void
Complejo::captura()
{
cout
<<
"real,
imaginario
";
cin
>>
this->real;
cin.ignore();
cin
>>
this->imag;
}
Ahora
es
posible
utilizar
la
funcin
suma
para
manipular
los
datos
privados
de
los
objetos
de
tipo
complejo.
int
main(){
Complejo
x(2,5),
y,
z;
cout
<<
"complejo
X:
";
x.mostrar();
cout
<<
endl;
cout
<<
"valores
de
Y:
";
y.captura();
z
=
suma(x,y);
cout
<<
"\n
resultado
en
Z:
";
z.mostrar();
system(pause);
return
0;
}
Programacin I | 2016
Bibliografa
Bjarne
Stroustrup,
"The
C++
Programming
Language",
Addison-Wesley,
second
edition,
1991,
ISBN
0-201-53992-6.
Naba
Barkakati,
Object-Oriented
Programming
in
C++,
Sams,
first
edition,
1992,
ISBN
0-672-
22800-9.
Harvey
Deitel
&
Paul
Deitel,
Cmo
programar
en
C++,
Prentice
Hall,
segunda
edicin,
1999,
ISBN
970-17-0254-9.
Naba
Barkakati,
Turbo
C++
Bible,
Sams,
first
edition,
1992,
ISBN
0-672-22742-8.
WikiPedia
the
free
encyclopedia,
Programming
paradigm
http://en.wikipedia.org/wiki/Programming_paradigm