Guía para Estudiantes: Introducción A La Programación Por Objetos

Introducción a
la EIF 200
programación Fundamentos de Informática
por objetos
Guía para
estudiantes
Master Sonia Mora Rivera

Doctora Mayela Coto Chotto
Master Santiago Caamaño Polini
Lic. Ronald Vargas Brenes
1 Guía estudiantes Fundamentos de Informática Mora, Coto,Caamaño y Vargas

Indice
Indice ............................................................................................................................................... 2
Introducción .................................................................................................................................... 4
Paradigma de la Orientación a objetos .......................................................................................... 6
Objetos ......................................................................................................................................... 8
Definición ................................................................................................................................ 8
Vista ........................................................................................................................................... 10
Estado de un objeto ................................................................................................................... 12
Interfaz de un objeto .................................................................................................................. 12
Abstracción ................................................................................................................................ 17
Clases ............................................................................................................................................ 19
Concepto .................................................................................................................................... 19
Creación ..................................................................................................................................... 21
Zona del nombre .................................................................................................................... 22
Zona de los atributos ............................................................................................................. 22
Zona de los métodos .............................................................................................................. 24
Atributos, campos y variables .................................................................................................. 25
Encapsulamiento ........................................................................................................................ 30
Ejercicios ................................................................................................................................... 33
Métodos ..................................................................................................................................... 39
Implementación ......................................................................................................................... 41
Tipos de datos básicos ........................................................................................................... 41
Sintaxis y semántica .............................................................................................................. 42
Sintaxis para la definición de clases ..................................................................................... 43
Identificadores ....................................................................................................................... 43
Palabras reservadas .............................................................................................................. 45
Campos .................................................................................................................................. 45
Variables................................................................................................................................ 45
Constantes ............................................................................................................................. 47
Comentarios .......................................................................................................................... 48
Bloque de código ................................................................................................................... 48
Bibliotecas ............................................................................................................................. 49
Expresiones y Operadores ..................................................................................................... 49
Operador de asignación .................................................................................................... 51
Prioridad de los operadores .............................................................................................. 53
Métodos ................................................................................................................................. 54
Parámetros de los métodos ............................................................................................... 58
Cuerpo del método ............................................................................................................ 58
Sobrecarga de métodos ..................................................................................................... 59
Constructores .................................................................................................................... 61
Convenciones de código ................................................................................................... 66
Creación de objetos: instancias ............................................................................................ 67
Ejemplos: ............................................................................................................................... 68
1. Clase Temperatura. ................................................................................................. 68
2. Clase Peso ............................................................................................................... 69
3. Clase Triángulo. ...................................................................................................... 70
4. Clase Numero. ......................................................................................................... 73
5. Clase Fecha. ............................................................................................................ 74
Estructuras de control alternativas. ...................................................................................... 76
Estructura de control alternativa simple (if) ..................................................................... 76
Integridad de los objetos ................................................................................................... 80
Estructura de control alternativa múltiple (switch case) .................................................. 85
Caso de estudio: clase Triángulo .......................................................................................... 87
Estructuras de control iterativas ........................................................................................... 88
Estructura de control for ................................................................................................... 88
Estructura de control while ............................................................................................... 89
Estructura de control do-while .......................................................................................... 90
Ejercicios ............................................................................................................................... 92
Clases contenedoras .............................................................................................................. 93
Arreglos unidimensionales ................................................................................................ 93
Búsqueda ......................................................................................................................... 105
Búsqueda binaria............................................................................................................. 106
Ordenamiento .................................................................................................................. 108
Ordenamiento por burbujas ............................................................................................ 108
Ordenamiento por inserción............................................................................................ 110
Ordenamiento por selección............................................................................................ 111
Arreglos bidimensionales ................................................................................................ 113
Ejemplos: ......................................................................................................................... 115
Referencias Bibliográficas ....................................................................................................... 124

Introducción
Querido estudiante al leer este documento encontrará una guía de estudio y apoyo que le
permitirán introducirse en el paradigma de la programación basada en objetos, exclusivamente
creada para el curso EIF 200 Fundamentos de Informática, según el enfoque definido para este
ciclo lectivo. Enfoque que ha sido el producto de la iniciativa de la Asamblea de Académicos de
la Escuela de Informática y de más de cinco años de trabajo en la cátedra del curso.
Este material ha sido desarrollado por los autores como una iniciativa personal, contando
con el aporte de muchos profesores que han pasado por la cátedra dejando huella; con el único fin
de ir consolidando un conjunto de terminología e información básica, estándar para el curso. Sin
embargo no puede considerarse como un documento terminado, más bien solicitamos su
colaboración mediante recomendaciones para mejorarlo y así facilitar el acceso a esta
información de nuevos estudiantes que se incorporen al curso cada año.
Se ha planteado como una guía de estudio para el estudiante; es por esta razón que
encontrará una lista de definiciones de distintos autores con distintos estilos de decir las cosas,
para que usted pueda formarse un criterio más amplio, además encontrará pequeñas listas de
ejemplos, ejercicios y una que otra estrategia para su propio aprendizaje.
Lo más importante en este curso es que el estudiante pueda conocer la importancia que
tiene la conceptualización del entorno, que pueda “visualizar” los objetos y clases en el
planteamiento de un problema y que finalmente pueda “diseñar” adecuadamente una clase,
identificando sus características y comportamientos, según el uso que vaya a dársele.
Este documento plantea una forma de introducir el paradigma de programación por

objetos, producto de muchos años de cambios y ajustes, por eso creemos que es de vital
importancia que el estudiante cuente con esta guía en su proceso de aprendizaje, pues trata los
temas conforme a la aplicabilidad que tengan y según se vayan acoplando a los intereses del
curso, donde es importante tener claro que el objetivo principal del mismo es la resolución de
problemas, utilizando el paradigma de orientación a objetos como un marco general donde
cimentar la programación, dando las bases necesarias para continuar con los siguientes cursos de
programación.
Esta es la primera versión de una guía para estudiantes, nos comprometemos a seguir en
el proceso de construcción y mejora continua. Todo el material presentado es usado
exclusivamente con fines académicos. Nos ponemos a su disposición para cualquier consulta,
duda o posibilidades de mejora.
Mag. Sonia Mora Rivera

Dra. Mayela Coto Chotto
Mag. Santiago Caamaño
Lic. Ronald Vargas Brenes

Paradigma de la Orientación a objetos
El desarrollo actual tecnológico impone que los informáticos conozcan distintos

paradigmas de programación, en especial el paradigma de la Orientación a Objetos: “todo es
objetos”, todo puede ser modelado mediante objetos de una forma “más natural”.
La Programación Orientada a Objetos (POO o OOP por sus siglas en inglés de Object
Oriented Programming) como paradigma, "es una forma de pensar, una filosofía, de la cual surge
una cultura nueva que incorpora técnicas y metodologías diferentes. Pero estas técnicas y
metodologías, y la cultura misma, provienen del paradigma, no lo hacen.”… (Greiff,1994).
La POO como paradigma es una postura ontológica: el universo computacional está

poblado por objetos, cada uno responsabilizándose por sí mismo, y comunicándose con los demás
por medio de mensajes" (Greiff,1994).
Se debe distinguir que la POO como paradigma (enfoque o manera de visualizar la

realidad) y como metodología (colección de características para la ingeniería de software) no son
la misma cosa. Sin embargo, la publicidad nos confunde asociando la POO más a una
metodología, que al paradigma. De aquí que "el interés en la POO radica más en los mecanismos
que aporta para la construcción de programas que en aprovechar un esquema alterno para el
modelado de procesos computacionales" (Greiff,1994).
La Programación Orientada a Objetos desde el punto de vista computacional "es un

método de implementación en el cuál los programas son organizados como grupos cooperativos
de objetos, cada uno de los cuales representa una instancia de alguna clase, y estas clases, todas
son miembros de una jerarquía de clases unidas vía relaciones de herencia" (Greiff,1994).
 Es un paradigma de programación que se basa en la representación de todo aquello que

nos rodea a través de objetos.
 Nace de la necesidad de modelar el mundo lo más real que se pueda.

 Los objetos poseen características y conductas bien definidas. Pueden ser tan tangibles
como una mesa o tan intangibles como una función numérica.
Según (Booch, 1986) los beneficios del enfoque OO son:
 Primero, el uso del modelo OO nos ayuda a explotar el poder expresivo de todos los
lenguajes de programación basados en objetos y los orientados a objetos, como Smalltalk,
Object Pascal, C++, CLOS, Ada, y recientemente Java.
 Segundo, el uso del modelo OO alienta la reutilización no sólo del software, sino de
diseños completos.
 Tercero, produce sistemas que están construidos en formas intermedias estables y por
ello son más resistentes al cambio en especificaciones y tecnología.
El mismo autor considera que el principal beneficio del Diseño Orientado a Objetos (DOO)
es que da un mecanismo para formalizar el modelo de la realidad.
Se pueden mencionar algunas otras ventajas:

 Desarrollo más rápido y completo.
 Aumenta la calidad en el proceso.
 Más sencillos los mantenimientos.
 Hay naturalidad en la forma de pensar.
 Proximidad de los conceptos de modelado respecto de las entidades del mundo real
• Mejora captura y validación de requisitos.
• Acerca el “espacio del problema” y el “espacio de la solución” .
• Modelado integrado de propiedades estáticas y dinámicas del ámbito del
problema.
 Facilita construcción, mantenimiento y reutilización de código.
 Conceptos comunes de modelado durante el análisis, diseño e implementación.
 Facilita la transición entre distintas fases de la solución al problema.
 Favorece el desarrollo iterativo del sistema.
 Disipa la barrera entre el “qué” y el “cómo”.

Objetos
Para entender el concepto de objeto, usaremos el entorno y el conocimiento mismo que

hemos adquirido desde niños, de ahí que se ofrecen diferentes definiciones:
Definición
1. “...cualquier cosa, real o abstracta, acerca de la cual, almacenamos datos y los

métodos que controlan dichos datos” (Martin, 1994).
2. “Un objeto es un concepto, abstracción o cosa con un significado y límites claros en

el problema en cuestión” (Rumbaugh,2000)
3. “es una conceptualización de algo que puede ser real o abstracto, tangible o
intangible”
4. Un objeto es una representación detallada, concreta y particular de un "algo". Tal

representación determina su identidad, su estado y su comportamiento particular en
un momento dado.
5. Es un concepto o entidad con límites bien definidos y con significado para un

problema dado.
6. “Un objeto es una cosa que podemos percibir por algún sentido y sobre la que se
puede accionar y carece de autonomía de acción. La consideración de algo como
objeto depende del ámbito en el cual se está definiendo al mismo.”. Wikipedia
Luego de estas definiciones, es importante ejercitar el concepto, de ahí que le proponemos

hacer el ejercicio de pensar en objetos que usted conoce, mire a su alrededor, ¿Qué ve? ¿Cuáles
son objetos? ¿Cualés no? Estas preguntas son muy interesantes y podrían ponernos en problemas,
por ejemplo: ¿una nube es un objeto?, pero lo importante es ir identificando para efectos nuestros
los objetos que queremos o debemos “procesar” en un sistema de información.

De esta manera, les facilitamos una lista de posibles objetos en la Tabla 1:
Tabla 1. Lista de objetos reales e imaginarios.

Objetos reales Objetos imaginarios
Silla número
Carro fracción
Lápiz triángulo
Casa número binario
Libro Cuenta bancaria
Zapato Cuenta de correo
Fuente: Elaboración propia
La siguiente definición no es original del paradigma de OO, pero para efecto de ir

construyendo un concepto mental que nos permita introducir el concepto de distintos “tipos” de
objetos, se introduce la siguiente definición:
a. un objeto simple: es un objeto que se puede concebir con sólo atributos simples: por
ejemplo un objeto Vehículo puede estar formado por atributos simples tales como
nombre del dueño, peso, longitud, marca, modelo, entre otros.
b. un objeto complejo: es un objeto que además de objetos simples, está compuesto de
otros objetos, es decir sus atributos son otros objetos. Por ejemplo un objeto Vehículo
(en otra circunstancia) puede estar formado por atributos simples como nombre del
dueño, peso, etc y otros que son objetos, tales como (chasis, llantas, motor, puertas,
ventanas, faros, carrocería, entre otros).
A continuación en la Tabla 2 algunos ejemplos más, es importante hacer notar que la

especificación de los mismos está sujeta y situada en una realidad, pues esta especificación
depende del uso que se le vaya a dar a cada objeto, por ejemplo el objeto Vehículo puede tener
marca, dueño y modelo para el sistema solicitado por la agencia de venta, pero para el taller de
reparación además de las características simples tiene otros aspectos (objetos) importantes como
motor, puertas, etc.

De esta manera depende del uso que se le vaya a dar si será considerado como un objeto
simple o un objeto complejo.
Tabla 2. Lista de objetos simples y complejos. Elaboración propia
Objetos simples Objetos complejos

Persona (nombre, edad, peso, estatura, Persona (nombre, cédula, sistema linfático,
cedula). sistema digestivo, tronco, extremidades).
Cuenta Bancaria (cédula, nombre de dueño Casa (cochera, cuartos, sala, patio, comedor,
de la cuenta, saldo, número de cuenta). cocina, baño)
Libro (título, autor, número de hojas, Circulo (radio, centro (un punto en R2).
editorial, número de edición, ISBN).
De esta forma cada objeto debe ser visualizado dentro de un contexto para describirlo
adecuadamente y de esta forma empezamos a introducir el tema de vista o entorno,
Vista
Una vista permite establecer los objetos en el entorno y su relación o interacción con los
demás objetos existentes, y los objetos existen en la medida que tienen algún tipo de relación con
otros objetos. Es decir una vista nos permite visualizar los componentes del entorno, de tal
manera que podamos identificar los objetos y las posibles interrelaciones entre ellos.
Una vista nos permite determinar el contexto en el que el objeto se desempeña, lo cual es
muy importante porque permite “definir” o diseñar el objeto.
Cuando se observa a nuestro alrededor se tiene una VISTA de los objetos que están
cerca o lejos. Pero hay que entender que los objetos existen en la medida que tienen algún tipo
de relación con otros objetos.

Es importante recordar que las relaciones entre objetos NO se establecerán en este curso,
sino en el segundo curso de programación: EIF 201 Programación I, esto con el objeto de
centrarse en el objetivo del curso: la resolución de problemas y no el POO mismo.
Veamos un ejemplo: piense en un perro. Usted tiene el concepto claro, pensará en un

perro que le guste, cada persona se hará una imagen distinta del mismo objeto: un Perro. Luego
haga una lista de características que identifiquen al objeto Perro. Luego piense que la aplicación
que se desea realizar tiene que ver con una clínica veterinaria, analice característica por
característica si son necesarias o importantes para la aplicación, es muy probalbe que encuentre
caracteristicas que ustede definió que no se requieren o no son importantes para la aplicación.
Esto muestra lo indispensable que es pensar primero en la vista: en para qué se quiere el
objeto, como se comporta dentro del contexto, para luego poder pensar en que característica se
requiere que tenga el mismo.
Ejemplo: el siguiente es un ejemplo clásico de vista ¿Qué relación podría existir entre
un Ejecutivo (objeto 1) y su celular (objeto 2).?. la relación es que el ejecutivo usa el celular
para establecer una comunicación con otra persona o sino para hacer cálculos matemáticos o
ingresar a Internet…. etc. Por otro lado: ¿Qué relación podría existir entre un caníbal (objeto 1)
y un celular (objeto 2).?. el caníbal usa un celular como si se tratara de un proyectil para cazar a
una presa o para aliñar la cena.
Aunque si bien es cierto, ambos usan el mismo objeto: un celular, el sentido de la relación
es muy diferente, visualizar el uso del objeto es muy importante, para un Ejecutivo hay mucha
diferencia entre un celular y una piedra, no es así para un caníbal.
El ejemplo anterior pretende establecer los atributos y características propias de un objeto

que varían de acuerdo a la relación que existe, dependiendo de la situación y de la visualización
de la realidad que se haga.

Ejemplo: Considere una silla. Una silla (objeto 1) solo tiene sentido en la medida que alguien
(objeto 2) pueda sentarse sobre ella y soportarlo. Esto es que, si no existieran objetos Persona
que se sienten sobre las sillas el objeto Silla pierde sentido.
Estado de un objeto
El estado de un objeto se define como:

“... abarca todas las propiedades (normalmente estáticas) del mismo más los valores actuales
(normalmente dinámicos) de cada una de esas propiedades” (Booch,1996).
Un objeto siempre debe tener un estado que lo caracteriza y que puede cambiar de un
momento a otro. Todo objeto tiene un estado inicial y el estado de un objeto está íntimamente
relacionado con el valor de sus atributos. Por ejemplo, si un objeto Persona tiene como atributos
nombre, dirección, edad y altura, un estado inicial podría ser:
nombre: “Carmen”,
dirección: “Heredia”,
edad: 20,
altura: 1.65
Pero este objeto podría cambiar su estado en otro momento, a

nombre: “Carmen”,
dirección: “San José”,
edad: 21,
altura: 1.65.
Interfaz de un objeto
Existen formas de comunicación entre los objetos, donde se utilizan diversos canales en
esa comunicación, tanto de entrada como de salida, y de tipo visual, auditivo, entre otros.
Los objetos de comunican entre ellos mediante el paso de mensajes:

 “Es una solicitud que se le envía a un objeto para que lleve a cabo una acción, …..”
(Martin, 1994).
 Una solicitud invoca una operación específica.
La interfaz de un objeto viene dada por el conjunto de órdenes a las que puede responder.
Un objeto se comunica con objetos de su misma clase o apariencia, mediante canales de

entrada y canales de salida (audio, imagen, etc), de esta forma existen diferentes mecanismos y
formas de comunicarse entre los objetos.
A continuación se dan algunos ejemplos, que también como muchas otras cosas en este
paradigma, podemos pensar diferente con respecto a ellos, pero la discusión siempre es
enriquecedora.
Tabla 3. Interacción entre objetos del mismo tipo. Elaboración propia
Interacción entre objetos de la Canal entrada Canal salida

misma clase
Humano-humano Oído, visión Cuerpo, boca
Computadora – computadora Modelo OSI (7 capas), Modelo OSI (7 capas),
(red) cableado cableado
Teléfono fijo – teléfono fijo Cable hacia una central Cable hacia una central
(impulsos eléctricos) (impulsos eléctricos)
Animal Ballena – Animal ballena Oído Sonido o canto
Celular – celular ondas Ondas
Dpto Ventas – Dpto Productos Buzón, fax, teléfono, Buzón, fax, teléfono,
pedidos pedidos
Animal Tigre – Animal Gacela Vista, olfato Salir corriendo
Dispositivo Notebook - Cables Cables
Dispositivo Impresora
Bailarín Hombre – Bailarín Mujer Boca, ojos, cuerpo, Movimiento, cuerpo, ojos
oídos, movimiento

Los siguientes ejemplos tratan de hacer lo mismo pero desde la perspectiva de la
comunicación de objetos con objetos que no son de su misma clase, y otros para que usted los
complete.
Tabla 4. Interacción entre objetos de distinto tipo. Elaboración propia.
Objetos que no son Canal entrada Canal salida

de la misma clase
Humano – Humano: vista, oído, tacto. Humano: tacto. Computador:
computador Computador: teclado, pantalla, impresora, parlantes,
mouse etc
Humano - teléfono Humano: sonido, Humano: movimiento, audio,
movimiento, tacto tacto.
teléfono: teclado, teléfono: pantalla, audio,antena,
micrófono, cámara, antena, puertos.
puertos.
Reloj –alarma
Perro – presa
Payaso – auditorio
Nadador – piscina
Chofer – vehículo
Lápiz – papel
Factura – producto
Llanta – aire
Para tener una mejor idea de la conceptualización y la comunicación entre objetos

veamos el siguiente ejemplo: imagine la siguiente situación: un domingo por la tarde está en
casa viendo la televisión, y de repente su madre siente un fuerte dolor de cabeza; como es
natural, lo primero que se hace es tratar de encontrar una caja de aspirinas. Esta situación
probablemente no resulte muy extraña a muchos de nosotros.

Esta misma situación vista en clave de objetos, sería:
 el objeto Hijo ha recibido un mensaje procedente del objeto Madre. El objeto hijo
responde al mensaje o evento ocurrido mediante una acción: buscar aspirinas.
 La madre no tiene que decirle al hijo dónde debe buscar, es responsabilidad del hijo
resolver el problema como considere más oportuno. Al objeto madre le basta con
haber emitido un mensaje.
Siguiendo con la historia: el hijo no encuentra aspirinas en el botiquín y decide acudir a la

farmacia de guardia más cercana para comprar aspirinas. En la farmacia es atendido por una
señorita que le pregunta ¿qué desea?, a lo que el hijo responde: "una caja de aspirinas, por favor".
La farmacéutica desaparece para regresar al poco tiempo con una caja de aspirinas en la mano. El
hijo paga el importe, se despide y vuelve a su casa. Allí le da un comprimido a su madre, la cual
al cabo de un rato comienza a experimentar una notable mejoría hasta la completa desaparición
del dolor de cabeza.
El hijo, como objeto responsable de un cometido, sabe lo que debe hacer hasta conseguir
una aspirina. Para ello entra en relación con un nuevo objeto, la Farmacéutica, quien responde al
mensaje o evento de petición del objeto Hijo con la búsqueda de la aspirina. El objeto
Farmacéutica es ahora el responsable de la búsqueda de la aspirina. El objeto Farmacéutica
lanza un mensaje al objeto Hijo solicitando el pago del importe, y el objeto Hijo responde a tal
evento con la acción de pagar.
Como ve en esta situación los objetos se diferencian de los demás por un conjunto de
características o propiedades, y por un conjunto de acciones que realizan en respuesta a unos
eventos que se originan en otros objetos o en el entorno.
La interfaz de un objeto es la manera en que me comunico con el objeto a través de

mensajes y está íntimamente relacionada al conjunto de métodos que posee un objeto.

A continuación un escenario, donde hay muchos objetos que se comunican entre sí para
lograr resultados, ¿en este caso específico, cuáles son los resultados que nos podrían interesar?
Figura 1. Escenario de un hospital
Fuente: Theme Hospital, Wikipedia
Existen grupos de objetos que se unen para montar un escenario o una situación en
particular. De esta forma podemos decir que hay grupos de objetos que actúan como un todo, o
sea como si fuera un solo paquete, por ejemplo se tiene:
Tabla 5. Listado de grupos de objetos.

Grupos de Objetos
Motor de un vehículo Reloj
Cuerpo humano Tren
Sistema administrativo de un banco Bicicleta
Juego de Sala Tendido-Eléctrico
Jauría Call-Center
Equipo de Sonido Un equipo de fútbol
Plaga Virus

Abstracción
Es el proceso de identificar y representar las características indispensables de un objeto,

dejando las demás de lado, pues no aportan a la solución del problema.
Es la caracterización de un objeto de acuerdo a las propiedades que nos interesen en un

momento dado. Las características escogidas son relativas a la perspectiva del observador.
La abstracción es la forma como yo veo lo que es relevante en una vista. Cada persona
puede ver cosas diferentes y depende de su formación y de la concepción en la manera de ver las
cosas. No todos somos iguales a la hora de abstraer lo más relevante. Cada uno tiene formas
parcializadas de ver las cosas, de ahí la dificultad o belleza de nuestra profesión, debemos captar
la vista (y mejorarla, optimizarla) del usuario (o varios usuarios).
Una abstracción se centra en la vista externa de un objeto, de modo que sirva para
separar el comportamiento esencial de un objeto, de su implementación. Definir una abstracción
significa describir una entidad del mundo real, no importa lo compleja que pueda ser, y a
continuación utilizar esta descripción para su implementación en un programa.
A continuación imágenes clásicas que muestran gráficamente el significado de la

abstracción:
Figura 2. Imagen cásica de abstracción.
Fuente: (Booch, 1996)

Figura 3. Imagen clásica de abstracción.
Fuente: (Booch, 1986)
En los siguientes ejemplos ejercite la habilidad de establecer las características más

relevantes de un objeto dependiendo de su uso o de su comportamiento, debe abstrer lo más
relevante de un objeto de acuerdo al problema o medio en que se debe desenvolver el mismo, se
les dan algunos ejemplos puede irlos mejorando.
Tabla 6. Objetos y sus características.
Objetos Características
Persona (oficina) (nombre, cedula, correo-electrónico, teléfono).
Persona (enfermo) (signos vitales, tratamiento, reposo, observación).
Persona (atleta) (alimentación, fuerza, resistencia, performance.
Persona (novia o novio) (nombre, dirección habitación, sentimientos, plata).
Factura (Pulpería)
Factura (Supermercado)
Vehículo (De carga para Trabajo)
Vehículo (Para exhibición).

Clases
Concepto
Desde lo más simple: un objeto. Un grupo de objetos con características y

comportamientos comunes, se clasifican para tener un grupo de objetos una clase.
Una clase:
 Engloba todas las características de un conjunto particular de objetos.
 Es un conjunto de objetos que tienen una estructura común y un comportamiento común.
Por tanto la clase es una abstracción del concepto objeto. Un objeto es una instancia de
una clase (Booch, 1996).
 Describen un conjunto de objetos que comparten los mismos atributos, operaciones y
relaciones. Es común encontrar muchos objetos en un sistema que esencialmente son
similares a otros salvo en los valores de sus atributos. Por ejemplo: empleados de una
fábrica. Cada uno de esos objetos son miembros de la misma clase Empleado.
 “El origen del concepto de clase viene dándose desde los tipos de datos abstractos en el
año 1966 por parte de los Noruegos Dahl y Nygaard ”. (Joyanes,1996).
 “Se define como una entidad que declara objetos similares”. (Joyanes,1996).
 “Son plantillas para crear objetos de una misma estructura”. (Joyanes,1996).
 Es un modelo de comportamiento de un tipo de objeto que existirá durante la ejecución de
un programa orientado a objetos.
 Es una plantilla o molde que define los atributos y métodos que tendrán los objetos de esa
clase.
 Un objeto es una entidad concreta que existe en el tiempo y el espacio, una clase
representa sólo una abstracción.
Note que el nombre de la clase debe ir en mayúscula y en singular, esto es importante

porque permite ir estableciendo una serie de convenciones en la codificación que facilitan el
entendimiento de los programas y por lo tanto el mantenimiento de los mismos.

Establecer las clases de objetos es vital en el momento que se desea crear objetos dentro
de un sistema de información.
Es importante enfatizar que cada clase deberá tener independencia con respecto a otras
clases, y entender que es altamente probable que las clases estén relacionadas, pero cada una por
sí misma debe tener bajo acoplamiento:
“…grado de interdependencia entre las unidades de software (módulos, funciones,
subrutinas, bibliotecas, etc.) de un sistema informático. El acoplamiento da la idea de lo
dependiente que son las unidades de software entre sí, es decir, el grado en que una
unidad puede funcionar sin recurrir a otras.
Por ejemplo, dos funciones son absolutamente independientes entre sí (es decir, el nivel
más bajo de acoplamiento) cuando una puede hacer su trabajo completamente sin
recurrir a la otra. En este caso se dice que ambas están desacopladas.
El consenso general es que debe haber bajo acoplamiento entre las unidades de software
para lograr una buena programación o un buen diseño. O sea, mientras menos
dependientes sean entre sí las partes que constituyen un sistema informático, mejor será
el resultado. Obviamente es imposible un desacoplamiento total de las unidades.
El bajo acoplamiento permite:
 Mejorar la mantenibilidad de las unidades de software.
 Aumentar la reutilización de las unidades de software.
 Evitar el efecto onda, ya que un defecto en una unidad puede propagarse a otras,
haciendo incluso más difícil de detectar dónde está el problema.
 Minimiza el riesgo de tener que cambiar múltiples unidades de software cuando
se debe alterar una. (Wikipedia)
En la ingeniería del software, un bajo acoplamiento es lo que se busca, es decir entre

menor sea la dependencia entre clases mayor reaprovechamiento se podrá hacer de ella.
La clase es una especie de “molde”, que correctamente establecido puede crear

representaciones de objetos reales o imaginarios (un adminstrador en jefe o una cuenta de banco,
respectivamente) dentro de un sistema informático. De esta forma sin la creación de clases no es
posible la creación de objetos en un sistema informático, por eso la importancia del desarrollo
correcto de una clase.
Ejemplo: Considere a todos los trabajadores de una Clínica. Todos son personas, todos
son objetos Persona que caminan, respiran, comen, trabajan … etc. Todos son personas que en
nuestro mundo informático, pueden “salir” de un molde que puede crear personas. Todos esos
objetos personas pueden ser creadas por la clase Persona. Todo objeto Persona guarda una serie
de características importantes a la hora de ser modelado.
En la Clínica existen doctores, enfermeras, conserjes, camilleros, anestesiólogos,

jardineros, administrativos, choferes, etc. Todos ellos tienen un nombre, una edad, un salario,
una dirección, un puesto, una cédula, un número de asegurado, un peso, un sexo, un tamaño …
etc. Todos estos objetos pueden ser “fabricados” bajo un mismo concepto, que es el concepto
Persona, que tendrá todas esas características: un nombre, una edad, un salario, una dirección, un
puesto, una cédula, un número de asegurado, un peso, un sexo, un tamaño … etc.. Esta clase es
muy común en muchos sistemas informáticos ya que se pueden unir grupos de personas con
características similares, es muy probable que exista la clase Enfermera, la clase Doctor, la clase
Paciente, etc, pero con aquellas características que los diferencian a unos de otros, en este caso se
dice que “heredando” (relación de Herencia) de la clase Persona, sin embargo la relación de
herencia no se tema de este curso.
Creación
La creación de clases se divide por lo general en 3 partes bien definidas:

a. El título de la clase, que se hace al asignarle nombre a las clases, y que como regla
general debe ir en mayúscula y singular.
“...aquella propiedad de un objeto que lo distingue de los demás objetos”. (Booch,1996).
b. La zona de los atributos, que son las características que todo objeto de la clase debe
tener, y que definen su estado.
c. Y por último la zona de los métodos que son las acciones o comportamientos únicos
que los objetos pueden tener cuando son creados.

“...es como actúa y reacciona un objeto, en términos de sus cambios de estado y paso de
mensajes ”. (Booch,1996).
Usando el diagrama de clase de UML (Lenguaje Unificado de Modelado) se definen tres

secciones:
Figura 4. Descripción clase en ULM.
Zona del nombre
Zona de Atributos
Zona de los Métodos
Fuente: elaboración propia
Zona del nombre

La primera sección corresponde al nombre de la clase, en este aspecto es importante
insistir en que el nombre de la clase sea nemónico, es decir refleje o represente muy bien al tipo
de objetos que agrupa, por convención debe escribirse en mayúscula y en singular.
Zona de los atributos

Identificar las características más importantes (abstracción) que puedan tener en común
las objetos es una de las tareas más importantes en el proceso de diseño de sistemas, como se ha
dicho las características más importantes de un objeto van a depender de lo que desea hacer con
ellos. Y esto es muy importante porque dependerá de la vista del objeto, es decir, de cómo se
perciba según los usos que se le quiera dar. Esto de nuevo refuerza los conceptos que queremos
enfatizar. Por ejemplo lo más relevante de una persona: será su nombre, apellido, número de
cédula, dirección, dirección electrónica, estado civil, edad, etc, en un sistema electrónico
electoral.
Para realizar esta tarea se deben conocer muy bien los problemas a resolver, de esta forma
habrá entornos que conocen muy bien y eso facilita la abstracción y otros que no y requieren
buscar ayuda de expertos. Algunos ejemplos son:

Tabla 7. Descripción de objetos.
Objetos (uso) características

Perro (sistema veterinario) nombre, raza, peso, altura, edad, enfermedades,
Perro (sistema de compra-venta) nombre, raza, peso, altura, edad, costo,
Vehículo Color, marca, año, modelo, motor, llantas, …
Triángulo longitud de los lados, el valor de los ángulos internos, el área, y el

perímetro.
Cuerpo Humano Nombre, apellido, pierna derecha, pierna izquierda, cabeza,

tronco, brazo derecho, brazo izquierdo
Ejemplo: Dependiendo del tipo de problema que se tenga que modelar, la clase
Persona puede ser diferente. En un problema (diseño de ropa a la medida) puede interesar
solamente las medidas de la persona: cintura, pecho, cuello, etc. En otro problema nos puede
interesar solamente el número de trabajos diferentes que puede realizar una persona, en otro
problema nos puede solo interesar la capacidad física de resistencia de la persona, en fin, los
atributos de la clase Persona pueden variar de un problema a otro o de una empresa a otra, aunque
sea la misma clase Persona. Todo depende el tipo de problema que se tenga, los atributos pueden
ser muy diferentes aunque las clases se llamen igual.
Es importante que el estudiante entienda que hay objetos complejos que están formados
por otros objetos. Así que no es de extrañar que los atributos de estos objetos sean objetos
también, sin embargo el detalle completo de este tema se verá en el siguiente curso EIF 201
Programación I.
Ejemplo: se puede definir una clase Triángulo en la que sus atributos son objetos, es decir
tendrá 3 atributos que serán a su vez objetos de la clase Punto o la misma clase Triángulo se
podría definir con 3 atributos simples: lado1, lado2, lado3, donde cada lado es un número real, o
se podría definir la clase Triángulo con base y altura, 2 atributos simples, ¿de qué dependerá esta
definición de la clase Triángulo? Como ya se ha dicho: del uso que se le debe dar a la clase, del

contexto de la solución. Esto es diseño e involucra los aspectos básicos que estamos
introduciendo del POO.
Zona de los métodos

En esta parte se le da vida al objeto, al determinar el comportamiento del mismo. En esta
zona se establecen las acciones que el objeto tomará una vez que se le pase el mensaje adecuado
y que un método es una función que responde a una acción determinada del objeto que pertenece
a esa clase.
Por ejemplo si el objeto es un Robot, dicho robot puede tener métodos o comportamientos
muy diversos, tales como: robotVuela(), robotCome(), robotDispara(), robotCorre(),
robotLLora(), etc.
En este momento es vital entender la importancia de adoptar estándares de programación

y enfatizar en que el nombre de los métodos debe ser muy concreto, nemotécnico y explicar
básicamente lo que el método realiza, por ejemplo:
a. Un método que calcula el vuelo rastrero de un robot: vueloRastreroRobot()
b. Un método que cambia un número de pin(): cambiaPin()
Un caso más específico:
Figura 5. Descripción de la clase Bola
Bola
tipo: int radio:real
color: int material: string
rebotar ( )
pintar ( )
desinflar ( )
Este diagrama representa en UML una clase que se utilizará para la creación de objetos
tipo Bola, con tipo, radio, color y materiales como sus características (atributos) y con
comportamientos como son rebotar(), pintar () y desinflar().

En este punto es importante relacionar la idea de atributo y campo. Es por esta razón que
se introducirá el tema, debemos tomar en cuenta que en estos aspectos hay consideraciones del
lenguaje a utilizar: C++.
Atributos, campos y variables
El tema de campos, variables y tipos de datos está íntimamente ligado con los atributos en
principio y después se verá que también está ligado con los métodos. De alguna manera los
atributos definen el estado de un objeto, y para almacenar los atributos de un objeto debemos
definir campos que permitan representarlos adecuadamente.
Cada uno de los campos que corresponda a un atributo está unido a un tipo de dato, al
declararlo se debe escribir el tipo de dato que le corresponde, esto se hace con dos propósitos:
 que la computadora conozca cómo y cuanto espacio de memoria asignar a cada campo
que se declare, esto es que la computadora asigne espacios de memoria adecuados y
 porque es necesario saber en todo momento el tipo de dato que usa cada campo, para
reconocer que se están haciendo las cosas correctamente. Por ejemplo, si tengo que
sumar dos campos, esperaría que se sumaran número con número y no cadenas de
caracteres con elementos de tipo de dato numérico. Este tipo de mezclas podría dar un
error de compilación o peor aún no da error y podríamos no darnos cuenta de lo que en
realidad quedo como resultado de la suma, de ahí la importancia de conocer bien el
problema a resolver.
Sin embargo este tema se detallará más adelante. Figura 6. Clase Persona
Veamos un ejemplo de la clase Persona, con campos

Persona
y un estado bien definido. -nombre: String
+direcion: string
nombre : “ Pedro Misingo Garmendia”; +annoNacimiento
dirección: “Sto Domingo, Heredia”

annoNacimiento: 1999

La clase debe tener unidad y concordancia entre los atributos y sus métodos, logrando en
todo momento que los métodos estén estrictamente relacionados con los atributos.
Ejemplo:
Considere por ejemplo una factura de alguna compra. Para comenzar a modelar este o
cualquier otro objeto siempre se deben hacer dos preguntas.
A) ¿Qué características tiene la factura ? R/ (Atributos)
B) ¿Cuáles son las acciones que lleva a cabo la factura? R/ (Métodos )
A) La factura tiene atributos o cualidades únicas que juntas forman lo que se conoce como
factura. A la hora de extraer sus atributos hay que hacer la pregunta. ¿ Qué es lo que “tiene”
una factura ?. esto permite saber cuáles son sus atributos. La factura tiene:
 Título de la Empresa
 Número de factura
 Cliente
 cédula Jurídica
 línea de detalle del producto (a su vez este tiene características)
a. cantidad solicitada del producto
b. nombre del producto
c. precio costo unitario del producto
 impuesto de venta
 total
B) En este punto se enfatiza en ¿Cuáles son las actividades que se realizan?. y se enlistan las
siguientes, por ejemplo:
a) imprimir Nombre del Cliente

b) imprimir Cédula del Cliente
a) imprimir Linea de Detalle
b) imprimir Cantidad de Producto
c) imprimir Nombre del Producto

d) calcular Sub Total
e) imprimir Sub Total
f) calcular Impuesto de Ventas
g) imprimir Impuesto de Ventas
h) calcular el Total de la factura
i) imprimir el Total
j) imprimir la Factura
Ya en este punto el estudiante tiene las herramientas básicas para visualizar objetos,
clasificarlos en clases y describirlos adecuadamente según el uso que se les vaya a dar.
En este punto es importante tomar en consideración que NO existe forma científica de

obtener las clases de un texto, pero al menos existe un método que facilita ir obteniendo objetos
que “podrían” ser clases, el método trabaja con sustantivos, adjetivos y verbos.
La obtención de clases de un texto es un proceso que se modela, que requiere de mucha

práctica y se va adquiriendo poco a poco. Analicemos el siguiente ejemplo:
Los insectos se caracterizan por tener seis patas y el cuerpo dividido en cabeza, tórax y
abdomen. Los insectos más numerosos son los abejones, en segundo lugar están las
avispas y las hormigas y en el tercer lugar se encuentran las mariposas. Los abejones, las
avispas y las hormigas pertenecen al Orden Himenóptero y las mariposas pertenecen al
Orden Lepidóptero. Dentro del orden lepidóptero, existen dos grandes grupos de
mariposas: las diurnas y las nocturnas. Es importante especificar que cada insecto se
alimenta de distintos tipos de flores
La idea principal de este proceso de análisis debe ser identificar sustantivos, verbos y
adjetivos, pensando que los sustantivos se pueden clasificar como clases, los adjetivos como
atributos y los verbos como comportamientos, de esta manera en el ejemplo anterior vemos los
sustantivos subrayados, los adjetivos en itálica y los verbos en negrilla

Los insectos se caracterizan por tener seis patas y el cuerpo dividido en cabeza, tórax y
abdomen. Los insectos más numerosos son los abejones, en segundo lugar están las
avispas y las hormigas y en el tercer lugar se encuentran las mariposas. Los abejones,
las avispas y las hormigas pertenecen al Orden Himenóptero y las mariposas pertenecen
al Orden Lepidóptero. Dentro del orden lepidóptero, existen dos grandes grupos de
mariposas: las diurnas y las nocturnas. Es importante especificar que cada insecto se
alimenta de distintos tipos de flores
Un primer refinamiento de este proceso puede ser:
Tabla 8. Primer refinamiento en busca de clases

sustantivos adjetivos verbos
insectos seis poseer
patas tres dividir
cuerpo dos ser
partes grandes estar
cabeza diurna existir
tórax nocturna caracterizan
abdomen segundo pertenecer
abejones tercer alimenta
avispas numerosos
hormigas distintos
mariposas
orden
himenóptero
lepidóptero
grupos
Este proceso no es 100% seguro, se requiere de experiencia, sin embargo una variante que
podría mejorar el proceso de identificar finalmente las clases, sería que intente pasar los

sustantivos que parecen características (enfatizado) a la columna de adjetivos, un segundo
refinamiento se vería como:
Tabla 9. Segundo refinamiento

sustantivos adjetivos verbos
insectos seis poseer
abejones tres dividir
avispas dos ser
hormigas grandes estar
mariposas diurna existir
nocturna caracterizan
segundo pertenecer
tercer alimenta
numerosos
patas
cuerpo
partes
cabeza
tórax
orden
himenóptero
lepidóptero
abdomen
grupos
Finalmente esta separación parece quedar mucho más clara con respecto a las posibles
clases que plantea la prosa del ejemplo. Se ven claramente son objetos del texto los insectos, las
mariposas, los abejones, las avispas y las hormigas. Ahora bien si se analiza la columa de los
adjetivos y estos se agrupan como estados de posibles características y se agrupan y etiquetan las
características, por último los verbos son analizados y se considerarn aquellos que no son

considerados en las características, es importante tomar en cuenta que las clase son de insectos, y
se declara una clase Insecto y las demás, por ser insectos, “heredan” todo de la clase Insecto y
sólo se agegan las pequñas diferencias, de esta forma se propone como representación de la
solución, el siguiente diagrama de clases:
Figura 7. Diagrama de clases
Abejon Insectos
-caracteristicas: String
-orden: String
-posicionCantidad: Integer Avispa
-tipoFlor: Integer
+pertenece()
+alimenta()
Mariposa
Hormiga
-grupo: String
Encapsulamiento
Retomando el tema de clasificación y análisis de las clases, se inicia con el tema de

encapsular, como un proceso básico para definir adecuadamente una clase.
 “...el proceso mediante el cual se ocultan todos los detalles de un objeto que no
contribuyen a sus características esenciales” (Booch,86).
 “...el resultado (o acto de ocultar los detalles) de implementación de un objeto respecto de

su usuario ” (Martín,94).
 Es la manera de ocultar los detalles de la representación interna de un objeto presentando

solo la interface para el usuario.
 Es la capacidad que tienen los objetos de construir una cápsula a su alrededor, ocultando
la información que contienen (aquella que es necesaria para su funcionamiento interno,
pero innecesaria para los demás objetos).

Ventajas básicas de la encapsulación:
 Se protegen los datos de accesos indebidos
 El acoplamiento entre las clases se disminuye
 Favorece la modularidad y el mantenimiento
Los niveles de encapsulación están heredados de los niveles de C++,. En este curso se
estarán usando algunos de estos niveles, no todos con el objetivo de nuevo de centrarnos en el
desarrollo y comprensión del tema, es por esta razón que sólo usaremos los siguientes:
(-) Privado: es el más fuerte. Lo que se defina como privado es totalmente invisible
(excepto para clases friends en terminología C++)
(+) Públicos: Los atributos u operaciones públicos son visibles a otras clases (cuando se
trata de atributos se está transgrediendo el principio de encapsulación.)
OBS: en este curso sólo se trabajará con declaración de atributos privados y métodos
públicos, es decir TODOS los atributos son privados y todos los métodos públicos, esto por
considerarlo un asunto de no quedarnos en detalles del POO que no aportan en este momento a
la resolución de problemas. Las consideraciones diferentes a estas son realizadas en el siguiente
curso de programación. De aquí en adelante ya el estudiante diseña las clases en UML usando
esta terminología (+,-).
Ejemplo:
Suponga un punto en un plano cartesiano (x,y). Si se modela ese punto como un objeto,
entonces se puede crear una clase Punto que pueda generar objetos tipo punto. Por ejemplo el
punto (3,2) ya sería una instancia particular de la clase Punto. En general hasta ahora las clases
deben tener tres cosas básicas:
Primero: Un nombre
Segundo: atributos
Tercero: métodos.

En primer aspecto es muy fácil, ya que el nombre o título representativo de la clase punto
podría ser Punto. El segundo, es también evidente, los atributos estarían representados por las
variables “x” y “y”. Y para el tercer aspecto se pueden definir los siguientes métodos:
distancia(v,w), distanciaOrigen(), etc.
A continuación algunos ejercicios que permiten ejercitar las destresas adquiridas, la idea
es que en cada ejercicio se haga el diseño de las clases con la declaración de atributos y métodos:

Ejercicios
Ejercicio No.1. Cierta Universidad desea un programa computacional que le ayude a administrar
las calificaciones finales de sus estudiantes. Para cada estudiante se registra su matrícula, nombre,
apellidos, semestre, la cantidad de materias que cursa y por cada materia se guarda el nombre y
una calificación final. La universidad distingue tres tipos de estudiantes especiales: los candidatos
a graduarse, los condicionados, los de posgrado. En el caso de los primeros se debe guardar su
fecha de graduación y el semestre se debe poner en –1 para identificar que se ha graduado, en el
caso de los segundos se debe guardar cuántas materias está cursando que no corresponden a su
programa académico y el semestre en que estuvo condicionado. En el último caso se guarda su
lugar de trabajo y escuela de origen.
Ejercicio No. 2. Una empresa de multimedios financia diferentes publicaciones en los medios
de comunicación más conocidos: la radio, la televisión y la prensa escrita. Todas las
publicaciones tienen un título y una persona responsable de la dirección de la publicación. Tienen
además un código numérico que las identifica unívocamente. Tanto los programas de radio como
los de la televisión poseen una duración determinada en minutos junto con una hora de inicio, así
como el nombre de la emisora correspondiente. Además, existe un espacio disponible para los
comerciales.
En los programas de radio, este tiempo se mide en minutos al aire (por ejemplo, “La Venganza
será terrible” tiene 23 minutos de propagandas). Para la televisión, se mide en cantidad de
comerciales por tanda (por ejemplo, “Hora Clave” tiene siete propagandas en cada tanda). Cada
programa televisivo puede tener además un número diferente de tandas comerciales. Los
programas de radio necesitan por otra parte un responsable de la musicalización. En cuanto a las
publicaciones por medios escritos, la empresa posee dos tipos: diarios y revistas. Las
publicaciones escritas tienen un editor responsable, una cantidad de páginas, un precio y un año
de publicación. Los diarios que se imprimen son semanales o quincenales, se cobra una pequeña
cantidad de recargo por envíos al interior, y se registra la semana y mes de publicación. Las
revistas poseen el mes de publicación, el número y el título de la nota de tapa.

Ejercicio No. 3. Una biblioteca realiza una serie de préstamos para sus usuarios. Los préstamos
son materiales que pueden ser revistas, libros y libros en reserva, ahora bien, los usuarios de la
biblioteca son estudiantes (becados o regulares) y profesores, en otras palabras la biblioteca
contiene una colección de materiales (Libros (normales y en reserva) y Revistas) y además
almacena a sus usuarios (Estudiantes (regulares y becados) y Profesores). Los usuarios solamente
pueden realizar diez prestamos ya sea de diferente material. Cada usuario tiene un nombre, un
teléfono, una dirección, un estado (inactivo o activo) el cual le permite realizar los préstamos.
Los usuarios estudiantes son de dos tipos regulares y becados, los primeros pueden realizar un
préstamo de los libros solamente por 15 días, en cambio, los estudiantes becados pueden realizar
el préstamo de los libros por un mes, los estudiantes además posee la carrera principal (esto
debido a que un estudiante puede estar inscrito en muchas carrera pero eso no importa, registre
solamente aquella carrera que es principal) en que están empadronados. Los usuarios profesores
a diferencia de los estudiantes es que los primeros pueden realizar el préstamo de los libros por
un año, además poseen la escuela en donde trabajan: La escuela posee un nombre y un número
de teléfono; la carrera posee un nombre y un código. Conforme al material estos tiene un usuario,
tiene un nombre, el nombre de la editorial, un código, una fecha de préstamo y una fecha de
entrega. Las revistas tiene un área de especialización (Ciencia, Matemáticas, etc.) además
realizan la operación de préstamo pero solamente por cuatro días. Los libros poseen el nombre
del autor o los autores, la operación de préstamo, está determinada por el usuario y esta puede
ser (2 semanas, 1 semestre o 1 año inclusive). Los libros de reserva poseen los mismos atributos
que un libro pero la operación de préstamo solamente se permite realizarla por una semana.
Ejercicio No. 4. Una empresa de recambios de piezas de coches necesita una aplicación para
gestionar sus ventas. Esta empresa compra las piezas a distintos proveedores para después
venderlas a los talleres. Cada pieza de recambio tiene un código que la identifica y un único
proveedor que puede proporcionarla. También tiene un precio de compra al proveedor y un
precio de venta a los talleres. Las operaciones que se quieren hacer sobre la pieza son modificar
los dos precios, comprarla y venderla. Los proveedores con los que trabaja la empresa tienen
datos de contacto como teléfono, dirección, nombre del proveedor y CIF. La empresa quiere
poder dar de alta nuevos proveedores y obtener sus datos de contacto. Además, la empresa quiere
mantener la información de los talleres con los que trabaja: su nombre, CIF, teléfono y dirección.
Quiere poder acceder a todos estos datos.

Ejercicio No 5. Una guardería mantiene varios grupos de alumnos. Cada alumno tiene nombre
y apellidos, fecha de nacimiento, hora de entrada y salida de la guardería y el grupo al que
pertenecen. También se informa del nombre, apellidos, DNI, dirección y teléfono del padre y de
la madre. Las operaciones que se quieren hacer sobre cada alumno es obtener el grupo en el que
están, las horas de entrada y salida y el teléfono de su padre y/o madre. Cada alumno está
incluido en un grupo. Estos grupos se forman dependiendo de la edad del niño y de las horas que
está en la guardería. Cada grupo tiene dos profesores. De cada grupo se quiere obtener una lista
de los niños que lo forman y también qué profesores hay. También se mantiene la información
de todos los profesores: nombre, apellidos, identificación, dirección y teléfono. Las operaciones
que se hacen sobre los padres y los profesores son las mismas: obtener sus datos personales.
Ejercicio No 6. Se desea modelar un sistema de gestión de pedidos. Un cliente puede realizar

varios pedidos en un período de tiempo. Cada pedido está formado por varias líneas de pedido,
cada una de las cuales se refiere a un solo producto. Se diferencian dos tipos de clientes, el cliente
personal y el cliente corporativo. La diferencia entre los dos tipos de clientes es que el cliente
personal pagará mediante una tarjeta de crédito, mientras el cliente corporativo tiene un contrato
con la empresa y un límite de crédito. Además, los vendedores de la empresa se encargan de
atender las peticiones de los clientes corporativos, de forma que cada vendedor se hace cargo de
una cartera de clientes corporativos, y a cada cliente corporativo sólo le atiende un vendedor.
Ejercicio No 7. Se trata de construir un sistema que controle una máquina para reciclar latas,
botellas y cajas de botellas. La máquina puede ser utilizada por varias personas a la vez. El
sistema registra cuántos elementos devuelve cada usuario e imprime un recibo con el valor de los
elementos devueltos y el total a pagar al usuario. El sistema también lo utiliza un operador que
desea conocer el número de elementos de cada tipo que se han introducido durante el día.
También debe poder actualizar los valores de los elementos. El sistema llamará al operador
cuando se acabe el papel de los recibos o si detecta algún problema con los elementos
introducidos. Para el uso de la máquina los trabajadores disponen de una tarjeta de identificación
que deben introducir en la máquina antes de su uso. Cuando el usuario introduce la tarjeta la
máquina le pide su contraseña personal. El usuario proporciona su contraseña y la máquina
comprueba los datos. Cuando la validación es correcta, la máquina muestra un mensaje indicando
al usuario que puede comenzar a reciclar elementos. Cada vez que el usuario recicla un elemento

(pulsando el botón de reciclaje) la máquina debe actualizar los contadores locales (hay un
contador local para cada tipo de elemento que introduce el usuario) y los contadores globales
(contador diario de los elementos que de cada tipo que se han introducido durante el día). Cuando
el usuario ha reciclado todos sus elementos acciona una palanca de fin de reciclaje y la máquina
le expide un recibo con los totales de los contadores locales y la cantidad de dinero a pagar al
usuario.
Ejercicio No 8. Todos los hoteles de la cadena independientemente de la ciudad donde se encuentre

tienen tres tipos de habitaciones: sencilla, doble y suite. Para cada habitación de cada hotel la cadena
maneja la siguiente información: número de habitación (nunca se repite en el hotel de una ciudad, pero
puede repetirse en el de otra ciudad), piso, precio, tipo (sencilla, doble, suite), ocupada/disponible. Es
importante aclarar que esta información es exactamente igual todos los días del año (por ejemplo en el
hotel de Monterrey, la habitación 100, es sencilla y tiene precio de $800) y cada hotel solo tiene capacidad
de reservar habitaciones desde el día actual hasta la próxima semana (es decir máximo 7 días). Cada hotel
de cada ciudad tiene mínimo 15 y máximo 20 habitaciones disponibles (de cualquiera de los tres tipos ya
mencionados). En el proceso de reservación se deberá hacer lo siguiente: capturar los datos del huésped si
es la primera vez que se hospeda o pedirle su número de cliente si ya había estado hospedado en otro hotel
de la cadena, preguntar la fecha de llegada y de salida. Dependiendo del tipo de habitación que elija el
proceso de reservación puede variar de acuerdo a esto: para el caso de las suites se permite una capacidad
máxima de 6 personas, por seguridad se deberá pedir el nombre de las personas adicionales al huésped que
realiza la reservación. Para el caso de las habitaciones sencillas se ofrece un plan ejecutivo donde se
venden cupones para desayuno, si el cliente decide comprarlos se le cobrará 10% extra por noche. En el
caso de las habitaciones dobles se pedirá al cliente un número de tarjeta de crédito, en caso de no
proporcionarse el hotel no hace la reservación.
Ejercicio No 9. Una empresa de multimedios financia diferentes publicaciones en los medios de

comunicación más conocidos: la radio, la televisión y la prensa escrita. Todas las publicaciones tienen un
título y una persona responsable de la dirección de la publicación. Tienen además un código numérico que
las identifica unívocamente. Tanto los programas de radio como los de la televisión poseen una duración
determinada en minutos junto con una hora de inicio, así como el nombre de la emisora correspondiente.
Además, existe un espacio disponible para los comerciales. En los programas de radio, este tiempo se
mide en minutos al aire (por ejemplo, “La Venganza será terrible” tiene 23 minutos de propagandas). Para
la televisión, se mide en cantidad de comerciales por tanda (por ejemplo, “Hora Clave” tiene siete
propagandas en cada tanda). Cada programa televisivo puede tener además un número diferente de tandas

comerciales. Los programas de radio necesitan por otra parte un responsable de la musicalización. En
cuanto a las publicaciones por medios escritos, la empresa posee dos tipos: diarios y revistas. Las
publicaciones escritas tienen un editor responsable, una cantidad de páginas, un precio y un año de
publicación. Los diarios que se imprimen son semanales o quincenales, se cobra una pequeña cantidad de
recargo por envíos al interior, y se registra la semana y mes de publicación. Las revistas poseen el mes de
publicación, el número y el título de la nota de tapa.
Ejercicio No 10. Una empresa desea una aplicación para gestionar los salarios de sus empleados.
La empresa paga a sus empleados una cantidad de dinero por diferentes conceptos teniendo cada
uno distintas características. Algunos conceptos están libres de impuestos, mientras que otros
están sujetos a cierta retención por parte de Hacienda. Calcular el sueldo de un empleado no es
más que sumar todos los conceptos netos correspondientes (es decir, restado las retenciones
cuando sea necesario). Los conceptos libres de cargas son debidos a trabajos de diversa índole,
por lo que se le asocia una descripción del trabajo y número de horas invertidas. En cuanto a los
conceptos sujetos a retención, el Ministerio de Hacienda se lleva un porcentaje. Estos conceptos
se clasifican en: el sueldo base, los complementos y el trabajo extra. El sueldo base de cada
empleado tiene un código numérico que lo identifica. Los complementos del sueldo tienen,
además del porcentaje de retención mencionado, un
Impuesto especial que varía para cada tipo de complemento. Los complementos que se tienen en
cuenta son: complemento de destino, complemento de cargo y complemento de antigüedad. Para
el complemento de destino se anotará el destino actual (ciudad y sucursal), para el complemento
de cargo se anota el propio cargo (jefe, directivo o empleado) y, finalmente, asociado al
complemento de antigüedad está el número de años.
El concepto de trabajo extra tiene en cuenta el número de horas extra que ha realizado el
trabajador además de la justificación (fin de proyecto, guardia, otros). Dada la excepcionalidad de
las horas extra, Hacienda aplica un porcentaje especial como impuesto.
Ejercicio No 11. Considere objetos triángulos rectángulos. La relación entre catetos e

hipotenusa se establece mediante el Teorema de Pitágoras: h = a +b2 donde h es la medida de la
2 2
hipotenusa, se requiere calcular la hipotenusa, el seno de un ángulo, que es la relación entre la

longitud del cateto opuesto y la longitud de la hipotenusa: Sen α =opuesto / hipotenusa = a / h y
el coseno de un ángulo es la relación entre la longitud del cateto adyacente y la longitud de la
hipotenusa y cos α =adyacente/hipotenusa=b/h.

Ejercicio No 12. El Banco “InviertaTodoAquí” desea desarrollar un sistema que permita a sus
usuarios utilizar cajeros electrónicos. El banco tiene dos tipos de cuentas: cuentas de ahorro y
cuentas corrientes. Cada cuenta se identifica por un número de cuenta y adicionalmente tiene el
nombre del cliente y el saldo. Sobre una cuenta se pueden realizar las operaciones de consulta de
saldo, transferencias y retiro. Los retiros de las cuentas de ahorro exigen que quede un saldo de al
menos ¢15.000.00. Los retiros de las cuentas corrientes no tienen restricciones. El cajero
automático se conecta con el banco. Cuando el usuario va a realizar una transacción, se identifica
con el número de la cuenta. Si la cuenta existe, se inicia una sesión que le permite consultar
saldo, retirar o transferir. Cuando no vaya a realizar más operaciones, se cierra la sesión.

Métodos
Existen básicamente cuatro tipos de métodos:
1) Métodos Constructor y destructor: permiten la creación y destrucción de instancias de una

clase. Se llamarán igual que la clase. El constructor tiene la función de crear instancias de la
clase, puede haber más de un constructor. El destructor destruye las instancias de la clase, esta
función es muy importante sobre todo cuando la clase hace referencias a objetos o punteros, y
aunque en este curso no veremos punteros se recomienda su uso, aunque sea muy simple a
manera de ir haciendo la costumbre, pues más adelante es vital que el estudiante contemple la
generación y uso de este tipo de métodos. El método constructor tiene sentido en la medida en
que todo objeto debe ser inicializado a través de sus atributos y el método destructor debe ser
parte del concepto de creación de objetos, todo objeto es destruido (su memoria puede volver a la
lista de memoria libre) ya sea que lo hace el compilador (como en el caso de las variables y
objetos estáticos) o que se define un método que libera la memoria ocupada.
2) Métodos modificadores: mutadores y establecedores: estos métodos se encargan de

modificar o mostrar los atributos de una clase. Por razones de convenciones y estándares se
escribirán como set<Atributo>() para modificar el contenido de un atributo y get<Atributo>()
para mostrar el contenido de un atributo, <Atributo> corresponde al identificador del atributo.
En este curso se ha establecido, con fines didácticos, que los atributos se definan como
privados, al declararlos de esta foma la única manera de acceder a ellos es mediante los métodos
set<Atributo>() y get<Atributo>(). SOLO de esta forma los atributos pueden ser accedidos,
además estos son necesarios pues pueden hacer verificaciones muy importantes y útiles en
algunas situaciones, por ejemplo imagine un atributo que sea el denominador de una clase
Fracción, este nunca puede ser 0, daría serios problemas de definición y de compilación, de esta
forma es muy útil definir un método setDenomindor(), de tal forma que verifique siempre que el
atributo va a ser cambiado, que se haga correctamente, el código puede ser:
void setDenominador (int den) {

if (den ! = 0) // si el argumento den es 0 no se cambia el atributo,

denominador = den; // de lo contario se hace el cambio
}
Otra situación que es interesante enfatizar es que también existen atributos que nunca
deben ser cambiados, por ejemplo un número de cédula, un número de cuenta bancaria y en estos
casos no se les debería crear un método set(), pues esto podría abrir la posibilidad de que alguien
lo usara y causara un daño al sistema.
3) Métodos de cálculo: son métodos de una clase encargados de llevar a cabo los cálculos
necesarios.
4) Métodos privados: son métodos que sólo pueden ser accedidos desde métodos de la clase.
Ejemplo: utilizando la clase Punto, se muestran los métodos que corresponden en el diagrama
de UML, observe que los atributos son privados y los métodos públicos, con excepción del
destructor:
Figura 8. Diagrama UMl par la clase Punto.
Punto
-x: real
-y: real
+Punto()
+Punto(real a)
+Punto(real a, real b)
+setX()
+setY()
+getX()
+getY()
+distancia(real a, real b)
+distanciaOrigen()
~Punto()

Implementación
Para dar inicio a la implementación del concepto de clase, necesitamos definir y entender
con claridad la implementación de los atributos mediante campos, y como estos campos tienen
una representación computacional, para ello se introduce el tema de tipos de datos.
Tipos de datos básicos
En la mayoría de los lenguajes se brinda un conjunto de tipos de datos que son necesarios
en la escritura de las aplicaciones, a éstos se les denominan tipos de datos básicos o primitivos y
entre éstos no deben faltar los tipos de datos para representar enteros, reales, caracteres, cadenas
de caracteres y lógicos.
Tabla 10. Tipos de datos en C.

Descripción Bits Rango de valores Alias C++
Bytes con signo 8 [-128, 127] sbyte
Bytes sin signo 8 [0, 255] byte
Enteros cortos con signo 16 [-32.768, 32.767] short
Enteros cortos sin signo 16 [0, 65.535] ushort
[-2.147.483.648,
Enteros normales 32 int
2.147.483.647]
Enteros normales sin signo 32 [0, 4.294.967.295] uint
[-9.223.372.036.854.775.808,
Enteros largos 64 long
9.223.372.036.854.775.807]
Enteros largos sin signo 64 [0,18.446.744.073.709.551.615] ulong
Reales con 7 dígitos de
32 [1.5×10-45, 3.4×1038] float
precisión
Reales de 15-16 dígitos de
64 [5.0×10-324, 1.7×10308] double
precisión
Reales de 28-29 dígitos de
128 [1.0×10-28, 7.9×1028] decimal
precisión
Valores lógicos 8 true, false bool
Caracteres Unicode 16 ['\u0000', '\uFFFF'] char

Cadenas de caracteres Variable El permitido por la memoria string
Algunos ejemplos de valores de los principales tipos de datos básicos son:
Tabla 11. Ejemplos de tipos de datos básicos
Tipo de dato Posibles valores

int 1, -5, 532, -423
double 1.0, -5.0, 2.24, -43.54, 542.342
bool true, false
char ‘B‘, ‘b‘, ‘@‘, ‘1‘, ‘/‘,‘a‘
string “Juan“,“Ejemplo de oración“
Sintaxis y semántica
Una instrucción en C++ es una secuencia de símbolos (o caracteres) de un alfabeto

básico. Una secuencia de símbolos forma lo que se denomina el texto o código fuente de una
clase. Sin embargo, no cualquier secuencia de símbolos representa una clase (al igual que no
cualquier secuencia de letras del alfabeto latino conforman una oración del idioma español)
Hay dos aspectos que determinan si una secuencia de símbolos es correcta: la sintaxis y la
semántica.
Las reglas de sintaxis son las que permiten determinar de que manera los símbolos del
vocabulario pueden combinarse para escribir código que por su forma sea correcto.
Así, por ejemplo, en el lenguaje natural son las reglas de la sintaxis las que nos permiten
determinar que la siguiente secuencia no es correcta:
Caballo el el hombre cabalga sobre
La semántica por su parte guarda una estrecha relación con las acciones o instrucciones.
Esta permite determinar el significado de la secuencia de símbolos para que se lleve a cabo la
acción por la computadora. También a través de las reglas semánticas pueden ser detectados

errores de interpretación que no permiten que las acciones o instrucciones puedan ser ejecutadas.
Por ejemplo, aunque en el lenguaje natural la oración:
El caballo cabalga sobre el hombre
es sintácticamente correcta, no lo es semánticamente, pues no expresa una idea lógica.
De forma similar son las reglas semánticas las que permiten determinar si una secuencia
de símbolos no forma un código correcto, aunque no tenga errores sintácticos.
Sintaxis para la definición de clases
Con esta idea en mente se irán describiendo las reglas sintácticas y semánticas para una
adecuada implementación de una clase, y de una vez se incluirán algunas convenciones básicas,
como son la indentación y el uso de identificadores nemotécnicos:
class <NombreClase>
{
<miembros>
}; // esto es un comentario para indicar que este punto es muy importante
De este modo se define una clase con nombre <NombreClase> cuyos miembros (atributos
y métodos) son los que se definen en <miembros>, estos estarán presentes en cada uno de los
objetos o instancias de la clase. <NombreClase> debe ser un identificador de la clase que
realmente la represente, es decir que sea significativo, y además debe ir en singular y en
mayúscula como parte de las convenciones.
Identificadores
Los identificadores son nombres simbólicos que se forman mediante una secuencia de letras
y dígitos y en C tienen que cumplir con las siguientes convenciones:
 El primer carácter de un identificador tiene que ser siempre una letra o un guión bajo
(subrayado), el carácter subrayado se considera como una letra más.

 Un identificador no puede contener espacios en blanco ni otros caracteres distintos de
los citados, como por ejemplo: * , : / ….
Los identificadores son utilizados para nombrar las diferentes entidades presentes en una
clase.
Ejemplos:
Tabla 12. Ejemplos de variables.
Identificador Estado Observación
edad correcto
Color camisa incorrecto No se permiten blancos

67 incorrecto Debe iniciar con letras o _
max_Valor correcto
minimo% incorrecto No se permite %

edad_Promedio correcto
345Ed7 incorrecto Debe iniciar con letras o _
Ca45_uv correcto
diaFecha correcto
_salario correcto
Algunos principios importantes sobre el uso de los identificadores que deben tenerse en
cuenta son:
 Usar identificadores nemotécnicos (que sugieren el significado de la entidad que

nombran). Por ejemplo, nombre, apellidos y Edad son mas significativos para la lectura
que n, a y E.
 No sacrificar la legibilidad por la longitud de los identificadores. Utilizar identificadores

pronunciables. Esto ayuda a la memorización de los nombres y a la explicación oral del
código fuente, por ejemplo no utilizar aN en lugar de annoNacimiento, sin embargo es
importante considerar un tamaño razonable para identificadores muy usado, por

ejemplo annoNac cumple con todas las consideraciones y convenciones a considerar,
pues es claro y no tan grande como annoNacimiento.
Algunos lenguajes son case sensitive, C lo es, esto es que las mayúsculas y las minúsculas
no son lo mismo, de esta manera los identificadores que apenas se diferencian en una mayúscula
ya son diferentes, por ejemplo: Color es distinto de color.
Palabras reservadas
Algunos identificadores tienen un uso especial en los lenguajes de programación. Estos

identificadores son conocidos como palabras claves o palabras reservadas (key words o reserved
words), ya que el programador no puede darle un uso diferente al que el lenguaje les confiere.
En el caso de class su objetivo es informarle al compilador que el identificador Persona

describe una clase; mientras que string permite “informar” que los atributos nombre y apellidos
almacenarán cadenas de caracteres, además string también permite informar que el método
toString va a retornar una cadena de caracteres.
Campos
Son datos comunes a todos los objetos de una determinada clase, corresponden a atributos
de la clase y su sintaxis de definición es:
<TipoDato> <nombreAtributo>;
El <nombreAtributo> puede ser cualquier identificador que cumpla con las reglas
establecidas y no coincida con el nombre de otro miembro previamente definido en la clase, pero
por convención debe ser nemotécnico, es decir debe representar muy bien el contenido que va a
almacenar.
Variables
Las variables son entidades de los programas que se utilizan para conservar valores
durante la ejecución de éstos. Las variables permiten representar valores que no necesariamente

se conocen cuando se escriben las aplicaciones y a su vez pueden cambiar durante la ejecución de
éstas. Al contenido de las variables se tiene acceso a través de los nombres simbólicos
(identificadores) que las identifican.
Una variable es una abstracción9 de una zona de memoria que se utiliza para representar y
conservar valores de un determinado tipo. Una variable debe tener un tipo asociado que es
precisamente el tipo de los valores que ella puede Figura 9. Diagrama clase Persona
conservar. Esta definición de las variables que dice cuáles Persona
identificadores serán utilizados como nombres de variables -nombre: String

-direcion: string
y cual es el tipo asociado a estas, es lo que se denomina -annoNacimiento: int
+Persona()
declaración de variables. +Persona(string, string)
+Persona(strin, string, annoNac)
Los atributos (como concepto del modelo OO) +setNombre(string)
+setDireccion(string)
+setAnnoNacimiento(int)
pueden ser considerados como un caso particular de +getNombre()
+getDireccion()
variable teniendo en cuenta que éstos pueden conservar +getAnnoNacimiento()
+edad(int)
valores durante la ejecución de las aplicaciones. +toString()
~Persona()
Se pueden definir variables dentro del cuerpo de un
método, las cuales se pueden calificar como variables
locales, pues solo podrán ser accedidas dentro del cuerpo del método, algo similar sucede con las
variables que constituyen parámetros de un método.
Según la siguiente declaración de campos correspondientes a la clase Persona:
string nombre;
string apellidos;
int annoNacimiento;
int unAño;
Las variables son caracterizadas por un tipo (int) y un nombre simbólico

(annoNacimiento). El tipo determina la clase de valores que puede tomar una variable (valores
enteros en el caso de añoNacimiento), así como las operaciones en las que puede participar
(aritméticas en añoNacimiento). Una buena práctica en programación es dar a las variables
nombres que evoquen el objeto que representan (nombres nemotécnicos).

Como vimos anteriormente el conjunto de valores de todas las variables en un instante
dado se determina el estado de un objeto. Lógicamente, el estado de los objetos cambia cada vez
que se ejecuta una acción que modifica el valor de al menos uno de sus campos.
En la mayoría de los lenguajes las variables tienen que ser definidas antes de ser
utilizadas. Toda variable tiene que ser definida una única vez en un mismo bloque o segmento de
código y a partir de esta definición puede ser utilizada todas las veces que se desee.
Las variables son declaradas escribiendo su tipo, seguido de algún espacio en blanco y
luego el identificador de la misma terminando con un punto y coma. En caso de que se desee
definir más de una variable entonces los identificadores de las mismas tienen que ser separados
por coma. Al declarar una variable se está informando al compilador de su tipo y de su
identificador propiamente.
La estructura sintáctica para la declaración de variables se podría generalizar de la siguiente

forma:
<tipo de dato> <lista de identificadores de variables>;
Ejemplo:
class Persona
{
string nombre, apellidos;
int añoNacimiento;
…………
};
Constantes
Las constantes se utilizan para representar datos que no cambian durante toda la
aplicación. A las constantes también se les asocia un tipo de datos. Una constante también puede
ser definida como una variable cuyo valor es determinado durante el proceso de compilación.
Como convención se definirán las constantes en mayúscula.
Las constantes se definen como variables normales, ya sean campos o variables locales
(exceptuando los parámetros) pero precediendo el nombre de su tipo la palabra reservada const y
dándoles siempre un valor inicial al declararlas. Es decir, con esta sintaxis:

const <tipo de dato> <identificador> = <valor>;
Comentarios
Un comentario es texto que se incluye en el código fuente con el objetivo de facilitar su

legibilidad a los programadores. Los comentarios no tienen significado alguno para la ejecución
de una aplicación; esto es equivalente a decir que los comentarios son completamente ignorados
por el compilador.
En el ejemplo de la clase Persona:
// identificación de la clase
// atributos …
// método de consulta o acceso …
/* Esto es un comentario que ejemplifica cómo se escriben comentarios que ocupen

varias líneas
*/
Bloque de código
Para “delimitar” las responsabilidades de la clase Persona y como parte de la sintaxis de

definición de clases y métodos se utilizaron bloques de código: todos los elementos agrupados
dentro de los símbolos “{” (apertura del bloque), inmediatamente después de la definición de
“}” (cierre del bloque).
En el caso particular de las clases, el bloque de código que agrupa las responsabilidades
de la misma comienza inmediatamente después de <NombreClase>.
Las acciones u operaciones que se implementan en un método se agrupan utilizando un

bloque de código que comience inmediatamente después de (<Parámetros>) y termine después de
la última instrucción que pertenece al método.

Bibliotecas
La mayoría de los lenguajes cuentan con una biblioteca de funciones que permiten a los
programadores trabajar con código que ya ha sido probado y que funciona. Además, a partir de
estas funciones y clases el programador puede crear nuevas clases que extiendan o usen su
funcionalidad y se integren a la perfección con el resto de las clases.
Se agrupan según sus funcionalidades. El espacio de nombres System nos proporciona

tipos que son usados muy frecuentemente, como los tipos de datos básicos, entrada/salida en
consola, excepciones, tablas, etc. A su vez el espacio de nombres System contiene otros espacios
de nombres de uso frecuente Collections (colecciones de datos de uso común como pilas, colas,
listas, diccionarios, etc.), IO (manipulación de ficheros y otros flujos de datos), etc.
Expresiones y Operadores
Un operador es un carácter o grupo de caracteres que actúa sobre uno, dos o más operandos
para realizar una determinada operación con un determinado resultado. Los operadores pueden
ser unarios, binarios y ternarios según actúen uno, dos o tres operandos respectivamente.
Llamaremos operandos a un valor constante o literal, al contenido de una variable, al resultado
de la invocación de un método, al resultado de la evaluación de una operación, etc.
A continuación se describen algunos operadores incluidos en la mayoría de los lenguajes:
 Los operadores aritméticos: suma (+), resta (-), producto (*), división (/) y módulo (%).
También se incluyen operadores de menos unario (-) y más unario (+).
 Los operadores lógicos permiten realizar las operaciones lógicas típicas: and (&& y &),
or (|| y |), not (!) y xor (^).
 Como operadores relacionales se han incluido los tradicionales operadores de igualdad

(==), desigualdad (!=), mayor que (>), menor que (<), mayor o igual que (>=) y menor o
igual que (<=).
 Para la concatenación de cadenas se puede usar el mismo operador que para realizar
sumas, ya que se redefine su significado para que cuando se aplique entre operandos que
sean cadenas o que sean una cadena y un carácter lo que haga sea concatenarlos. Por

ejemplo, el método toString() para retornar el nombre y a continuación los apellidos de
los objetos Persona se auxilia de la expresión nombre + “ ” + apellidos.
Seguidamente se muestran los tipos de datos básicos y las operaciones que se pueden
realizar sobre ellos:
Tabla 13. Operaciones con tipos de datos
Tipo de dato Operaciones

int +, -, *, /, % : int x int  int
<, >, == , <=, >=, !=: int x int  bool
double +, -, *, / : double x double  double
<, >, == , <=, >=, !=: double x double 
bool
bool &, | : bool x bool  bool
no : bool  bool
char <, >, == , <=, >=, != : char x char  bool
+ : char x char  int
string == , != : string x string  bool
+ : string x string  string
Si se desea obtener el valor exacto de la división de 5 entre 2 se tiene que expresar al menos
uno de los valores como constante del dominio de los números reales: 5.0 / 2 (5 / 2.0 ó 5.0 / 2.0).
Una expresión es una combinación de operaciones sobre operandos (valores) que nos
permite obtener nuevos valores. Una expresión también puede ser definida como un operando o
la aplicación de operadores sobre operandos.
La expresión es equivalente al resultado que proporciona el aplicar sus operadores a sus

operandos. Una expresión puede estar formada por otras expresiones más sencillas, y puede
contener paréntesis de varios niveles agrupando distintos términos.

Operador de asignación
Para asignarle valores a las variables se utiliza el operador de asignación “=”, cuya
sintaxis es:
<variable> = <expresión>;
La instrucción de asignación es un caso particular de instrucción que permite asignarle

(“=”) a una variable (<variable>) el resultado de la evaluación de una expresión (<expresión>),
siendo particularmente para la POO el mecanismo utilizado para el cambio de estado de los
objetos.
Ejemplos:
int temperatura;
uint edadJuan;
temperatura = -5;
uint edadPedro = 23;
edadJuan = edadJuan + 2;
edadPedro = edadPedro + 1;
float peso = 60.5;
char letra = 'a';
string nombreJuan = “Juan“;
string nombrePedro, nombreAna;
nombrePedro = nombreJuan;
nombreAna = “Ana“;
bool existe = true;
La instrucción de asignación se ejecuta cumpliendo el siguiente principio: “se evalúa la

expresión a la derecha del operador de asignación (=) y el resultado de esta evaluación se le da
como valor a la variable que está a la izquierda del operador”. Luego de haberse efectuado esta
asignación de valores a la variable de la izquierda este valor sustituye cualquier otro que hubiera
tenido con anterioridad la variable.

Nota: Es importante diferenciar este operador de asignación con el utilizado en las
igualdades matemáticas. ( = = )
Es posible relacionar la propia definición de las variables con el primer valor que se le
asigna, en este caso se le llama inicialización, por ejemplo:
bool existe = true;

string nombreJuan = “Juan“;
Además de los elementos presentados con anterioridad, el operador de asignación tiene otra
serie de funcionalidades como se muestra a continuación:
 Se han incluido operadores de asignación compuestos que permiten ahorrar en la edición de

nuestros códigos a la hora de realizar asignaciones tan comunes como:
peso = peso + 10; // Sin usar asignación compuesta
peso += 10; // Usando asignación compuesta
Las dos líneas anteriores son equivalentes, pues el operador compuesto += lo que hace es
asignar a su primer operando el valor que tenía más el valor de su segundo operando. Como
se ve, permite compactar bastante el código.
 Aparte del operador de asignación compuesto +=, también existen operadores de asignación
compuestos para la mayoría de los operadores binarios ya vistos, como por ejemplo: +=, -=,
*=, /=, %=, &=.
 Otros dos operadores de asignación incluidos son los de incremento(++) y decremento (--)
Estos operadores permiten, respectivamente, aumentar y disminuir en una unidad el valor de
la variable sobre el que se aplican. Así, estas líneas de código son equivalentes:
peso = peso + 1; // Sin asignación compuesta ni incremento
peso += 1; // Usando asignación compuesta
peso++; // Usando incremento
Si el operador ++ se coloca tras el nombre de la variable (como en el ejemplo) devuelve el

valor de la variable antes de incrementarla, mientras que si se coloca antes, devuelve el valor
de ésta tras incrementarla; y lo mismo ocurre con el operador --. Por ejemplo:

c = b++; // Se asigna a c el valor de b y luego se incrementa b
c = ++b; // Se incrementa el valor de b y luego se asigna a c
La ventaja de usar los operadores ++ y -- es que en muchas máquinas son más eficientes
que el resto de formas de realizar sumas o restas de una unidad, pues el compilador puede
traducirlos en una única instrucción en código máquina.
Prioridad de los operadores
El resultado de una expresión depende del orden en que se ejecutan las operaciones. Si no
existiese un orden de prioridad entre los operadores, la siguiente expresión:
3 + 4 * 2;
daría 11 si se efectúa primero la multiplicación y después la suma y 14 en caso contrario
Con el objetivo de que el resultado de cada expresión sea claro e inequívoco es necesario
definir reglas que definan el orden en que se ejecutan las expresiones. Existen dos tipos de reglas
para determinar este orden de evaluación: las reglas de precedencia y las de asociatividad.
Para la evaluación de las expresiones se aplican las siguientes reglas cuando existe más de
un operador:
 Si en la expresión todos los operadores tienen la misma prioridad la evaluación de estos

se lleva a cabo de izquierda a derecha.
 Cuando existen operadores de diferente prioridad se evalúan primero los que tengan
mayor prioridad, a continuación los de la prioridad siguiente y así sucesivamente.
 Las dos reglas anteriores quedan sin efecto cuando se incluyen paréntesis. En este caso
la parte de la expresión encerrada entre paréntesis se evalúa primero siguiendo a su vez
estas tres reglas.
Seguidamente se muestra en una tabla la precedencia (ordenados de mayor a menor) y

asociatividad de los operadores.

Tabla 14. Tabla de precedencia de los operadores.
Precedencia Asociatividad
() [] izquierda a derecha
++ -- ! + (unuario) – (unario) derecha a izquierda
* / % izquierda a derecha
+ – izquierda a derecha
< <= > >= izquierda a derecha
== != izquierda a derecha
&& & izquierda a derecha
|| | izquierda a derecha
?: derecha a izquierda
= += -= *= /= %= &= |= derecha a izquierda
, izquierda a derecha
Métodos
La implementación de un método puede verse como un conjunto de acciones que se agrupan

a través de un determinado nombre simbólico de tal manera que es posible ejecutarlas en
cualquier momento sin tener que volverlas a escribir sino usando sólo su nombre. A estas
instrucciones se les denomina cuerpo del método, y a su ejecución a través de su nombre se le
denomina llamada al método.
Los métodos son bloques de instrucciones que pueden devolver algún valor cuando se
ejecutan. Invocar a un método hace que las instrucciones del mismo se ejecuten. En las
instrucciones es posible acceder con total libertad a la información almacenada en los campos de
la clase a la cual pertenece el método.
A continuación se presenta de forma general la sintaxis de declaración de los métodos:
< Tipo devuelto > < Nombre simbólico del método > ([<Parámetros>])
{
< Cuerpo del método >

A su vez todo método puede devolver un objeto como resultado de haber ejecutado las
<instrucciones>. En tal caso el tipo del objeto devuelto tiene que coincidir con el especificado en
<TipoDevuelto>, y el método tiene que terminar con la cláusula return <objeto>. En caso que
se desee definir un método que no devuelva objeto alguno se omite la cláusula return y se
especifica void como <TipoDevuelto>.
Opcionalmente todo método puede recibir en cada llamada una lista de parámetros a los que
podrá acceder en la ejecución de las <instrucciones> del mismo. En <Parámetros> se indican los
tipos y nombres de estos parámetros y es mediante estos nombres con los que se deberá referirse
a ellos en el cuerpo del método.
Aunque los objetos que puede recibir el método como parámetro pueden ser diferentes cada
vez que se solicite su ejecución (llamado), siempre han de ser de los mismos tipos y seguir el
orden establecido en <Parámetros>.
La sintaxis usada para llamar a los métodos de un objeto es la misma que se utiliza para
acceder a sus campos, solo que además tras el nombre del método que se desea invocar habrá que
indicar entre paréntesis cuales son los valores que se desea dar a los parámetros. O sea se escribe
de la siguiente forma:
<objeto>.<nombre del método>([<valor de los parámetros>])
<objeto> no tiene que ser explícitamente el nombre de una instancia de objetos, es

cualquier expresión que retorne como resultado un objeto.
Los términos método y función suelen usarse de forma indistinta, pero hay una diferencia.
Un método es una función contenida en una clase. Una función suele ser un grupo de
instrucciones que no está contenido en una clase y que suele estar en un lenguaje, como C o C++.
En algunos lenguajes como C# no se puede añadir código fuera de una clase. Todos los métodos
se encierran en una clase.
La ejecución de las acciones de un método puede producir como resultado un objeto de

cualquier tipo. A este objeto se le llama valor de retorno del método y es completamente
opcional, por lo tanto se pueden escribir métodos que no devuelvan ningún valor.
Ejemplo: en este ejemplo se muestra una implementación de la clase Persona (ver la

representación en UML en la fig. 9 clase Persona)

// identificación de la clase
class Persona
{
prívate:
// campos que corresponden a atributos …
string nombre;
string apellidos;
int annoNacimiento;
public:
// constructor sin parámetros
Persona ()
{
nombre = “ Indefinido”;
apellidos= “Indefinido”;
annoNacimiento = 0;
}
// constructor con 2 parámetros
Persona (string nom, string ape)
{
nombre = nom;
apellidos= ape;
annoNacimiento = 0;
}
// constructor con 3 parámetros
Persona (string nom, string ape, int annoNac) {
nombre = nom;
apellidos= ape;
annoNacimiento = annoNac;
}
// método de consulta o acceso …
void setNombre (string nom){

nombre = nom;
}
void setApellidos(string ape){
apellidos = ape;
}
void setAnnoNacimiento(int anno){
annoNacimiento = anno;
}
float getNombre ( ){
return (nombre);
}
float getApellidos ( ){
return (apellidos);
}
float getAnnoNacimiento ( ){
return (annoNacimiento);
}
// métodos de cálculo
int edad (int annoActual) //método que devuelve la edad de la persona
{
// edad aproximada a partir del año actual
return annoActual - annoNacimiento;
}
string toString() // método que muestra los datos de la persona
{
return nombre + ” ” + apellidos; //concatena cadenas de caracteres
}
~Persona ()
{
// método destructor
}
}; // fin de la clase
Este ejemplo muestra la implementación haciendo uso de los distintos métodos que
conforman una clase.

Un método importante es el toString() que convierte los datos importantes de una
instancia de la clase Persona en una cadena de caracteres, uniendo el nombre y los apellidos, en
este caso los campos son de tipo cadena de caracteres y el operador + en este ámbito realiza la
unión de ambas cadenas . Puede decirse que es una convención, que se definirá en casi todas las
clases para mostrar un objeto en forma de cadena de caracteres, pues esto facilita el proceso de
imprimir un objeto y más delante entenderemos mejor las razones para esta convención y la
mejoraremos un poco.
Parámetros de los métodos
El método edad() para cumplir con su responsabilidad de retornar el valor de la edad (con
relación a un año determinado) de cualquier Persona necesita saber el año de nacimiento (resuelto
a través del campo annoNacimiento), además necesita conocer con respecto a que año va a
calcularse dicha edad y esto es desconocido en principio, además puede ser que en un momento
quisiera saber la edad de una persona en el año actual o hace 5 años. Es por ello que aseguramos
que le está faltando información al método edad() para cumplir con la respectiva responsabilidad
asignada. La referida información que está faltando es la que se completa a través del parámetro
int unAño.
Los parámetros son definidos entre paréntesis a continuación del nombre de la clase. Un
método puede contener varios parámetros (lista de parámetros) o ninguno. En caso de contener
una lista de parámetros, cada uno de ellos va antecedidos por su tipo y separados por coma. En
caso contrario la lista de parámetros estaría vacía.
Al conjunto formado por el nombre de un método y el número y tipo de sus parámetros se

le conoce como signatura o firma del método. La signatura de un método es lo que
verdaderamente lo identifica.
Cuerpo del método
Se le denomina instrucción a toda acción que se pueda realizar en el cuerpo de un método,

como definir variables, llamar a métodos, asignaciones y muchas cosas más como veremos a lo
largo de este documento. Las instrucciones se agrupan formando bloques de instrucciones

(bloques de codigo), que son secuencias de instrucciones encerradas entre llaves que se ejecutan
una tras otra.
El cuerpo de un método es el bloque de instrucciones que compone el código del método,

por ejemplo
return unAño - añoNacimiento;
La palabra reservada return se utiliza para especificar precisamente el valor que va a

retornar el método. Si se define un método que retorna un valor, es responsabilidad del
programador garantizar que durante el desarrollo de las acciones (instrucciones) del mismo se
retorne siempre un valor, en caso contrario el compilador reportará un error.
En caso de que el método no tenga que retornar ningún valor, simplemente no hay que usar
el return dentro del cuerpo, y se especifica void en el encabezado de la declaración del método
como < Tipo devuelto >.
Sobrecarga de métodos
Suponga que una alternativa para el método edad() de la clase Persona es poder calcular
la edad de una instancia de Persona a través del valor retornado por el reloj interno de la máquina
(el año en este caso).
Lo interesante de este planteamiento es que ahora la propuesta del método edad() dispone
de toda la información para dar un resultado ya que el año a comparar sería obtenido desde el
reloj interno de la máquina.
Suponga que se quieren brindar las dos facilidades, una que calcule la edad a partir de un
año dado y otra que la calcule a partir del año actual adquirido a través del reloj de la máquina.
Evidentemente esta propuesta conlleva a interrogantes interesantes, pues como se ha decidido
brindar las dos facilidades se tienen que definir dos métodos para acceder a estas de forma
independiente, puesto que sus propuestas de solución difieren notablemente.
¿Qué nombres llevarán estos métodos? Como ambos métodos están definidos con el
objetivo de calcular la edad de una instancia de Persona el nombre más lógico con el cual se debe
hacer referencia a cada uno de ellos debe ser edad(), pues otro nombre se contradice con lo que
realmente hace o con el objetivo para lo cual fue diseñado. Luego en la clase Persona existirían
dos métodos con igual identificador, tipo devuelto y solo con la diferencia de que uno necesita de
un parámetro para establecer con respecto a que año se calcularía la edad, mientras que el otro no
necesita del parámetro porque la calcula respecto al año actual tomado del reloj de la máquina.
En una misma clase se pueden definir varios métodos con el mismo nombre siempre y
cuando tomen diferente número o tipo de parámetros, o que en caso extremo si tienen igual
número y tipo de parámetros se diferencien en el orden de los mismos.
Ejemplo:
class A
{
…
int f(int x, int y){...}
int f(string x, int y){...}
int f(int x, int y, int z){...}
int f(int y, string x){...}
int f(int a, int b){...}
}
El ejemplo anterior consta de 5 definiciones del método f. Las cuatro primeras son
aceptadas por el lenguaje, ya que difieren en el tipo, la cantidad u orden de los parámetros. El
último caso no es correcto pues solo se diferencia del primero en los identificadores de los
parámetros. Este produce un error semántico puesto que existe un método previamente definido
que tiene dos parámetros enteros. Es decir, el nombre de los parámetros, no establece diferencia
alguna para la signatura de distintos métodos.
A la posibilidad de disponer de varios métodos con el mismo nombre, pero con diferente
lista de parámetros es lo que se conoce como sobrecarga de métodos, cuando se les invoca el
compilador podrá determinar a cual llamar a partir de los parámetros pasados en la llamada.
Lo que no se permite es definir varios métodos que solamente se diferencien en su valor de

retorno, puesto que la forma de invocar a los métodos a través de instancias de la clase es
<objeto>.<nombre del método>([<valores de los parámetros>])

como el tipo devuelto no tiene que especificarse en el llamado, la existencia de varios métodos,
que solo se diferencien en este valor se retorno se considera un error, ya que no se podría
diferenciar a que método en concreto se hace referencia en la llamada.
Ejemplo
class A
{
…
int f(int x, int y){...}
string f(int x, int y){...}
}
Suponga que a1 es una instancia de A. ¿Qué sucedería con una instrucción de la forma
a1.f(2, 4)?
Evidentemente, no se sabría a cual de las dos variantes de método llamar pues como ya se
mencionó el tipo devuelto no establece diferencias en la llamada a los métodos.
La sobrecarga de métodos se establece entre métodos con igual identificador y diferente
signatura.
Los métodos constructores son el ejemplo clásico de métodos sobercargados.
Constructores
Los constructores de una clase son métodos especiales que se definen como componentes
(responsabilidades) de ésta y que contienen código a ejecutar cada vez que se cree un objeto de
ese tipo. Éste código suele usarse para la inicialización de los atributos del objeto a crear, sobre
todo cuando el valor de éstos no es constante o incluye acciones más allá de una asignación de
valor. La sintaxis básica de definición de constructores consiste en definirlos como cualquier otro
método pero dándoles el mismo nombre que la clase a la que pertenecen y no indicando el tipo de
valor de retorno.
No tiene sentido que un constructor devuelva objetos por lo que incluir en su definición
un campo <TipoDevuelto> se considera erróneo (incluyendo void).

La sintaxis apropiada para definir constructores es:
<nombreTipo>([<parámetros>])
{
Figura 11. Dagrama de la clase Circunferencia
<código>
} Circunferencia
-x: float
-y: float
Ejemplo: Diseñar una clase para representar circunferencias,-radio:
según el
float siguiente UML
+Circunferencia()
+Circunferencia(float, float, float)
+setX(float)
class Circunferencia +setY(float)
+setRadio(float)
{ +getX()
+getY()
prívate: +getRadio()
float x, y; +area()
+longitud()
float radio; ~Circunferencia()
public:
Circunferencia () Fuente: Elaboración propia
{
x = y = radio =0;
}
Circunferencia (float a, float b, float r)
{
x = a;
y = b;
radio = r;
}
void setX(float a){
x = a;
}
void setY(float b){
y = b;
}
void setRadio(float r){
radio = r;
}
float getX ( ){
return (x);
}
float getY ( ){
return (y);
}
float getRadio ( ){
return (radio);
}
float area()
{
return 3.14159 * radio * radio;
}
float Longitud()
{
return 2 * 3.14159 * radio;
}
}
En este ejemplo la definición de PI como 3,14159 permite ejemplificar el tema de las

constantes, la siguiente es una definición de constante en C++:
const double PI = 3.14159;
Particularmente, en C++ existe una clase ya definida denominada Math en la cual se

define la constante  (PI), por lo que el ejemplo anterior podría resoverse como:
double Area()
{
return Math.PI * radio * radio;
}
Algunas de las ventajas que reportaría el uso de la constante PI:
 Es tedioso y monótono escribir constantemente la secuencia 3.14159 en vez de PI,

además se pueden cometer errores que no serían detectados por el compilador.
 Mayor legibilidad para los códigos fuentes.
 Si se decide cambiar la precisión (usar por ejemplo 3.1415926) se tendrían que hacer
modificaciones en todos los lugares donde aparece la secuencia de dígitos.
La última de estas ventajas trae consigo una problemática: ¿Cómo modificar una constante
de una clase ya definida? Esto no es posible pues en principio no se debe contar con el código

fuente de la clase Math para cambiar el valor de PI, pero esto se podría solucionar definiéndo una
constante con nombre PI en la propia clase Circunferencia como se muestra a continuación:
Ejemplo:
clase Circunferencia
{
prívate:
float x, y;
float radio;
const float PI = 3.1415926;

………….
float Area()
{
return PI * radio * radio;
}
float Longitud()
{
return 2 * PI * radio;
}
}
Es posible unificar el proceso de creación de la instancia y la inicialización de sus

campos, definiendo explícitamente un constructor que reciba como parámetros los valores que se
utilizarán para la inicialización de los campos del objeto y que contenga en su cuerpo dicha
inicialización de los campos, ejemplo:
Persona (string nom, string ape, int annoNac) // constructor con 3 parámetros
{
nombre = nom;
apellidos= ape;

annoNacimiento = annoNac;
}
De acuerdo al ejemplo anterior, ¿Qué sucede si los parámetros del constructor se

denominan igual que los campos? ¿Dentro del cuerpo del constructor a quien se haría referencia
al campo o al parámetro?
La respuesta a estas interrogantes se puede obtener a partir de los conceptos de alcance

(ámbito) y tiempo de vida de las variables.
Tiempo de vida de las variables: Es el tiempo durante el cual se puede hacer referencia a la
variable y va desde su creación hasta que dejan de existir. Para el caso de los campos de los
objetos, estos existen durante toda la vida de los objetos. Pero en el caso de las variables locales
(ejemplo, los parámetros), su tiempo de vida es mas limitado pues dejan de existir después que
finalice el bloque de instrucciones al que pertenece.
Alcance o ámbito: Este concepto esta relacionado con la visibilidad de las variables y
especifica desde que código es posible hacer referencia a la variable.
Lo que supuestamente podría dar un error por una posible redefinición de la variable nombre
(por ejemplo) no sucede, puesto que la definición del parámetro se realiza en un bloque más
interno que la del campo. El parámetro, durante su tiempo de vida, oculta al campo.
Para solucionar esta problemática, C++ ofrece la palabra reservada this, que permite
referenciar al objeto en curso y uno de sus usos es diferenciar campos y parámetros (entre otros
usos, que se detallarán en cursos siguentes) con iguales identificadores, en el ámbito que sea
necesario como se muestra en el siguiente ejemplo:
class Persona
{
string nombre;
string apellidos;
uint annoNacimiento;
Persona(string nombre, string apellidos, int annoNacimiento)

{
thisnombre = nombre;
this apellidos = apellidos;

this annoNacimiento = annoNacimiento;
}
….
}
La palabra reservada this identifica al objeto en curso o actual, o sea, al objeto para el cual
se está ejecutando el código del método en cuestión. Esto permite que a través de this se haga
referencia a las responsabilidades de este objeto y no de algún otro.
Convenciones de código
Se establecen un conjunto de reglas que permitan dar un buen nivel de homogeneidad al

código fuente y su objetivo es facilitar la lectura de dicho código, principalmente a otros
programadores que no participaron en la elaboración del mismo.
Algunas recomendaciones para el estilo de código son:
 Evitar en lo posible líneas de longitud superior a 80 caracteres.
 Indentar (dejar snagría de al menos 3 espacios) en los bloques de código.
 Las llaves de apertura (“{”) se colocarán siempre en una sola línea, inmediatamente después
de la línea de la instrucción que da pie a su uso y con la misma indentación de dicha
instrucción y las de cierre (“}”) se colocarán de igual forma en una sola línea coincidiendo
con su respectiva llave de apertura.
 Los operadores se separarán siempre de los operandos por un carácter "espacio". La única
excepción para esta regla es el operador de acceso a los componentes de objetos y clases (“.”)
que no será separado.
 Utilizar identificadores nemotécnicos, es decir, utilizar nombres simbólicos adecuados para

los identificadores lo suficientemente autoexplicativos por si mismos para dar una orientación
de su uso o funcionalidad de manera tal que podamos hacer más claros y legibles nuestros
códigos.
 Los identificadores para constantes se especificarán siempre en mayúsculas.

 Los identificadores de variables y parámetros se especificarán siempre comenzando en
minúsculas, si se compone de más de un nombre, entonces el segundo comenzará con
mayúscula.
 Los identificadores de clases siempre se escriben con la inicial en mayúscula y en singular.
 Los identificadores de clases, métodos y propiedades se especificarán siempre comenzando

en mayúsculas, si se compone de más de un nombre, entonces el segundo también comenzará
con mayúscula.
 Utilizar comentarios, pero éstos seguirán un formato general de fácil portabilidad y que no
incluya líneas completas de caracteres repetidos. Los que se coloquen dentro de bloques de
código deben aparecer en una línea independiente indentada de igual forma que el bloque de
código que describen.
Creación de objetos: instancias
Para manipular objetos o instancias de tipos de dato que no sean básicos también se
utilizan variables, los objetos tienen que ser creados (tómese por crear un objeto el hecho de
reservar memoria para almacenar los valores de todos sus campos). La creación de objetos se
hace mediante sus métodos constructores. Para efectos del curso sólo vamos a construir objetos
estáticos, pues se ha dejado el tema de punteros para el siguiente curso. De esta manera la
sintaxis sería:
<tipo de dato objeto> <variable> [(<lista de argumentos>)]
El <tipo de dato objeto> corresponde a una clase definida, se usará como un tipo de dato,
sólo que en este caso se está definiendo un objeto, que será nobmrado mediante el nombre
definido en <variable>. La lista siguiente [(<lista de argumentos>)] es opcional, depende del
constructor que se decida usar, para la clase Persona veamos algunos ejemplos:
{
…….
Persona Juan;
Persona Pedro (“Pedro”, “Pérez”);
Persona Ana ( “Ana”, “Soto”, 1990);
Pedro.setNombre (“Juan”);
….
}
Al ser las variables objeto estáticas se destruyen al terminar el ámbito en que fueron
definidas.
Ejemplos:
1. Clase Temperatura.
Diseñe e implemente una clase Temperatura con la capacidad para almacenar un valor de
temperatura en grados Celsius (C) y obtener su correspondiente en grados Fahrenheit (F)
(F = C * 9 / 5 + 32).
Para comenzar es necesario determinar las responsabilidades y clasificarlas en variables y

métodos. A partir del enunciado queda explícito que al menos se tiene que implementar una
responsabilidad para almacenar un valor de temperatura en grados Celsius, lo cual constituye
un dato o información por lo que se implementa a través de una variable; por otra parte se
debe poder obtener la conversión de este valor a grados Fahrenheit donde evidentemente
intervienen acciones u operaciones por lo que su representación es a través de un método.
Figura 12. Diagrama de la clase Temperatura
Temperatura
-graCelsius
+Temperatura()
+Fahrenheit()
~Temperatura()
class Temperatura
{
private:
double celsius;
public:
Temperatura (double unaTempCelsius)
{

thiscelsius = unaTempCelsius;
}
double Fahrenheit()
{
return thiscelsius * 9.0 / 5 + 32;
}
~Temperatura ()
{
}
}
2. Clase Peso
Diseñe e implemente una clase Peso con que almacena un peso en libras y puede obtener
su equivalente en kilogramos y gramos. (Una libra equivale a 0.453592 kilogramos)
Analizando el enunciado anterior queda explícito que al menos tenemos que implementar una
responsabilidad para almacenar el valor de un peso en libras, el cual también constituye un dato o
información por lo que se implementa a través de una variable; por otra parte se debe poder
obtener la conversión de este valor a gramos y kilogramos donde evidentemente también
intervienen acciones u operaciones por lo que estamos en presencia de dos métodos. En la
implementación de estos métodos veremos como hecho significativo la reusabilidad de código
puesto que si se dispone de una expresión para la conversión a kilogramos, se utiliza el valor
convertido en kilogramos para la conversión a gramos.
Figura 13. Diagrama de la clase Peso
Peso
-libras: real
+Peso(real)
+kilogramos()
+gramos()
~Peso()

class Peso
{
private:
float libras;
public:
Peso (float unPesoLibras)
{
thislibras = unPesoLibras;
}
void setLibras(float lib){
thislibras = lib;
}
float getLibras ( ){
return (thislibras);
}
float Kilogramos()
{
return thislibras * 0.453592;
}
float Gramos()
{
/* aquí se reutiliza código puesto que se llama al método Kilogramos()
en vez de colocarse explícitamente la expresión para el cálculo de este
*/
return Kilogramos() /1000;
}
~Peso ()
{
}
}
3. Clase Triángulo.
En este ejemplo se implementa una clase llamada Triangulo. Todo triangulo está
compuesto por tres líneas coplanares (que se encuentran en el mismo plano) y que cada línea
tiene una determinada longitud. Así que un triángulo está compuesto por tres líneas cuyas
longitudes representan una terna. Se sabe que una terna es la unión de tres números, por ejemplo
3, 4, 5 es una terna pitagórica, ya que representan las medidas de un triangulo rectángulo. Sin

embargo se debe tener claro que tres longitudes cualesquiera no necesariamente forman un
triángulo, así que debe ocmprobarse si la terna consiste en un triángulo.
Entonces para hablar de un triángulo, basta con referirse a tres números que cumplan cierta
condición específica. De ahí que crear y escribir una clase que tenga tres valores pueden
representar los lados de un triángulo.
Figura 14. Diagrama de clase Triángulo
Triangulo
-lado1: float
-lado2: float
-lado3: float
+Triangulo()
+Triangulo(float, float, float)
+setLado1()
+setLado2()
+setLado3()
+getLado1()
+getLado2()
+getLado3()
-esTriangulo()
+area()
+perimetro()
+Operation1()
~Triangulo()
Según la descripción anterior se definirá una clase Triángulo de esa forma, sin embargo
pueden darse distintas definiciones de la misma, según el uso que se la dará a la clase.
Título: Triángulo.
Atributos: longitudes de tres líneas cualesquiera, área, perímetro.
NOTA: El área y el perímetro se pueden obtener de la longitud de las tres líneas, por lo que no se
consideran para tener un campo, pues pueden ser calculados en cualquier momento, lo cual
facilita el proceso de mantenimiento de la correctitud de los datos, si fueran campos cada vez
que cambia una longitud habría que cambiar los campos de área y perímetro, pero al ser
calculados sólo se llama a los métodos cuando se necesiten.

Métodos: además de los métodos constructores se escribirán los métodos set( ) y get( )
respectivamente para cada atributo y por último los métodos de cálculo, para saber
a) si las longitudes que tiene el objeto triángulo representan realmente a un triángulo o no,
b) calcular el perímetro del triángulo,
c) calcular el área del triángulo,
///// Escuela de Informática

///// EIF 200 Fundamentos de Informática
///// Autor: profesor
#include <iostream>
#include <math.h>
using namespace std;
class Triangulo {
private:
float lado1;
float lado2;
float lado3;
public:
// método constructor sin parámetros
Triangulo( ){
this lado1 = 0;
this lado2 = 0;
thislado3 = 0;
}
// método constructor con parámetros
Triangulo ( float primero, float segundo, float tercero){
thislado1 = primero;
thislado2 = segundo;
thislado3 = tercero;
}
// métodos set
void setLadoUno(float primero){
thislado1 = primero;
}
void setLadoDos (float segundo){
thislado2 = segundo;

}
void setLadoTres(float tercero){
this lado3 = tercero;
}
// métodos obtener
float getLadoUno ( ){
return (thislado1);
}
float getLadoDos ( ){
}
float getLadoTres ( ){
}
};
// fin de la clase
En este ejemplo la realización de los demás métodos requieren una mayor explicación,
como veremos más adelante.
4. Clase Numero.
Definiremos una clase Numero útil para el propósito de esta guía, pues permitirá definir y
explicar métodos y estructuras de programación. El propósito de la misma es tener una clase para
cada número y definir varios métodos clásicos, como par(), abundante(), etc.
Figua 15. Diagrama de clase Numero
Numero
-num: uint
+Numero()
+Numero(uint)
+esPar()
+esAbundante()
+........()
+........()

///// Escuela de Informática
///// EIF 200 Fundamentos de Informática
///// Autor: profesor
#include <iostream>
class Numero {
private:
uint num;
public:
// método constructor sin parámetros
Numero ( ){
thisnum = 0;
}
// método constructor con parámetros
Numero( uint num){
thisnum = num;
}
// métodos set
void setNum( uint num){
thisnum = num;
}
// métodos obtener
uint getNum ( ){
return (thisnum);
} Figura 15. Diagrama de clase Fecha
};
// fin de la clase Fecha
-dia: int
-mes: int
-anno: int
5. Clase Fecha.
+Fecha()
Se define una clase Fecha que debe mantener el día, +Fecha(int, int, int)
hora y año. Es una clase que podemos usar mucho +setDia(int)
+setMes(int)
en relación con otras clases. +setAnno(int)
+getDia()
+getMes()
+getAnno()
class Fecha +annoBisiesto()
+diaMes()
{ +incrementaDia()
~Fecha()
prívate:
int día, mes, año;
public:
Fecha () Fuente: Elaboración propia
{

día = 0;
mes = 0;
año = 1;
}
Fecha ( int d, int m, int a)
{
día = d;
mes = m;
año = a;
}
// métodos set
void setDia( int dia){
thisdia = dia;
}
void setMes( int mes){
thismes = mes;
}
void setMes( int mes){
thismes = mes;
}
// métodos obtener
int getDia ( ){
return (thisdia);
}
int getMes ( ){
return (thismes);
}
int getAnno ( ){
return (thisanno);
}
bool bisiesto() // devuelve true si el año es bisiesto

{
// se deja como ejercicio al estudiante
}
~Fecha() {
// se destruye la instancia
}
}

Estructuras de control alternativas.
Con mucha frecuencia, en la solución de los problemas aparecen situaciones en que la

ejecución de una instrucción depende de si se cumple o no una situación. Es por ello que en los
lenguajes de programación aparecen las estructuras de control alternativas o condicionales que
son instrucciones que permiten ejecutar bloques de código sólo si se pone de manifiesto una
determinada condición. Estas estructuras son las que permiten resolver problemas a través de la
técnica de descomposición denominada análisis de casos.
Estructura de control alternativa simple (if)
Para tratar de resolver el ejemplo anterior, de la clase Tirángulo, es posible determinar la

presencia de una nueva instrucción o estructura sintáctica del lenguaje, en este caso la estructura
de control alternativa simple if. La sintaxis de esta nueva estructura sintáctica es la siguiente:
if (<condición>)
<bloque de instrucciones>;
La semántica de esta instrucción es la siguiente: se evalúa la expresión lógica

<condición>, si el resultado de su evaluación es verdadero (true) se ejecuta el <bloque de
instrucciones >. La instrucción condicional if refleja que en un punto dado del programa se quiere
ejecutar alternativamente (en dependencia de la evaluación de una condición), un conjunto de
instrucciones.
En el ejemplo podemos usar esta instrucción determinando el cálculo del área y perímetro
siempre y cuando el triángulo lo sea, para esto hayque comprobar que asi sea mediante un
método que sólo será usado por otros métodos en la clase, determinar si la terna es un triángulo,
de tal manera:
float perimetro ( ){
if (esTriangulo())
return (thislado1 + this lado2 + thislado3);
}

float area ( ){
double s,a;
if (esTriangulo()) {
s = (thislado1+ thislado2+ thislado3)/2;
a = sqrt( s*(s- thislado1)*(s- thislado2)*(s- thislado3));
return(a);
}
}
En este último método se hace un cálculo que ya fue calculado en el perímetro() por lo
que se podría mejorar el código de tal manera que se llame:
float area ( ){
float s;
if (esTriangulo()) {
s = (perímetro())/2;
return (sqrt( s*(s- thislado1)*(s- thislado2)*(s- thislado3)));
}
}
De esta manera sólo si la terna conforma un triángulo se harán los cálculos pertinentes,
más adelante se verán otras formas más elegantes de determinar si es un triángulo, desde los
constructores directamente, para evitar estas preguntas.
Analizando el ejmplo anterior es posible determinar la presencia de una variante de la

estructura alternativa if ahora con la presencia de una nueva cláusula (else). La sintaxis de esta
variante sintáctica de la estructura if se puede expresar de la siguiente forma:
if (<condición>)
<bloque de instrucciones 1>;
else
La semántica de esta variante es la siguiente: El <bloque de instrucciones 1> se ejecuta en

caso de que se cumpla la <condición>, en otro caso se ejecuta entonces el <bloque de
instrucciones 2>.

Al comparar las diferentes variantes presentadas es posible concluir que la estructura de
control alternativa if puede ser descrita de la siguiente forma (dado el carácter opcional de la
cláusula else):
if (<condición>)
[else
<bloque de instrucciones 2>;]
Nota: Vale aclarar que un bloque de instrucciones puede comenzar a su vez con otro if.
Continuando con el ejemplo del triángulo, el método que determina si una terna es un
triángulo requieren una estructura más compleja, como se verá a continuación:
private bool esTriangulo ( ){

if (lado1+lado2>lado3 && lado1+lado3>lado2 && lado2+lado3>lado1)
return (true);
else
return (false);
}
Cómo este método sólo se usará por otros métodos de la clase, es posible definirlo como
un método privado.
Ejemplo: Según la clase Fecha definida anteriormente se requiere que les permita a sus objetos
incrementarse en un día. Este algoritmo es muy simple, siempre y cuando el objeto Fecha no se
encuentre en el último día de su respectivo mes pues en este caso únicamente es necesario
incrementar el día. Determinar si el mencionado objeto Fecha se encuentra en el último día de su
respectivo mes nos lleva a una acción intermedia que es determinar los días del mes.
Un posible algoritmo para retornar los días de un mes se resume a devolver 30 en el caso
de los meses 4, 6, 9, 11; cuando el mes sea 2 se devuelve 28 si el año no es bisiesto y 29 en caso
contrario; finalmente se retorna 31 para el resto de los meses.
class Fecha
{
prívate:

public:
…..
int díasMes()
{
if (mes == 4 || mes == 6 || mes == 9 || mes == 11)
return 30;
else
if (mes == 2)
if (bisiesto( ))
return 29;
else
return 28;
else
return 31;
}
}
Note que en el caso de que el valor de un mes sea 2, debe verificarse otra condición, en
este caso si el año es o no bisiesto. Esto es lo que se conoce como if anidado, es decir un if como
parte de otro if. Esto muestra la capacidad de la instrucción alternativa if para expresar el caso de
que una sentencia que sigue a un if sea a su vez otro if, o que la sentencia que sigue a un else sea
otro if, y esta circunstancia puede repetirse varias veces de forma que se disponga de una serie de
decisiones anidadas.
Una vez que se dispone del método díasMes() se puede implementar entonces el método
incrementaDía(). El algoritmo en este caso consiste en determinar si el día de la Fecha en
cuestión coincide con el último día de su respectivo mes (método DíasMes), en caso negativo
apenas se incrementa el día en 1 y en caso contrario día toma valor 1 y el mes también se
incrementa en 1 exceptuando cuando es 12 (diciembre), que entonces toma valor 1 (enero) y año
se incrementa en 1.
void incrementaDía()
{
if (día != díasMes())
día++;
else

{
día = 1;
if (mes != 12)
mes++;
else
{
mes = 1;
año++;
}
}
}
Al analizar la implementación del algoritmo del método incrementaDía, es de notar que

existen dos casos mas generales que se definen a través de las expresiones: día != díasMes() y
día == díasMes(). El subproblema asociado con el segundo caso a su vez se descompone en una
acción de asignación y en otro análisis de casos (ahora con el mes). Es decir, se descompone en
dos acciones que se ejecutan secuencialmente (composición secuencial) pero a su vez una de
estas (la segunda) se resuelve a través de un análisis de casos. Este es un ejemplo de como la
descomposición de un problema en subproblemas también se puede obtener a partir de la
combinación de la composición y el análisis de casos.
Integridad de los objetos
Basados en la clase Fecha, definida anteriormente, y dado el siguiente código se observa

que la variable fecha1 transita por varios estados y algunos de ellos no pertenecen al dominio de
los objetos Fecha, o lo que es equivalente a decir, la integridad del objeto fecha1 se ha
corrompido en dos oportunidades. En el caso de la variable fecha2 desde su creación no
representa a un objeto del dominio Fecha.
…..
Fecha fecha1 (1, 1, 1975);
fecha1.día ( 32);
fecha1.mes( 2);
Fecha fecha2 (33, 4, 1969);

…….
La integridad de los objetos Fecha se ha perdido porque existe total acceso a las variables
de los objetos Fecha y porque el constructor “no se preocupa” por verificar que se garantice la
integridad durante la creación del objeto, es decir, los objetos se crean independientemente de
que los valores de inicialización no correspondan con datos que garanticen objetos del dominio
Fecha.
En un primer refinamiento se debe limitar el acceso a las variables de las instancias de la

clase Fecha. Esta limitación se traduce en no permitir acceder directamente a las variables de
dichos objetos (utilizando la sintaxis <objeto>.<responsabilidad>). Este primer refinamiento no
permitirá acciones como: fecha1.día ( 32).
Este control sobre el acceso a los campos se logra a través del mecanismo de
encapsulamiento, el cual se consigue añadiendo modificadores de acceso en las definiciones de
los miembros y tipos de datos. Estos modificadores constituyen palabras reservadas del lenguaje
que se les anteponen para indicar desde que código puede accederse a ellos, entendiendo por
acceder cualquier cosa que no sea definirlo.
En caso de no especificarse modificador alguno, se considera por defecto u omisión que los
miembros de un tipo de dato sólo son accesibles desde código situado dentro de la definición del
mismo tipo. En C++ y para los efectos de este curso se utilizan los siguientes modificadores:
 public: indica que la componente puede ser accedida desde cualquier código (+).
 private: sólo puede ser accedido desde el código de la clase a la que pertenece. Es lo
considerado por defecto (-).
A continuación se presenta una aplicación de estos niveles de visibilidad precisamente en la

clase Fecha.
En el diagrama de clases estos niveles de visibilidad se representan de la siguiente forma,

un signo – delante de los campos y un signo + antes de los métodos. Esta es una restricción que
asumiremos para este curso, para efectos de centrarnos en lo importante: resolución de
algoritmos.

A partir de este momento, al ser las variables día, mes y año privadas, no están disponibles
para los clientes de la clase Fecha, por lo tanto no es posible modificar sus valores, es decir, al
intentar realizar la siguiente operación:
fecha1.día (32);
inmediatamente el compilador reportaría un error similar al siguiente:
'Fecha1.día' no es accesible debido a su nivel de protección
Ejemplo: ¿Cómo podría ahora juan suministrar la información sobre su fecha de nacimiento?
Esto no es posible, pues se le oculta por completo a los clientes el acceso a las responsabilidades
de Fecha que almacenan sus respectivos valores. Para solucionar esto se deben definir los
métodos modificadores y accesores de los que hablamos anteriormete que retornan el valor de las
respectivas variables.
public class Fecha

{
public int getDía()
{
return día;
}
public int getMes()
{
return mes;
}
public int getAño()
{
return año;
}
public setDía(valor)

{
día = valor;
}
public setMes(valor)
{
mes = valor;
}
public setAño(valor)
{
año = valor;
}
}
Entonces a partir de este momento, se tendría acceso a los valores de las variables día, mes y año
a través de sus respectivos métodos de acceso como se muestra seguidamente:
{
fecha1.setDía(valor);
fecha1.setMes(valor);
fecha1.setAño(valor);
fecha1.getDía();
fecha1.getMes();
fecha1.getAño();
}
Para controlar la integridad de los campos en cuanto a los valores que pueda recibir, se
debe llevar a cabo una programación que verifique las condiciones dentro de las propios métodos.
En el ejemplo siguiente se muestra otro refinamiento de la clase Fecha a partir de la verificación
de las condiciones en su constructor.
public class Fecha

{
prívate:

public:
Fecha(int d, int m, int a)
{
bool fechaOK = false;
if (m > 0 && m < 13)
{
mes = m;
año = a;
if (d > 0 && d <= díasMes())
{
día = d;
fechaOK = true;
}
}
if ( !fechaOK)
{
día = 1;
mes = 1;
año = 1880;
}
}
}
En este caso la precondición que tienen que cumplir los clientes de la clase Fecha (y que
será verificada por el constructor) es que la terna de valores día/mes/año a pasar en el constructor
como parámetro, permita formar una instancia de dicho dominio de objetos. La post-condición a
cumplir por el constructor de Fecha es garantizar la creación correcta del objeto. En este caso, si
no se cumplen las condiciones, el constructor ha decidido crear un objeto con valores
preestablecidos poco comunes (1/1/1880) que garanticen la integridad del mismo.

Estructura de control alternativa múltiple (switch case)
En la implementación del método díasMes() se puede apreciar cómo para diferentes

valores se toman distintas determinaciones, en casos donde sean muchos los valores resulta poco
legible el uso de los if anidados como se muestra en el siguiente ejemplo.
Ejemplo: implementar una variante del método díasMes() de la sección anterior donde se
invierta el orden de evaluación de los dos últimos casos más generales.
public int DíasMes()

{
if (mes == 4 || mes == 6 || mes == 9 || mes == 11)
return 30;
else
if (mes == 1 || mes == 3 || mes == 5 || mes == 7 ||
mes == 8 || mes == 10 || mes == 12)
return 31;
else
if (bisiesto( ))
return 29;
else
return 28;
}
Con el objetivo de hacer más legibles y claros los códigos de implementación de los
algoritmos donde se tienen múltiples casos, la mayoría de los lenguajes brinda una instrucción de
alternativa múltiple (switch case) cuya sintaxis se muestra seguidamente:
switch (<expresión>)
{
case <valor 1>: <bloque de instrucciones 1>
[break]
case <valor 2>: <bloque de instrucciones 2>
[break]

case <valor n>: <bloque de instrucciones n>
[break]
[default: <bloque de instrucciones default>
[break]]
}
La semántica de esta instrucción es muy simple: si al evaluarse <expresión> toma <valor
1> entonces se ejecuta <bloque de instrucciones 1>; si al evaluarse <expresión> toma <valor 2>
entonces se ejecuta <bloque de instrucciones 2> y así sucesivamente hasta <valor n>. De no
coincidir la evaluación con alguno de las valores predeterminados y existir la rama default (note
que es opcional), entonces se ejecutará <bloque de instrucciones default>. La instrucción break
es obligatoria excepto cuando exista una instrucción return en el respectivo bloque de
instrucciones. Este break indica que después de ejecutar el bloque de instrucciones que lo
precede se salta a la próxima instrucción después del switch.
Los valores indicados en cada rama del switch han de ser expresiones constantes que
produzcan valores de algún tipo básico entero, de una enumeración, de tipo char o de tipo string.
Además, no puede haber más de una rama con el mismo valor.
Para ejemplificar esta nueva estructura sintáctica se define a continuación una variante del
método díasMes()
int díasMes()
{
switch (mes)
{
case 4: return 30;
case 6: return 30;
case 9: return 30;
case 11: return 30;
case 2 : if (bisiesto( ))
return 29;
else
return 28;
default: return 31;
}

}
En el caso que varias ramas coincidan en sus respectivos bloques de instrucciones, éstas
se pueden agrupar como se muestra seguidamente, en una nueva versión del métdo:
int díasMes()
{
switch (mes)
{
case 4: case 6: case 9: case 11: return 30;
case 2 : if (bisiesto( ))
return 29;
else
return 28;
default: return 31;
}
Caso de estudio: clase Triángulo
A partir de la definición anterior de la clase Triángulo a partir de la longitud de sus lados.

Implementar un método clasifica() que permita obtener la clasificación de las respectivas
instancias en cuanto a las respectivas longitudes de los lados (equilátero, isósceles y escaleno).
Para implementar el algoritmo que determina la clasificación del triángulo es evidente que se
tiene un análisis de casos con tres subdominios: los tres lados iguales (equilátero), solamente dos
lados iguales (isósceles) y los tres lados diferentes (escaleno).
string clasifica()
{
if (lado1 == lado2 && lado2 == lado3)
return "Equilátero";
else
if (lado1 == lado2 || lado2 == lado3 || lado3 == lado1)
return "Isósceles";

else
return "Escaleno";
}
Estructuras de control iterativas
El objetivo de las estructuras de control iterativas es permitir la expresión de la repetición

de una secuencia de instrucciones, a estas estructuras se les denomina ciclo, lazo o bucle.
Estructura de control for
Uno de los ciclos más conocidos y usados es el basado en la instrucción for y que suele
estar controlado por un contador o variable de control y que tiene la siguiente sintaxis:
for (<instrucciones 1>; <expresión>; <instrucciones 2>)

<instrucciones>
La semántica de esta instrucción es la siguiente:
<instrucciones 1>; se ejecutará una sola vez al inicio del ciclo, generalmente se realizan
inicializaciones y declaraciones de variables.
<expresión>; es evaluada en cada ciclo y en dependencia del valor que devuelva, dependerá
que el bucle continúe ejecutándose (valor de la evaluación true) o no (false).
<instrucciones 2>; es ejecutado siempre en cada ciclo al terminar de ejecutar todas las
instrucciones que pertenecen al bucle for en cuestión. Por lo general puede contener
alguna actualización para las variables de control.
Ejemplo: Si pensamos en la clase Numero y definimos un método que

determine la sumatoria de números consecutivos del 1 hasta el campo num. num
Podemos escribir un método que use el ciclo For adecuamente, encontrando  i
cual es el segmento de código que debe repetirse: si partimos del número 1, i=1
generado a partir de un contador, este se acumula, y el proceso se respite
hasta llegar a num.

uint sumatoria1aN ()
{
int con; // variable local que se define para ir llevando el número a sumar
uint suma = 0.; // variable local que ira contabilizando el total sumado
for (con=1; con <= num ; ++con)

{
suma = suma + con;
}
return suma;
}
Estructura de control while

A veces no es posible saber de antemano el número de veces que se va a repetir la
ejecución de una posición de código mientras una cierta condición sea cierta. Para definir estos
ciclos condicionales es posible utilizar la estructura de control while cuya sintaxis es la siguiente:
while <condición>
<instrucciones>
Esta estructura de control permite realizar un bucle (<instrucciones>)

n
que se repetirá mientras la <condición> sea cierta, o dicho de otra manera, el
bucle terminará cuando la <condición> sea falsa. Cabe señalar que con esta  i+2
i=num
estructura la <condición> se chequea siempre al principio del bucle por lo que
si la primera vez que se evalúa <condición> es falsa, el ciclo no llegará
nunca a ejecutarse.
Ejemplo: siempre en la clase Numero, considere la suma de los números pares que van del
campo num a un número dado como parámetro al método.
uint sumatoriaNumAN ( int n)

{
int con=num +2; // variable local que se define para ir llevando el número a sumar

uint suma = 0.; // variable local que ira contabilizando el total sumado
while (con <= n)

{
suma = suma + con;
con = con + 2;
}
return suma;
}
Estructura de control do-while
La estructura de control do-while es otra sentencia de iteración en la que la condición se

evalúa por primera vez después de que las instrucciones del ciclo se hayan ejecutado. Esto quiere
decir que las sentencias del bucle do-while, al contrario que las del ciclo while, al menos se
ejecutan una vez.
La sintaxis de esta estructura es la siguiente:
do
<instrucciones>
while <condición>;
Ejemplo: Con base en la clase Número, vamos a diseñar un método que determine cuál es el
menor n que hace que 2n > num
int menor ( ) {
int potencia2 = 1; // variable que almacena las potencias de 2
int n = 0; // variable que irá contando las veces que se eleva a la potencia de 2
do
potencia = potencia * 2; // se calcula una nueva potencia
n ++; // se incrementa n

while (potencia < num) // mientras no se exceda a num se sigue calculando
return n;
}

Ejercicios
Tomando como base la clase Numero realice los siguientes métodos
1. Haga un método que determine si el número num es positivo.

2. Haga un método que devuelva el valor absoluto de num.
3. Haga un método que determine el factorial de num.
4. Haga un método que calcule y devuelva la suma de los divisores de num.
5. Haga un método que calcule y devuelva la suma de los divisores propios de num. Los
divisores propios de un número son todos los divisores mayores a 1 y menores al número.
6. Haga un método que determine si num es um número primo.
7. Haga un método que sume los números primos de 1 a num.
8. Haga un método que devuelva el número de dígitos de un núm.
9. Haga un método que sume los dígitos de num.

Clases contenedoras
Una clase contenedora como la palabra lo dice contiene un conjunto de datos del mismo
tipo.
En este apartado detallaremos clases que contienen una secuencia de valores del mismo
tipo (todos del mismo tipo, sin embargo el tipo puede ser cualquiera: tipos básicos u objetos),
siendo significativo el orden (posición en la secuencia) entre ellos.
En la mayoría de los lenguajes de programación la forma de representar las secuencias es

a través de arreglos (arrays). Los arreglos se utilizan cuando se necesita almacenar múltiples
valores del mismo tipo y con información relacionada.
Arreglos unidimensionales
Un arreglo unidimensional (también llamados vector.) es un tipo especial de variable que

es capaz de almacenar en su interior y de manera ordenada varios elementos de un determinado
tipo. Se entiende en este caso por orden, que cada elemento ocupa una posición, es decir, cada
uno tiene predecesor (exceptuando el primero) y sucesor (exceptuando el último).
De forma general para declarar un arreglo se colocan corchetes vacíos entre el tipo y el
nombre de la variable como se muestra a continuación:
<identificador de tipo> <identificador de variable> [<tamaño del arreglo> ];
Seguidamente se muestran algunas formas de declarar y a la vez inicializar arreglos para

representar secuencias:
int temperaturas [2]= {28, -5};
float notas [5] = {5, 4, 3, 4, 5};
double pesos [ 3]= {70.3, 60.1, 65.7};
char palabra [4]= {'H', 'o', 'l', 'a'};
string nombres [1]= {"Ana"};

Los arreglos utilizan semántica por referencia, las variables de arreglo guardan solamente
la referencia al bloque de memoria donde realmente se encuentran los valores. En la figura
siguiente se muestra una representación en memoria de los arreglos definidos e inicializados
anteriormente.
temperaturas 28 -5
notas 5 4 3 4 5
pesos 70.3 60 65.7
palabra 'H' 'o' 'l' 'a'
nombres “Ana”
Para acceder a los elementos de un arreglo se utilizan índices (variables enteras) como se
muestra a continuación, que se cambia el valor de la primera posición del arreglo temperatura:
temperaturas [0] = 45;
Es importante tomar en cuenta que el índice de los arreglos en lenguajes como C++
comienza en cero (0), esto significa que el primer elemento de un arreglo tendrá siempre índice
cero (0), mientras que el último elemento tiene como índice la longitud del mismo (cantidad de
elementos) menos uno.
El número de elementos del arreglo se indica en el momento de instanciarlo, esto puede

ocurrir en la misma declaración (ejemplos anteriores) o posteriormente a través del operador
new, utilizando punteros, sin embargo este tema no lo veremos en este curso, por lo que para
efectos del curso siempre definiremos su tamaño en la definición.
Luego de instanciado un arreglo, se puede acceder a cualquiera de sus elementos. La

instrucción clásica para acceder a los elementos de un arreglo es un ciclo for. No hay que olvidar
que la variable declarada como arreglo lo que contiene es una referencia al arreglo y es posible
usarla para acceder individualmente a cualquiera de los elementos, disponiendo del índice del
elemento al cual se desea acceder como ya se vio con anterioridad y para manipular este es que el
ciclo for se ajusta adecuadamente.
Los arreglos una vez creados son estáticos, es decir no pueden cambiar su tamaño.

Ahora bien si quiere definir una clase que contenga una secuencia de datos del mismo
tipo, se define entonces la clase contenedora.
En este ejemplo se define una clase contenedora con un arreglo de tamaño fijo, por
simplicidad, para trabajar métodos clásicos de manipulación de arreglos, con 3 constructores
diferentes como ejemplos y al ser la definición de vector privada, se definen métodos set y get
para usar las posiciones del arreglo cuando estas son accedidas desde el main() :
class Contenedor
{
private:
int vector[5];
public:
Contenedor (){ // constructor de inicializa las 5 posiciones con cero
for(int i=0;i<5;i++)
vector[i]=0;
}
Contenedor (int a){ // constructor que inicializa todas las posiciones con el valor
// recibido
vector[i]=a;
}
Contenedor (int a, int b,int c, int d,int e) {
vector [0]=a;
vector [1]=b;
vector [2]=c;
vector [3]=d;
vector [4]=e;
}
setPos(int i, int valor) {
vector [i]= valor;
}
getPos (int i) {
return vector[i];
}
};
int main()
{
Contenedor A;
Contenedor A1(5);
Contenedor B(4,6,8,9,2);
….
}

Como ejercicios se resolverán algunos métodos para esta clase y al final se verán en un
ejemplo completo de la clase:
1. Escriba un método que muestre los elementos del vector
void mostrar(){
for(int i=0;i<5;i++) // observe el uso de vector en métodos de la clase
cout<< "elemento "<<i<<" es: "<<vector [i]<<endl;
}
2. Escriba un método que devuelva la suma los elementos del vector.
int sumaVector(){
int suma = 0;
for (int i=0; i< 5; i++)
suma = suma + vector [i];
return suma;
}
3. Escriba un método que devuelva la media (promedio simple) de sus elementos

float media() {
int suma=0;
for(int i=0; i<5; i++)
suma = suma + vector[i];
return suma/5; // ¿división de enteros???
}
Otra forma de hacerlo:
float media() { // observe el llamado a métodos dentro de métodos de la clase

return (float) sumaVector()/5; // casting
}
4. Escriba un método que devuelva el valor o elemento máximo del vector.
int valorMax() {
int max = vec[0];
if (vec[i]>max) {
max=vec[i];
}
return max;
}

5. Escriba un método que retorne la posición del vector en el que se encuentra el valor máximo
int posMax() {
int pos=0;
int max=vector[0];
if (vector[i]>max) {
pos= i;
max=vector[i];
}
return pos;
}
Otra versión de este método es la siguiente, en esta hay menos variables, ¿será más difícil
de entender?:
int posMax(){
int pos=0;
for (int i=1; i<5; i++)
if (vector[i]>vector[pos]) {
pos= i;
}
return pos;
}
6. Ejercicio: escriba un método que devuelva el valor mínimo del vector y otro que devuelva la
posición en la cual ocurre el valor mínimo del vector.
7. Escriba un método que intercambie los valores máximo y mínimo del vector
void intercambiaMaxMin() {
int i,j, aux;
i = posMax(); // observe el llamado a métodos dentro de métodos de la clase
j = posMin();
aux= vector [i];
vector [i]=vector [j];
vector [j]=aux;
}
Otra forma de resolver el problema es la siguiente, de nuevo debe valorarse el uso de

variables y el llamado a métodos:
void intercambiaMaxMin(){
int aux;
aux = valorMax();
vector [posMax()] = valorMin();
vector [posMin()] = aux;
}
8. Escriba un método para invertir los elementos del vector, para realizarlo de manera más fácil
y modular, se diseña un método que invierte dos posiciones
void intercambiaPos ( int i, int j) {

int temp;
temp = vector [i];
vector [i] = vector [j];
vector [j]=temp;
}
Luego para intercambiar todo un vector se usará el método anterior, es importante

entender que para darle vuelta al vector, se debe llegar hasta la mitad del mismo, de la siguiente
manera:
void invierteVector() {
int k=4,i=0;
while (i<k ) {
intercambiaPos( i, k)
i++;
k--;
}
}
Otra versión haciendo uso de las ventajas del for de C:
void invierteVector(){
int k,i;
for(i=0,k=4; i<k; i++,k--) {
}
}
Finalmente, la clase Contenedor se verá de la siguiente manera:
class Contenedor
{
private:
int vector[5];
public:
Contenedor (){ // constructor de inicializa las 5 posiciones con cero

vector[i]=0;
}
Contenedor (int a){ // constructor que inicializa todas las posiciones con el valor
// recibido
vector[i]=a;
}
Contenedor (int a, int b,int c, int d,int e) {
vector [0]=a;
vector [1]=b;
vector [2]=c;
vector [3]=d;
vector [4]=e;
}
setPos(int i, int valor) {
vector [i]= valor;
}
getPos (int i) {
return vector[i];
}
void mostrar(){
for(int i=0;i<5;i++) // observe el uso de vector en métodos de la clase
cout<< "elemento "<<i<<" es: "<<vector [i]<<endl;
}
int sumaVector(){
int suma = 0;
for (int i=0; i< 5; i++)
suma = suma + vector [i];
return suma;
}
float media() { // observe el llamado a métodos dentro de métodos de la clase

return (float) sumaVector()/5; // casting
}
int valorMax() {
int max = vec[0];
for(int i=1; i<5; i++) {
if (vec[i]>max) {
max=vec[i];
}
}
return max;
}
int posMax(){
int pos=0;
for (int i=1; i<5; i++)
if (vector[i]>vector[pos]) {
pos= i;

}
return pos;
}
int valorMin() {
// ejercicio
}
int posMax(){
// ejercicio
}
void intercambiaMaxMin(){
int aux;
aux = valorMax();
vector [posMax()] = valorMin();
vector [posMin()] = aux;
}
void intercambiaPos ( int i, int j) {
int temp;
temp = vector [i];
vector [i] = vector [j];
vector [j]=temp;
}
void invierteVector(){
int k,i;
for(i=0,k=4; i<k; i++,k--) {
}
};
int main() {
Contenedor A;
Contenedor A1(5);
Contenedor B(4,6,8,9,2);
cout<<"Vector A : "<<endl;
A.mostrar();
cout<<”la suma de los elementos de B es:” << B.sumaVector()<<endl;
cout<<"El elemento máximo del vector B es: " << B.valorMax() << endl;
// note el acceso a métodos que devuelven un valor

cout<<"y ocurre en la posicion: " <<B.posMax()<<endl;
// note el acceso a métodos que no devuelven nada

cout<<"Intercambiando maximo y minimo en el vector B"<<endl;
B.intercambiaMaxMin();
B.invierteVector();
cout<<"El vector B invertido queda como: "<<endl;

B.mostrar();
system (“pause”);
El ejemplo anterior plantea un arreglo de tamaño fijo, como paso inicial para entender el
acceso a un arreglo, sin embargo este tipo de arreglos no es muy útil en situaciones de la vida
real, por eso que es necesario definir un arreglo que manteniendo las reglas de definición de C,
pueda adaptarse a distintos tamaños de arreglos, la estrategia será definir un arreglo de largo
máximo, y dependiendo de cada solución se definirá una cantidad y un tamaño según la
necesidad, obviamente todavía no es la solución óptima en eficiencia pues el excedente en
tamaño es desperdicio de memoria, pero se verá posteriormente una mejor estrategia, de nuevo
utilizando punteros, que no es tema del curso.
De esta forma definimos una nueva clase Contenedora:
#include <iostream>
class Contenedor {
private:
int vector[100]; // se define 100 como el máximo permitido
int tamano; // cada solución puede definir un tamaño diferente
int cantidad; // cantidad mantiene el número real de elementos al momento, nunca
// puede ser mayor a tamaño
public:
Contenedor ( ) {
cantidad=0;
tamano= 10;
for (int i=0;i< tamano;i++){
vector [i]=0;
}
}
Contenedor (int n) {
cantidad=0;
tamano= n;
for (int i=0; i< tamano; i++){
vector [i] = 0;
}
}
int setCantidad( int can){

cantidad = can;
}
int getCantidad(){
return cantidad;
}
int getTamano(){
return tamano;
}
void llenarRapido(){
for(int i=0; i < cantidad; i++){
vector[(cantidad-1)-i]= (cantidad%(i+1))*i+78;
// llena con números diferentes desde el final
}
}
int sumaVector(){
int acum=0;
for(int i=0;i< cantidad;i++){
acum=vector[i]+acum;
}
return acum;
}
void invierteVector(){ // sin usar vector auxiliar
int k,i, temp;
for(i=0,k=cantidad-1;i<k;i++,k--){
temp=vector[k];
vector[k] = vector[i];
vector[i]=temp;
}
}
void mostrar(){
cout<< "\t elemento "<<i<<" es: "<<vector [i]<<endl;
}
~Vector ( ) { }// toda la memoria es estática
};
Con la definición de esta clase vamos a trabajar otros métodos, dejando claro que pueden
resolverse con cualquiera de los dos esquemas, pero para efecto de usar un contenedor más
flexible, seguiremos usando esta nueva definición, y para ello resolveremos varios problemas:
1. Escriba un método que ingrese un elemento al vector

void ingresarElemento (int elem ) { //ingresa elem en la última posición
if (cantidad < tamaño) }
vector [cantidad] = elem; //cantidad establece la ultima posición vacía

setCantidad ( cantidad +1);
}
}
2. Escriba un método que elimine el último elemento del vector, en este caso se establece que
hay un elemento menos, aunque realmente sigue estando ahí, pero ningún método tendrá
acceso a él, pues todos están ajustados a la variable cantidad.
int eliminaElemento(){ // establece que hay un elemento menos y lo devuelve

setCantidad(cantidad-1);
return (vector[cantidad]);
3. Escriba un método que retorne la posición de un elemento determinado en el arreglo. Si el

elemento no se encuentra retorna -1.
int encuentraPosElemento(int elem) {

for (int i=0; i<cantidad; i++)
if (vector[i]==elem)
return i;
return -1;
}
4. Escriba un método que permita eliminar el elemento en la posición pos del arreglo.
void eliminarElementoPos (int pos) {

for (int i=pos;i<cantidad-1;i++)
vector[i]=vector[i+1];
setCantidad(cantidad-1);
}
5. Escriba un método que permita insertar el valor x en el lugar k-ésimo de un vector,

produciendo un corrimiento hacia la derecha de los restantes elementos.
void insertaElemPos (int elem, int pos) {

if (getCantidad() < getTamaño() && getCantidad()> pos) {
for (int i=cantidad; i>pos; i--)
vector[i] = vector[i-1]; //corrimiento a la derecha
vector[pos] = elem;
setCantidad (getCantidad() + 1);
}
}

De esta manera se podría definir un main() como el que sigue para probar los métodos
creados:
int main() { // úsenlo para probar los métodos

int num,cont,k,elem;
…… // se crea un contenedor Numeros con la cantidad de datos que de el usuario

cout<<"cuántos elementos desea agregar? ";
cin>>num;
Contenedor Numeros (num) ; // construimos un contenedor de num posiciones
cont=0;
while (Numeros.getCantidad()< Numeros.getTamano() && cont<num) {
cout<<"digite el valor del elemento "<<cont+1<<": ";
cin>>elem;
Numeros.InsertarElemento(elem);
cont++
}
cout<<"Contenedor original.."<<endl<<endl;
Numeros.mostrar();
cout<<"Eliminamos un elemento del contenedor.."<<endl;

elemento = Numeros.eliminaElemento();
cout<<"El elemento eliminado fue..."<<elemento<<endl<<endl;
cout<<"Y el contenedor quedaria..."<<endl<<endl;

Numeros.mostrar();
cout<<"que elemento desea buscar? ";

cin>>elem;
cout<<"el elemento "<<elem<<" se encuentra en la posicion "
<<Numeros.encuentraPosElemento(elem);
cout<<"Ahora invirtiendo el contenedor..."<<endl<<endl;

Numeros.invierteVector();
cout<<"Nos queda..."<<endl<<endl;
Numeros.mostrar();
cout<<"La suma de todos los elementos del contenedor nos da...";

cout<<"--->"<<Numeros.sumaVector()<<endl<<endl;
cout<<"Creando un nuevo contenedor..."<<endl<<endl;
Contenedor Numeros2();// construimos un vector de 10 posiciones
Numeros2.llenarRapido(); //llena el vector

Numeros2.mostrar();

cout<<"que posicion desea eliminar? ";
cin>>pos;
Numeros2.eliminarElementoPos(pos);
Numeros2.mostrar();
cout<<"que elemento desea insertar y en que posicion? ";

cin>>elem>>pos;
Numeros2.insertaElemPos (elem,pos);
Numeros2.mostrar();
system("pause");
return 0;
}
Búsqueda
La búsqueda de un objeto específico en una lista de objetos es un procedimiento muy

común. La forma más simple es buscar uno por uno hasta encontrar el elemento deseado.
bool buscar ( int elem) {

for (int i = 0; i <cantidad; i++)
if (vector[i] == elem)
return true;
return false;
}
Si el elemento no está en el arreglo no se sabe hasta que no se recorra todo el arreglo

completo. De esta manera, si los arreglos fueran muy grandes, de millones de elementos, las
búsquedas son métodos muy costosos en tiempo, y poco eficaces si los elementos no se
encuentran, es por eso que se ha estudiado mucho acerca de métodos de búsqueda, en este curso
se verán algunos de ellos.
Ejemplo: ¿Qué sucede si se tiene el arreglo de objetos ordenado ascendentemente?
Si el arreglo está ordenado ascendentemente se puede saber sin recorrerlo si el objeto no

está con solo chequear si es menor que el primer elemento ó mayor que el último. Además en
caso de que el elemento pudiera estar en el arreglo solo habría que recorrerlo mientras el objeto
buscado sea mayor que el de la posición actual. Si en algún momento llega a ser menor entonces
se puede concluir que no está en el arreglo.

bool buscarOrdenado (int elem) {
if (elem < vector[0] || elem > vector [cantidad - 1])
return false;
else {
int i = 0;
while (i < cantidad && elem >= vector [i])
if (vector [i++] == elem) //analice el resultado de i++
return true;
return false;
}
}
Búsqueda binaria
Un algoritmo de búsqueda muy interesante en arreglos ordenados es la búsqueda binaria,

que consiste en tomar el objeto que ocupa en el arreglo la posición del medio (si la cantidad de
objetos es impar se toma el que ocupa la posición mitad - 1), si el objeto que se busca es mayor
entonces hay que buscarlo en la mitad de la derecha (queda claro que no puede estar en la otra
mitad) y si es menor en la mitad de la izquierda. Este proceso se repite hasta encontrar el número
o concluir que no está. Es claro que este algoritmo es más eficiente, pues reduce la búsqueda a la
mita, pero requiere un arreglo ordenado.
Si se busca el número 7 en la secuencia { 2, 4, 7, 8, 10, 12, 13} los pasos serían:
Intervalo de búsqueda
vector 2 4 7 8 10 12 13
0 1 2 3 4 5 6
elem 7
IZQ DER
MED = ( IZQ + DER) / 2

= (0 + 6 ) / 2 = 3

Tomar el 8 y compararlo con el 7, como el 8 es mayor hay que buscarlo en la parte
izquierda del arreglo.
Valores 2 4 7 8 10 12 13
0 1 2 3 4 5 6
Elem 7
IZQ DER

= (0 + 2 ) / 2 = 1
Tomar el 4 y compararlo con el 7, como el 4 es menor hay que buscarlo hacia la derecha.
Valores 2 4 7 8 10 12 13
0 1 2 3 4 5 6
Elem 7
IZQ DER

= (2 + 2 ) / 2 = 2
Tomar el 7 y compararlo con el 7, luego el 7 está en el arreglo
En este esquema de búsqueda se realiza siempre la misma acción que es buscar el número
en un intervalo que varía en dependencia de si el número buscado sea mayor o menor que el que
ocupa la posición del medio.
El algoritmo cuenta con dos condiciones de término o fin, la primera que se encuentre el
número y la segunda que el número no esté (esta condición se puede cumplir analizando que el
intervalo en el que hay que buscar tenga longitud positiva).

Una versión no recursiva del mismo algoritmo puede verse a continuación:
public bool BusquedaBinaria(int elem) {

int mitad;
int ini=0;
int fin = cantidad -1 ;
while (inic <= fin) {
mitad = (inic + fin ) / 2;
if (elem == vector [mitad])
return true;
else
if (elem > vector [mitad])
inic = mitad+1;
else
fin = mitad -1;
}
return false;
}
Ordenamiento
El proceso de ordenar una lista de elementos ascendente o descendentemente es

fundamental y se realiza con mucha frecuencia en la solución de problemas.
Cuando se habla de ordenar lo primero que viene a la mente es ordenar números, pero en
la vida diaria ordenamos distintos tipos de objetos siguiendo diversos criterios.
Por ejemplo las palabras mesa, computadora y artista se pueden ordenar por orden
alfabético
artista, computadora y mesa
o por su longitud
mesa, artista y computadora
Se verán en este curso los métodos o algoritmos más comúnmente usados, para que el
estudiante se haga una idea del proceso que llevan a cabo cada uno de ellos.
Ordenamiento por burbujas
El método más usado para ordenar listas de elementos no demasiado grandes es el método
de burbujas. La idea básica que hay detrás del nombre es imaginar que el arreglo a ordenar se

coloca verticalmente y que los objetos menos “pesados” suben más rápidamente hacia el tope del
arreglo como las burbujas menos pesadas lo hacen a la superficie.
Se hacen repetidos pases sobre el arreglo desde el final hacia el principio. Si dos objetos
adyacentes están desordenados entonces se intercambian de posición. El efecto de esta operación
es que en el primer pase el objeto menos “pesado” es llevado hacia la primera posición; en el
segundo pase, el segundo objeto menos pesado (que no es más que el menos “pesado” de los que
quedan) es llevado a la segunda posición. De forma general en el pase i-ésimo, el i-ésimo objeto
menos “pesado” es llevado a la posición i.
A continuación se presenta el código que lleva a cabo el proceso descrito, en el mismo se

ordena un arreglo de enteros.
void burbujas () {
int aux;
for (int i = 0; i <= cantidad - 2; i++)
for (int j = cantidad - 1; j >= i+1; j--) {
if (vector[j] < vector[j-1]) {
aux= vector [j]
vector [j]= vector [j-1]
vector [j-1]=aux
}
}
}
A medida que la i va avanzando el arreglo va quedando ordenado hasta la posición i -1 y a

medida que la j va decreciendo se va llevando el menor valor de los que quedan hasta la posición
i, por eso se asemeja a las burbujas porque los valores mayores van subiendo.
Si se aplica el método de burbujas para ordenar los números {8, 4, 5, 9, 7, 2} se puede ver
en la figura como queda el arreglo después de cada pasada, la línea indica que los elementos que
están por encima de ella ya están ordenados y en su posición.
A pesar de ser 6 elementos el número de pasadas es 5 porque después de ubicar los 5

menores en sus respectivas posiciones no queda otra opción para el mayor que no sea la última, la
misma lógica del algoritmo va llevando el mayor elemento a la última posición del arreglo. Mire
el arreglo verticalmente.

8 2 2 2 2 2
4 8 4 4 4 4
5 4 8 5 5 5
9 5 5 8 7 7
7 9 7 7 8 8
2 7 9 9 9 9
Inicio i =1 i =2 i =3 i =4 i =5
Ordenamiento por inserción
Un segundo esquema de ordenación es el llamado método de inserción que tiene su

fundamento en el siguiente planteamiento: Si se tiene una secuencia de n elementos a1 , a2 , ….. ,
an de forma tal que a1 <= a2 <= ….. <= an , es decir, ordenados de menor a mayor, e insertamos
un elemento ak en una posición tal que ai <= ak <= ai+1 para algún i (1 <= i <= n) entonces la
nueva secuencia a1, a2 , …, ai , ak , ai+1....., an sigue estando ordenada.
Basado en esto el método comienza tomando el segundo elemento e insertándolo en su

correspondiente posición en la secuencia formada por el primer elemento, esto se logra
intercambiando el segundo elemento con el primero en caso de que estén desordenados; después
toma el tercer elemento y lo inserta en la secuencia formada por los dos primeros elementos (la
cual ya está ordenada) realizando tantos intercambios como sean necesarios. De forma general el
método inserta el i-ésimo elemento en la secuencia formada por los i-1 elementos anteriores, los
cuales ya están ordenados.
A continuación se muestra el código que lleva a cabo el algoritmo descrito.
void insercion () {
int aux;
for (int i = 1; i <= cantidad - 1; i++) {
int j = i ;
while ( j >= 1 && vector [j] < vector[j-1]) {
aux= valores[j]
vector [j]= vector [j-1]

vector [j-1]=aux
j = j – 1;
}
}
}
A continuación se muestra el método de inserción aplicado a la secuencia de números de

la sección anterior.
8 4 4 4 4 2
4 8 5 5 5 4
5 5 8 8 7 5
9 9 9 9 8 7
7 7 7 7 9 8
2 2 2 2 2 9
Inicio i =2 i =3 i =4 i =5 i =6
Ordenamiento por selección
Es uno de los algoritmos más intuitivos de ordenamiento. Consiste en lo siguiente: si el

vector consta de «cantidad» de elementos, encuentre el elemento de menor valor e intercámbielo
con la posición 0, luego tome el menor elemento a partir de la posición 1 e intercámbielo con el
de la posición 1 y así sucesivamente hasta intercambiar el menor elemento entre la posición
«cantidad-1» y «cantidad» y ubicarlo en la posición «cantidad-1». De esta manera al final usted
tendrá el arreglo ordenado.
El método es el siguiente:
void ordenaSeleccion() {
int i, k, posMenor, temp;
for(k = 0; k < cantidad-1; k++) {
posMenor = k;
for(i = k+1; i < cantidad; i++) {
if(vector [i] < vector [posMenor]) {
posMenor = i;
if (posMenor != k) { // intercambio
temp = vector [posMenor];
vector [posMenor] = vector [k];
vector [k] = temp;
}
}
}
}
}

Arreglos bidimensionales
Los arreglos descritos anteriormente, en los que se puede acceder a sus elementos
utilizando un solo índice se denominan arreglos unidimensionales, vectores o de una sola
dimensión. De la misma forma, si se tiene más de un índice, se denominan arreglos
multidimensionales.
Un arreglo multidimensional es un arreglo donde los elementos se encuentran organizados

en varias dimensiones. Para su definición se usa una sintaxis similar a la usada para declarar
arreglos unidimensionales pero separando las diferentes dimensiones por comas. En lo particular
un arreglo bidimensional es un arreglo de dos dimensiones, conocido comúnmente como matriz.
Tómese como ejemplo la siguiente tabla que representa una abstracción o simulación de
cómo se pudiesen representar los arreglos bidimensionales, aunque realmente en memoria no se
representan de esa forma, en general se conocen como arreglos con filas (horizontales) y
columnas (verticales).
columnas
1 2 3
filas
4 5 6
De forma análoga a los arreglos unidimensionales, para declarar un arreglo bidimensional

se colocan corchetes luego del nombre de la variable, sin embargo, ahora estos corchetes separan
entre ellos el tamaño de las filas y las columnas:
<identificador de tipo> <identificador de variable> [ <tam. filas>][ <tam. columnas> ];
A continuación se muestran algunas formas de declarar e inicializar arreglos

bidimensionales:
int tabla [4][2];
int tabla [3][3]= {{1,2,3}, {4,5,6}};

float matriz [3][2];
char tabla1[6][10];
Se define entonces una nueva clase Contenedora,
const int tam=4; // se define para el tamaño de la matriz
class Contenedor{
private:
int matriz[tam][tam];
public:
Contenedor (){ // constructor predefinido
for (int i = 0; i<tam; i++)
for (int j = 0; j<tam ; j++)
matriz[i][j]=0;
}
Contenedor (int a){ // constructor para inicializar todas las posiciones con el valor a
matriz[i][j]= a;
}
void setPos (int i, int j, int valor) {

matriz[i][j] = valor;
}
int getPos (int i, int j) {

return matriz[i][j];
}
void llenarMatriz() {
int valor;
for (int i = 0; i<tam;i++)
for (int j = 0; j<tam;j++) {
cout<<"valor["<<i<<"]["<<j<<"]: ";
cin>>valor;
setPos(i,j,valor);
}
~Matriz() { // memoria estática }

};
int main(){
Contenedor mat1;
Contenedor mat2(5);
cout<<"Llenando la matriz"<<endl;
mat1.llenarMatriz();
}
Ejemplos:
Se escribirán distintos métodos para comprender adecuadamente el manejo de arreglos de

dos dimensiones:
1. ¿Cómo mostrar el contenido de la variable en el formato acostumbrado para una matriz? En

este caso es necesario conocer cómo acceder al elemento (i,j); para ello se utilizan índices de
forma similar a los arreglos unidimensionales sólo que ahora se utiliza un índice por cada una
de las dimensiones i,j.
void mostrar()
for (int i = 0; i<tam;i++) {
cout<<matriz[i][j]<<" ";
}
cout<<endl;
}
cout<<endl;
}
2. Escriba un método que devuelva la suma de todos los elementos de la matriz.
int suma() {
int suma = 0;
for (int j = 0; j<tam;j++)
suma = suma + matriz[i][j];
return suma;
}
3. Escriba un método que calcule el promedio de todos los elementos de la matriz.
float promedio() {
return (float) suma() / (tam*tam); // casting
}
4. Escriba un método que multiplique todos los elementos de la matriz por un escalar (recibido
como parámetro)

void multiplicarEscalar (int escalar){
matriz[i][j] = matriz[i][j] *escalar;
}
5. Escriba un método que reciba como parámetro int elem y que retorne true si un elemento
determinado se encuentra en la matriz y false si no.
bool encuentraElem (int num) {

for(int i = 0;i <tam;i++) {
for(int j = 0;j <tam;j++)
if (matriz[i][j]== num)
return true;
}
return false;
}
6. Escriba un método que retorne el mayor valor de la matriz.

int buscaMaximo() {
int max = matriz[0][0]; // estrategia: suponga el primero es el mayor
for (int i = 0;i <tam;i++) {
for (int j = 0;j <tam;j++)
if (matriz[i][j] > max)
max=matriz[i][j];
}
return max;
}
7. A la suma de los elementos de la diagonal principal de una matriz cuadrada se le llama traza
de la matriz. Escriba un método que calcule la suma de los elementos de la diagonal principal
de la matriz.
int sumaDiagonal(){
int i = 0, suma=0;
for (i=0; i< tam; i++){
suma = suma + matriz[i][i];
}
return suma;
}
8. Una matriz se dice que es la matriz identidad si tiene todos sus elementos nulos excepto los
de la diagonal principal que son iguales a 1. Escriba un método que retorne true si la matriz
es la matriz identidad y false si no.

bool esIdentidad() {
for(int i=0;i<tam;i++) {
for(int j=0;j<tam;j++) {
if (i == j) {
if (matriz[i][j] != 1)
return false;
}
else {
return false;
}
}
}
return true;
}
9. Una matriz A de tamaño mxn se dice que es una matriz simétrica si:
m=n y
si cumple que A [x][y] = A[y][x] para 1<= x<= m y 1<= y <= n.
Escriba un método que determine si la matriz es simétrica o no.
bool esSimetrica() {
for(int j = 0;j < i ;j++)
if (matriz[i][j]!=matriz[j][i])
return false;
}
return true;
}
10. Escriba un método que busque un elemento determinado en una matriz e indique cuantas
veces lo encuentra.
int cuentaElem(int elem) {

int cont=0;
for(int i = 0;i <tam;i++){
if (matriz[i][j]== elem)
cont++;
}
return cont;
}

11. Escriba un método que retorne la posición del elemento menor de una matriz. Como se ha
estudiado un método solo puede devolver un valor, pero en este caso se requiere devolver una
posición que consta de un número de fila y un número de columna, es decir dos valores, por
lo que se usará la estrategia de definirlos como parámetros por referencia, es decir como
parámetros de entrada y salida.
void buscaPosMinimo (int &fil, int &col) {

int min=matriz[0][0]; // estrategia común
fil=0;
col=0;
if (matriz[i][j] < min) {
min=matriz[i][j];
fil=i;
col=j;
}
}
}
12. Defina un método que calcule la suma de los elementos de la diagonal inversa de la matriz.
int sumaDiagonalInversa(){
int suma=0;
for (int i=0; i<tam; i++)
suma = suma + matriz[i][(tam-1)-i];
return suma;
}
De esta manera, la clase contenedora completa sería:
const int tam=4; // se define para el tamaño de la matriz

class Contenedor{
private:
int matriz[tam][tam];
public:
matriz[i][j]=0;
}

matriz[i][j]= a;
}

}

}
int valor;
cout<<"valor["<<i<<"]["<<j<<"]: ";
cin>>valor;
setPos(i,j,valor);
}
void mostrar()
for (int i = 0; i<tam;i++) {
}
cout<<endl;
}
cout<<endl;
}
int suma() {
int suma = 0;
return suma;
}
float promedio() {
return (float) suma() / (tam*tam); // casting
}
void multiplicarEscalar (int escalar){
matriz[i][j] = matriz[i][j] *escalar;
}
bool encuentraElem (int num) {
if (matriz[i][j]== num)
return true;

}
return false;
}
int buscaMaximo() {
int max = matriz[0][0]; // estrategia: suponga el primero es el mayor
for (int i = 0;i <tam;i++) {
for (int j = 0;j <tam;j++)
if (matriz[i][j] > max)
max=matriz[i][j];
}
return max;
}
int sumaDiagonal(){
int i = 0, suma=0;
for (i=0; i< tam; i++){
suma = suma + matriz[i][i];
}
return suma;
}
bool esIdentidad() {
for(int i=0;i<tam;i++) {
for(int j=0;j<tam;j++) {
if (i == j) {
return false;
}
else {
return false;
}
}
}
return true;
}
bool esSimetrica() {
for(int j = 0;j < i ;j++)
if (matriz[i][j]!=matriz[j][i])
return false;
}
return true;
}
int cuentaElem(int elem) {
int cont=0;
for(int i = 0;i <tam;i++){
if (matriz[i][j]== elem)
cont++;

}
return cont;
}
void buscaPosMinimo (int &fil, int &col) {
int min=matriz[0][0]; // estrategia común
fil=0;
col=0;
if (matriz[i][j] < min) {
min=matriz[i][j];
fil=i;
col=j;
}
}
}
int sumaDiagonalInversa(){
int suma=0;
for (int i=0; i<tam; i++)
suma = suma + matriz[i][(tam-1)-i];
return suma;
}
~Matriz() { // memoria estática }
};
int main(){
int valor, x,y;
Contenedor mat1;
Contenedor mat2(5);
cout<<"Llenando la matriz"<<endl;
mat1.llenarMatriz();
cout<<"La suma de los valores de la matriz es "<<mat1.suma()<<endl;

cout<<"El promedio de los valores de la matriz es "<<mat1.promedio()<<endl;
cout<<"Digite el valor por el que desea multiplicar la matriz ";

cin>>valor;
mat1.multiplicarEscalar(valor);
mat1.mostrar();
cout<<"Digite el elemento que desea buscar ";

cin>>valor;
if (mat1.encuentraElem(valor))
cout <<"El valor " <<valor<<" SI se encuentra en la matriz "<<endl;
else
cout <<"El valor " <<valor<<" NO se encuentra en la matriz "<<endl;

cout<<"El valor maximo de la matriz es "<<mat1.buscaMaximo()<<endl;
cout<<"La suma de la diagonal es "<<mat1.sumaDiagonal()<<endl;
if (mat1.esIdentidad())
cout <<"La matriz SI es la matriz identidad "<<endl;
else
cout <<"La matriz NO es la matriz identidad "<<endl;
if (mat1.esSimetrica())
cout <<"La matriz SI es simetrica "<<endl;
else
cout <<"La matriz NO es simetrica "<<endl;
cout<<"Digite el valor que desea contar ";

cin>>valor;
cout<<"El valor "<<valor<<" se encuentra "<<mat1.cuentaElem(valor)<<" veces"<< endl;
mat1.buscaPosMinimo(x,y);
cout<< "La posicion del valor minimo en la matriz es ["<<x<<"]["<<y<<"]"<<endl;
cout<<"La suma de la diagonal inversa es "<<mat1.sumaDiagonalInversa()<<endl;
Todos los ejercicios se han trabajado con una matriz cuadrada, es decir de tam* tam, sin
embargo se puede hacer un cambio pequeño pero significativo en el cual los ejercicios pueden
adaptarse a matrices que no son cuadradas, por ejemplo definir como constantes fil =n y col =m,
con n y m números enteros definidos. Veamo un ejemplo de clase contenedora definida de esta
manera, con uno de los métodos resueltos anteriormente, se dejará el main() como ejercicio, por
no tener mayor dificultad:
const int fil=3; // se define para el tamaño de las filas de la matriz

const int col=4; // se define para el tamaño de las columnas de la matriz
class Contenedor{
private:
int matriz[fil][col];
public:
for (int i = 0; i<fil; i++)
for (int j = 0; j<col ; j++)
matriz[i][j]=0;
}
for (int i = 0; i<fil; i++)
for (int j = 0; j<col ; j++)
matriz[i][j]= a;
}
}
}
int valor;
for (int i = 0; i<fil;i++)
for (int j = 0; j<col;j++) {
cout<<"valor["<<i<<"]["<<j<<"]: ";
cin>>valor;
setPos(i,j,valor);
}
void mostrar()
for (int i = 0; i<fil;i++) {
for (int j = 0; j<col;j++) {
}
cout<<endl;
}
cout<<endl;
}
int suma() {
int suma = 0;
for (int i = 0; i<fil;i++)
for (int j = 0; j<col;j++)
return suma;
}
…continúa como ejercicio para el estudiante.

Referencias Bibliográficas
Booch, G. (1996).Análisis y Diseño Orientado a Objetos con Aplicaciones. México :Editorial

Addison Wesley Logman, 2 da edición,.
Greiff W. R. (1994). Paradigma vs Metodología: El Caso de la POO (Parte II). Soluciones

Avanzadas. Ene-Feb pp. 31-39.
Jacobson, I. (1998). Applying UML in The Unified Process. Presentación. Rational Software.
Presentación disponible en http://www.rational.com/uml como UMLconf.zip
Joyanes, Luis. (1996). Programación Orientada a Objetos. México: McGraw-Hill.
Martín, J.; Odell, J. (1994). Análisis y Diseño Orientado a Objetos. Editorial Prentice Hall, 1era
edición, México.
Rodríguez, O. (1997). C ++ para ambientes gráficos. Costa Rica:Editorial Tecnológica de

Costa Rica, 1era edición.
Rumbaugh,J., Jacobson, I., Booch, G. (2000) El Lenguaje Unificado de Modelado. Manual de

Referencia. Madrid: Addison Wesley.
Wikipedia. [En línea] Recuperado de http://es.wikipedia.org/wiki/Objeto

Guía para Estudiantes: Introducción A La Programación Por Objetos

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Guía para Estudiantes: Introducción A La Programación Por Objetos

Cargado por

Copyright:

Formatos disponibles

Introducción a

Master Sonia Mora Rivera

1 Guía estudiantes Fundamentos de Informática Mora, Coto,Caamaño y Vargas

3 Guía estudiantes Fundamentos de Informática Mora, Coto,Caamaño y Vargas

Este documento plantea una forma de introducir el paradigma de programación por

Mag. Sonia Mora Rivera

5 Guía estudiantes Fundamentos de Informática Mora, Coto,Caamaño y Vargas

El desarrollo actual tecnológico impone que los informáticos conozcan distintos

La POO como paradigma es una postura ontológica: el universo computacional está

Se debe distinguir que la POO como paradigma (enfoque o manera de visualizar la

La Programación Orientada a Objetos desde el punto de vista computacional "es un

 Es un paradigma de programación que se basa en la representación de todo aquello que

 Nace de la necesidad de modelar el mundo lo más real que se pueda.

6 Guía estudiantes Fundamentos de Informática Mora, Coto,Caamaño y Vargas

Según (Booch, 1986) los beneficios del enfoque OO son:

Se pueden mencionar algunas otras ventajas:

7 Guía estudiantes Fundamentos de Informática Mora, Coto,Caamaño y Vargas

Para entender el concepto de objeto, usaremos el entorno y el conocimiento mismo que

1. “...cualquier cosa, real o abstracta, acerca de la cual, almacenamos datos y los

2. “Un objeto es un concepto, abstracción o cosa con un significado y límites claros en

4. Un objeto es una representación detallada, concreta y particular de un "algo". Tal

5. Es un concepto o entidad con límites bien definidos y con significado para un

Luego de estas definiciones, es importante ejercitar el concepto, de ahí que le proponemos

8 Guía estudiantes Fundamentos de Informática Mora, Coto,Caamaño y Vargas

Tabla 1. Lista de objetos reales e imaginarios.

La siguiente definición no es original del paradigma de OO, pero para efecto de ir

A continuación en la Tabla 2 algunos ejemplos más, es importante hacer notar que la

9 Guía estudiantes Fundamentos de Informática Mora, Coto,Caamaño y Vargas

Tabla 2. Lista de objetos simples y complejos. Elaboración propia

Objetos simples Objetos complejos

10 Guía estudiantes Fundamentos de Informática Mora, Coto,Caamaño y Vargas

Veamos un ejemplo: piense en un perro. Usted tiene el concepto claro, pensará en un

El ejemplo anterior pretende establecer los atributos y características propias de un objeto

11 Guía estudiantes Fundamentos de Informática Mora, Coto,Caamaño y Vargas

El estado de un objeto se define como:

Pero este objeto podría cambiar su estado en otro momento, a

Los objetos de comunican entre ellos mediante el paso de mensajes:

Un objeto se comunica con objetos de su misma clase o apariencia, mediante canales de

Interacción entre objetos de la Canal entrada Canal salida

13 Guía estudiantes Fundamentos de Informática Mora, Coto,Caamaño y Vargas

Tabla 4. Interacción entre objetos de distinto tipo. Elaboración propia.

Objetos que no son Canal entrada Canal salida

Para tener una mejor idea de la conceptualización y la comunicación entre objetos

14 Guía estudiantes Fundamentos de Informática Mora, Coto,Caamaño y Vargas

Siguiendo con la historia: el hijo no encuentra aspirinas en el botiquín y decide acudir a la

La interfaz de un objeto es la manera en que me comunico con el objeto a través de

15 Guía estudiantes Fundamentos de Informática Mora, Coto,Caamaño y Vargas

Fuente: Theme Hospital, Wikipedia

Tabla 5. Listado de grupos de objetos.

Fuente: Elaboración propia

16 Guía estudiantes Fundamentos de Informática Mora, Coto,Caamaño y Vargas

Es el proceso de identificar y representar las características indispensables de un objeto,

Es la caracterización de un objeto de acuerdo a las propiedades que nos interesen en un

A continuación imágenes clásicas que muestran gráficamente el significado de la

Fuente: (Booch, 1996)

17 Guía estudiantes Fundamentos de Informática Mora, Coto,Caamaño y Vargas

Fuente: (Booch, 1986)

En los siguientes ejemplos ejercite la habilidad de establecer las características más

Tabla 6. Objetos y sus características.

Persona (enfermo) (signos vitales, tratamiento, reposo, observación).

Persona (atleta) (alimentación, fuerza, resistencia, performance.

Persona (novia o novio) (nombre, dirección habitación, sentimientos, plata).