58947061 Introduccion POO

El índice de rendimiento académico es la valoración cuantitativa del logro del

que!QUÉ???estudiante y se obtiene multiplicando la última calificación definitiva obtenida en

cada asignatura por el número de créditos

que le corresponda, se suman los productos obtenidos y este resultado se divide entre la suma de los créditos computados...Voy con Objetos y C++ta’ fácil ! ... multiplico cada nota con sus créditos, sumo los resultados y luego divido entre la suma de sólo

los créditos...

Qué buena Abstracción!...Programa

- Orientado+ Objetos

Reglamento de Evaluación del DCyT

Universidad Centroccidental“Lisandro Alvarado”

Sistema de Educación a DistanciaDecanato de Ciencias y Tecnología

GUÍA DIDA CTICA

Introducción a la Programación Orientada a Objetos con C++

Profesor Giovanni TorrealbaBarquisimeto, Octubre 2010



Datos de IdentificaciónElaborado por: Profesor Giovanni TorrealbaCorreo-electrónico: [email protected] Elaboración: Octubre 2010Fecha de Última Actualización: Octubre 2010

Profesor Giovanni Torrealba

TABLA DE CONTENIDO Pág

Guía Didáctica: Introducción a la Programación Orientada a Objetos con C++


1 INTRODUCCIÓN........................................................................1



2 ESTRATEGIAS DE ENSEÑANZA EN ESTA GUÍA DIDÁCTICA.....................3



2.1 Filosofía para la transmisión del conocimiento........................................................................3



2.1.1 Referencias cruzadas...............................................................................................................3



2.1.2 Imágenes alusivas......................................................................................................................3



2.1.3 Otras estrategias de organización de la guía.....................................................................4



2.2 Ejercicios por tópico......................................................................................................................4



2.3 Tablas resumen y/o comparativas..............................................................................................5



2.4 Mapas mentales...............................................................................................................................5



3 CONOCIMIENTOS PRELIMINARES...................................................7



3.1 Creación de programas..................................................................................................................7



3.2 Funciones...........................................................................................................................................8



3.2.1 Implementación de una Función.............................................................................................8



3.2.2 Parámetros de una función......................................................................................................9



3.2.3 Tipos de parámetros según lo que retornan.......................................................................9



3.2.4 Tipos de parámetros según su ubicación............................................................................10



3.2.5 Ejemplos de funciones.............................................................................................................11



3.3 Estado de la memoria en una ejecución...................................................................................12



3.4 Corridas en frío.............................................................................................................................13



3.5 Depuración de programas............................................................................................................16



3.5.1 Cómo activar la depuración de un programa con DevC++...............................................16



3.5.2 Comenzar a depurar un programa........................................................................................17



3.5.3 Depurar paso a paso su programa........................................................................................17



3.5.4 Observar el valor de variables y miembros de clases....................................................18



3.5.5 Entrar en el código de subrutinas, funciones o métodos..............................................19



3.5.6 Otras opciones de depuración..............................................................................................20



3.5.7 Aprovechar las herramientas de depuración...................................................................20



3.6 Sintaxis de comandos de programación..................................................................................20



3.6.1 Ejemplos de sintaxis de comandos en C++.........................................................................21



3.7 Métricas de programación: legibilidad del código................................................................22



3.8 Entrada de datos desde archivos.............................................................................................24



3.8.1 Manipulación de Archivos......................................................................................................24



3.8.2 Archivos de texto...................................................................................................................25



3.8.3 Apertura y lectura de archivos...........................................................................................25



3.8.4 Funciones de control...............................................................................................................26



4 CONCEPTUALIZACIÓN DE PROGRAMACIÓN ORIENTADA A OBJETOS (POO)..29



4.1 ¿Qué es la Programación Orientada a Objetos?..................................................................29



4.1.1 Ejemplo de otros paradigmas de programación:.............................................................29



4.1.2 Ejercicios resueltos y propuestos......................................................................................30



4.2 Clases, instancias y objetos.......................................................................................................30



4.2.1 Ejercicios resueltos y propuestos.......................................................................................31



4.3 Composición de los objetos.........................................................................................................31



4.3.1 Atributos...................................................................................................................................32



4.3.2 Métodos.....................................................................................................................................32



4.3.3 Ejemplos de Objetos..............................................................................................................33



4.4 Lenguajes Orientados a Objetos..............................................................................................35



4.5 Pilares de la Programación Orientada a Objetos.................................................................38



4.5.1 Abstracción...............................................................................................................................38



4.5.2 Encapsulamiento.......................................................................................................................40



4.5.3 Herencia.....................................................................................................................................40



4.5.4 Polimorfismo.............................................................................................................................42



5 IDENTIFICACIÓN DE OBJETOS.....................................................47



5.1 Técnicas para identificar objetos y componentes...............................................................48



5.2 Ejemplificación de requerimientos..........................................................................................49



5.3 Equivalencias entre ejemplificación tabulada y POO...........................................................51



5.4 El control remoto de los objetos..............................................................................................52



5.5 Ejercicios resueltos y propuestos............................................................................................55



6 REPRESENTACIÓN DE CLASES.......................................................61



6.1 UML...................................................................................................................................................61



6.2 Notación gráfica de clases con UML........................................................................................61



6.3 Relaciones entre clases - Diagramas de clases.....................................................................63



6.4 Paso de mensajes..........................................................................................................................63



7 OBJETOS EN C++.....................................................................67



7.1 Batería de ejercicios resueltos................................................................................................67



7.2 Estructura de un POO con C++..................................................................................................67



7.3 Interfaz e implementación de clases......................................................................................68



7.3.1 Interfaz de clases con C++...................................................................................................68



7.3.2 Implementación de clases con C++......................................................................................70



7.4 El programa principal y su compilación....................................................................................71



7.5 Acceso a los datos de una clase................................................................................................73



7.5.1 Constructores y destructores.............................................................................................74



7.5.2 Sobrecarga de métodos.........................................................................................................75



7.5.3 Setters (Sets) y Getters (Gets).........................................................................................75



7.6 Integración de los componentes del proyecto con POO y DevC++..................................77



7.7 Demostración paso a paso: crear un POO con DevC++........................................................79



7.8 Recomendaciones para la identificación de errores al compilar......................................80



7.8.1 Metodología para corregir errores de compilación con Devc++...................................81



7.8.2 Algunos errores típicos que reporta el Lenguaje C++.....................................................81



8 METODOLOGÍA PARA EL ANÁLISIS Y PROGRAMACIÓN ORIENTADA A OBJETOS...............................................................................87



8.1 Justificación de la necesidad de una metodología...............................................................88



8.2 Demostración de la aplicación de la metodología.................................................................89



8.3 Ejemplos de programas orientados a objetos.......................................................................91



8.4 Ejercicios propuestos..................................................................................................................93



9 RESPUESTAS A EJERCICIOS PROPUESTOS........................................95



9.1 Planteamientos del tópico 4.1.2.................................................................................................95



9.3 Planteamientos del tópico 4.3.4................................................................................................96



9.5 Planteamientos del tópico 4.5.5................................................................................................98



9.6 Planteamientos del tópico 5.5..................................................................................................100



9.9 Planteamientos del tópico 8.4...................................................................................................111



10 BIBLIOGRAFÍA.......................................................................119



Bibliografía

1



ÍNDICE DE ILUSTRACIONES PágIlustración 1: demostración de las partes de una tabla resumen / comparativa...................5Ilustración 2: estrategias de enseñanza / aprendizaje en esta guía didáctica.....................6Ilustración 3: Pasos durante la creación de un programa...................................................7Ilustración 4: Ejemplo de una Función con parámetros....................................................11Ilustración 5: Ejemplo de una Función sin parámetros.....................................................12Ilustración 6: Extracto de programa que multiplica los primeros N números.....................13Ilustración 7: Programa que multiplica los primeros N números. Corrección 1....................14Ilustración 8: Programa que multiplica los primeros N números. Corrección 2...................15Ilustración 9: Programa que multiplica los primeros N números. Solución final..................15Ilustración 10: Cómo activar la depuración de un programa con DevC++............................17Ilustración 11: Cómo comenzar a depurar con DevC++.....................................................17Ilustración 12: Depuración paso a paso con DevC++.........................................................18Ilustración 13: Observar el valor de variables mientras depuras.....................................19Ilustración 14: Entrar en el código de subrutinas, funciones o métodos............................19Ilustración 15: Ejemplo de aplicación de métricas de programación.................................23Ilustración 16: Sintaxis para abrir un archivo de texto...................................................26Ilustración 17: Programa con entrada exclusiva por archivo de texto...............................27Ilustración 18: Un Teléfono en términos de objetos.......................................................33Ilustración 19: Una Cuenta Bancaria en términos de objetos...........................................33Ilustración 20: Un Automóvil en términos de objetos.....................................................34Ilustración 21: IDE DevC++, para el Lenguaje Orientado a Objetos C++............................36Ilustración 22: Pilares de la Programación Orientada a Objetos......................................38Ilustración 23: Jerarquía de clases de transportes........................................................41Ilustración 24: Demostración de un caso de polimorfismo...............................................43Ilustración 25: Identificación de objetos y sus componentes (Ejemplo Organización).......48Ilustración 26: Identificación de objetos y miembros por ejemplificación tabulada..........51Ilustración 27: El cielo en la pantalla del computador.....................................................52Ilustración 28: El control remoto del cielo.....................................................................53Ilustración 29: funcionamiento del control remoto del cielo............................................54Ilustración 30: El ejemplo Trabajadores en la pantalla del computador............................54Ilustración 31: funcionamiento del control remoto del problema Organización..................55Ilustración 32: Representación de una clase según la notación UML.................................61Ilustración 33: Sintaxis para representar los atributos en la clase, según UML................62Ilustración 34: Sintaxis para representar los métodos en la clase, según UML.................62Ilustración 35: Diagrama de clases base para ejemplo de la Organización........................63Ilustración 36: Sintaxis para la programación de la interfaz de una clase........................69Ilustración 37: Archivo Trabajador.h con la interfaz de la clase.....................................70Ilustración 38: Archivo Trabajador.cpp con la implementación de la clase........................70Ilustración 39: Archivo Trabajador.h con la interfaz de la clase.....................................71Ilustración 40: Sintaxis para la programación del programa principal...............................72

Decanato de Ciencias y Tecnología

Universidad Centroccidental “Lisandro Alvarado”

Ilustración 41: Archivo Principal.cpp con el Programa Principal........................................73Ilustración 42: Archivo Trabajador.h con la interfaz de la clase.....................................76Ilustración 43: Archivo Trabajador.cpp con la implementación de la clase........................76Ilustración 44: Integración de componentes de un POO con el proyecto en DevC++...........77Ilustración 45: Barra de herramientas en la IDE de DevC++............................................78Ilustración 46: Paso a paso para crear un POO con DevC++.............................................79Ilustración 47: Sintaxis para la programación del programa principal...............................80Ilustración 48: Ejemplo 1 de aplicación de metodología...................................................89Ilustración 49: Ejemplo 2 de aplicación de metodología..................................................90Ilustración 50: Ejemplo 3 de aplicación de metodología..................................................90Ilustración 51: Ejemplo 1 de POO (Proy-CtaBanco).........................................................91Ilustración 52: Del ejemplo y abstracción al POO (Proy-CtaBanco)..................................91Ilustración 53: Ejemplo 2 de POO (Proy-NroEntero)......................................................92Ilustración 54: Ejemplo 3 de POO (Proy-Llamada)..........................................................92Ilustración 55: Del ejemplo y abstracción al POO (Proys Llamada y NroEntero)................93Ilustración 55: Del ejemplo y abstracción al POO (Proys Llamada y NroEntero).



ÍNDICE DE TABLAS PágTabla 1: comparación entre parámetros por valor y por referencia..................................10Tabla 2: compatibilidad entre parámetros formales y parámetros actuales......................11Tabla 3: Primera corrida en frío, se identifica un problema.............................................14Tabla 4: Segunda corrida en frío, se identifica otro problema.........................................14Tabla 5: Tercera corrida en frío, se identifica otro problema.........................................15Tabla 6: Comparación entre clases, instancias y objetos.................................................31Tabla 7: tabulación de información y requerimientos (ejercicio de la organización)...........51Tabla 8: Ejemplificación del ejercicio de los billetes......................................................57Tabla 9: Ejemplificación del ejercicio de los artículos....................................................57Tabla 10: Ejemplificación del ejercicio de los sobres de dinero.......................................57Tabla 11: Efecto del tipo de visibilidad de miembros......................................................62Tabla 11: Efecto del tipo de visibilidad de miembros



2 INTRODUCCIÓN

La Programación de Computadoras es una técnica que ha ido evolucionando desde hace ya varias décadas, pasando desde lenguajes de bajo nivel, donde era preciso configurar los programas desde los mismos circuitos del computador, pasando por tarjetas perforadas (como fichas de biblioteca, pero con huequitos que leía una máquina), luego por la muy arraigada programación estructurada, hasta establecerse de la manera más natural en la actualidad con la Programación Orientada a Objetos (POO).

Esta forma de programar se basa en las características de las cosas que conforman la situación problemática, observándolas y describiéndolas tal y como las ves en el ámbito real: con sus propiedades y su comportamiento.

La gran mayoría de los lenguajes actuales de programación admiten bien sea todas las características de la Programación Orientada a Objetos, o algún subconjunto del mismo.

En lo que te resta de carrera, e incluso en tu vida profesional como Ingeniero Informático o Analista de Sistemas, estarás estrechamente vinculado a las técnicas, diseños y metodologías orientadas a objetos, actividades imprescindibles en la implantación de soluciones software.

Esta guía te ofrece:

➢ Conocimientos básicos y herramientas útiles para las actividades de programación.

➢ Conceptualización de la POO.

➢ Metodología para el diseño y modelaje de planteamientos con POO.

➢ Aplicación de POO con el Lenguaje C++.

➢ Múltiples ejercicios resueltos y propuestos en cada capítulo.

➢ Soluciones a los ejercicios propuestos.

La guía se ha concebido con técnicas ilustrativas nemotécnicas que te permiten identificar rápidamente la idea que se te presenta. La sección de Estrategias de Enseñanza te explica cómo sacarle máximo provecho a esto.

Anímate y vamos juntos a aprender a programar con POO!!!



1



2 ESTRATEGIAS DE ENSEÑANZA EN ESTA GUÍA DIDÁCTICA

La guía se ha diseñado de manera que cuentes con distintas herramientas de comprensión del contenido, posibilitándote un estudio más ameno e interactivo.

A medida que avances en los contenidos de la guía, te resultará más fácil “navegar” en la lectura y estudiar de la misma.

Entre las técnicas que se aplican en toda la guía encontrarás: referencias cruzadas, mapas mentales, tablas comparativas y fichas resumen.

Otro elemento que encontrarás es que cada tópico relevante tiene su propio grupo de ejercicios resueltos y propuestos tipo examen, de manera que puedas prever el tipo de cuestiones a las que te enfrentarás en las evaluaciones.

2.1 FILOSOFÍA PARA LA TRANSMISIÓN DEL CONOCIMIENTO

Se ha procurado el uso intensivo de imágenes, ilustraciones y tablas resúmenes que demuestren el contenido de los objetivos planteados de una manera gráfica.

Una imagen dice más que mil palabras…Un gráfico dice más que mil imágenes !

2.1.1 REFERENCIAS CRUZADAS

Las referencias cruzadas te indicarán el lugar donde puedes obtener mayor información de un tópico. La referencia te llevará a la página exacta donde conseguirás el detalle que buscas. Ejemplo:

Aprende más de referencias cruzadas en Pág. Error:Reference source not found

2.1.2 IMÁGENES ALUSIVAS

Cuando veas las siguientes imágenes, esto es lo que significan:

• IDEA: estarás frente a un planteamiento genial.

• TIP: nota o recomendación; seguramente verás indicaciones de cómo lograr o cómo entender algo de una manera más fácil.



• SOLUCIÓN: cuando veas el “cubo mágico” armado, estarás frente a ejercicios ya resueltos!

• PROBLEMA: el “cubo mágico” por armar indica ejercicios propuestos.

• REFERENCIA CRUZADA: la lupa en el libro te invita a buscar más información en el sitio indicado.

• MAPA MENTAL: te indica que la ilustración está estructurada como un mapa mental del tema o tópico.

1.1.1 OTRAS ESTRATEGIAS DE ORGANIZACIÓN DE LA GUÍA

Encontrarás en toda la guía los siguientes instrumentos que te permitirán comprender más fácilmente el conocimiento que queremos transmitirte:

• Ejercicios por tópico.• Tablas resumen y/o comparativas.• Mapas mentales.

Seguidamente te explicamos un poco más en detalle cada una de estas estrategias, para que los asimiles al máximo.

1.1 EJERCICIOS POR TÓPICO

Cada tópico de esta guía didáctica se ha concebido con uno o varios ejercicios resueltos, ideados con el mismo nivel de dificultad al que te enfrentarás en las evaluaciones.

Por otra parte, también dispondrás de múltiples ejercicios propuestos, mismos que te invitamos a resolver en su totalidad.

Al final de la guía didáctica conseguirás las respuestas a los ejercicios propuestos.

Recuerda que en programación hay muchas formas de resolver el mismo problema, pero siempre con la condición de que se cumplan con las reglas del ejercicio planteado y los objetivos por evaluar. Considerando esto, la respuesta que encontrarás seguramente corresponderá a una de las soluciones posibles.



1.2 TABLAS RESUMEN Y/O COMPARATIVAS

Cuando veas tablas con información tabulada, concéntrate en la idea que se intenta transmitir en cada uno de sus títulos, filas, columnas y celdas.

Los títulos de la tabla, de las filas y columnas te darán la explicación del contenido respectivo. Posiblemente en la celda donde se cruzan los títulos consigas información del tema tratado en filas y el tratado en columnas.

En una tabla también suele denominarse a cada fila como un REGISTRO, y a cada columna como un CAMPO.

Observa la siguiente tabla resumen identificando las partes de la misma:

Ilustración 1: demostración de las partes de una tabla resumen / comparativa.

1.3 MAPAS MENTALES

Un mapa mental es un diagrama que usaremos con mucha frecuencia para representar las palabras, ideas, tareas, u otros conceptos ligados y dispuestos radialmente alrededor de de una idea central o de un tema.



Título de la tablaTítulos de columnasTítulos de filasCeldasTema de filas (Estado) y columnas (Año)IDENTIFICACIÓN DE LAS PARTES DE UNA TABLA RESUMEN / COMPARATIVAEn esta tabla hay 3 registros y 2 campos

En esta guía, las partes de una Tabla Resumen se explicaron usando un mapa mental. Observa el tópico Tablas resumen y/o

comparativas y verás cómo alrededor de la tabla resumen se colocaron las ideas que te muestran cada parte de la misma

Analiza detenidamente el siguiente mapa mental donde resumimos las estrategias de enseñanza y aprendizaje que te hemos presentado.



Referencias CruzadasImágenes AlusivasTablas Resumen y/o ComparativasEjercicios por tópico

Ilustración 2: estrategias de enseñanza / aprendizaje en esta guía didáctica.

2



ESTRATEGIAS DE ENSEÑANZA / APRENDIZAJE EN ESTA GUÍA DIDÁCTICATe indican donde puedes buscar más informaciónIdea: estarás frente a un planteamiento genialTip: verás indicaciones de cómo lograr o entender algo de una manera más fácilSolución: el “cubo mágico” armado, te indica ejercicios ya resueltosReferencia cruzada: te invita a buscar más información en el sitio indicadoProblema: el “cubo mágico” por armar indica ejercicios propuestosConcéntrate en la idea que se intenta transmitir en cada uno de sus títulos, filas, columnas y celdas.Cada tópico de esta guía didáctica tiene varios ejercicios resueltos y propuestos, con el mismo nivel de dificultad de las evaluaciones.Al final de la guía están las soluciones.

Mapa mental: indica que una ilustración está estructurada como un mapa mental

Codificar el Programa Fuente

Compilar el Programa Fuente

Construir el Programa Objeto

Enlazar el Programa Objeto

Obtener el Programa Ejecutable

3 CONOCIMIENTOS PRELIMINARES

Los siguientes tópicos constituyen un conocimiento que debes dominar antes de que empieces a trabajar con Programación Orientada a Objetos. Posiblemente ya manejes las definiciones y términos que se presentan, de manera que revísalos detenidamente y verifica que los dominas, ya que en la guía se hacen muchas referencias a los mismos.

3.1 CREACIÓN DE PROGRAMAS

El proceso de crear un programa de computadoras consiste, en términos generales, en la siguiente secuencia de pasos:

Ilustración 3: Pasos durante la creación de un programa.

Codificar el Programa Fuente: el programa fuente consiste en todos los archivos con las líneas de código que hacemos en un programa. en este curso, el código fuente será con Lenguaje C++.

Compilar el Programa Fuente: Compilar consiste en verificar que todas las reglas del lenguaje (sintaxis) se cumplen en las instrucciones del programa fuente. La compilación se invoca desde la interfaz de desarrollo (IDE) la cual se vale del compilador del lenguaje respectivo.



Construir el Programa Objeto: el sólo hecho de que el programa fuente sea sintácticamente correcto no garantiza que vaya a funcionar. El programa objeto se crea automáticamente luego de la compilación es exitosa, y lo que resulta es un código intermedio que contiene múltiples tablas con las referencias a variables y llamadas a subrutinas, funciones y métodos, para su posterior verificación de que se declararon y/o existen.

Enlazar el Programa Objeto: enlazar el programa consiste en verificar las tablas de referencias, creadas en el programa objeto, y comprobar que toda referencia a variable, subrutina, función o método está disponible en el programa fuente o en las librerías que se incluyeron.

Obtener el Programa Ejecutable: una vez se superan exitosamente las etapas anteriores, se produce el programa ejecutable, el cual podrás hacerle doble clic en el explorador de archivos y hacerlo funcionar. En Windows los programas ejecutables tienen extensión EXE.

1.1 FUNCIONES

Una función contiene una o más sentencias y se crean generalmente para realizar una única tarea.

En la Programación Orientada a Objetos, las funciones se utilizan para definir los métodos de las clases. Cuando estés haciendo programas y veas que se refieren a métodos, entonces sabrás que se trata de funciones definidas por el usuario.

Todos los lenguajes de programación ofrecen innumerables funciones que ya están programadas, y también la posibilidad

de crear nuevas por parte del programador. A estas se les denomina Funciones Definidas por el Usuario, considerándote a ti

como usuario del Lenguaje (programador).

1.1.1 IMPLEMENTACIÓN DE UNA FUNCIÓN

Para que puedas programar una función, debes seguir la siguiente sintaxis:tipo_de_retorno NombreFuncion (lista parámetros) { sentencias return valor;}



Cuando en el tipo de retorno aparece la palabra reservada void significa que la función no retorna ningún valor.

void NombreFuncion (lista parámetros) { sentencias .....}

Usualmente se les denomina Procedimientos a las funciones que no retornan ningún valor

1.1.2 PARÁMETROS DE UNA FUNCIÓN

Los parámetros se usan para enviar valores a una función, con los que ella trabajará para realizar los procesos. Son los valores de entrada que recibe una función. Por ejemplo, una función que realizase una suma de dos números tendría como parámetros a esos dos números. Los dos números son la entrada, así como la salida sería el resultado. También se conocen como Argumentos.

Una función puede utilizar parámetros por valor y parámetros por referencia, o puede no tener parámetros.

1.1.3 TIPOS DE PARÁMETROS SEGÚN LO QUE RETORNAN

Según el valor que puede retornar un argumento, los parámetros se clasifican en parámetros por valor o por referencia.

• PARÁMETROS POR VALOR: El paso de argumentos por valor significa que al compilar la función y el código que llama a la función, ésta recibe una copia de los valores de los parámetros que se le pasan como argumentos.

• PARÁMETROS POR REFERENCIA: Cuando una función debe modificar el valor de la variable pasada como parámetro y que esta modificación retorne a la función llamadora, se debe pasar el parámetro por referencia.

Los parámetros por referencia también pueden identificarse ya que constituyen parámetros de entrada y salida. Los parámetros por valor son sólo de entrada.

En este método, el compilador no pasa una copia del valor del argumento; en su lugar, pasa una dirección de memoria, que indica a la función dónde existe la dirección de los argumentos pasados.



Para declarar un parámetro como paso por referencia, el símbolo & debe preceder al nombre del parámetro.

COMPARACIÓN ENTRE PARÁMETROS POR VALOR Y POR REFERENCIA

ComparaciónTipo parámetro Por valor Por referencia

Cómo identificarlos Se declaran sin & Se declaran con &

Qué recibe la funciónCopia de los valores de los argumentos que se pasan

El mismo valor que el argumento que se pasa (la

misma dirección)

Cómo se afecta el parámetro que se envía

No cambia el valor del argumento original

El cambio es retornado al argumento original

Entrada y/o salida Solo de entrada Son de entrada y salida

Tabla 1: comparación entre parámetros por valor y por referencia

1.1.1 TIPOS DE PARÁMETROS SEGÚN SU UBICACIÓN

Tanto en la definición (cabecera) de la función como en las llamadas deben colocarse parámetros; la siguiente terminología los distingue

• Parámetros formales: están en la definición de la función (cabecera). Debe indicarse el tipo de cada argumento. Sólo se definen 1 vez, ó 2 veces cuando se trabaja con clases (una en la interfaz y otra en la implementación).

• Parámetros actuales: están en cada llamada a una función. No debe colocarse el tipo de cada argumento. Los veremos múltiples veces, todas las que sea necesaria, en un programa; cada vez que se invoca a una función, esos parámetros serán actuales.

Para que la invocación a una función esté correcta sintácticamente en sus parámetros actuales con respecto a los parámetros formales, deben cumplirse las siguientes reglas:

COMPATIBILIDAD ENTRE PARÁMETROS FORMALES Y PARÁMETROS ACTUALES

ReglaCompatibilidad Debe cumplir con lo siguiente

Misma cantidadPara N parámetros formales deben haber N parámetros actuales. Ej: si hay 3 parámetros en los formales, deben

haber 3 en los actuales

Mismo tipo Deben ser parámetros del mismo tipo. Ej: Si en los formales



hay un char y un int, igualmente deben haber un char y un int en los actuales

Mismo orden

Deben estar en el mismo orden. Ej: si en los formales hay un char y un int, y en los actuales hay un int y un char, ambos pares de parámetros tienen el mismo tipo pero no están en

el mismo orden.

Tabla 2: compatibilidad entre parámetros formales y parámetros actuales

1.1.1 EJEMPLOS DE FUNCIONES

Ilustración 4: Ejemplo de una Función con parámetros.

Ilustración 5: Ejemplo de una Función sin parámetros.



Ejemplo de una Función con parámetrosvoid ImprimirMensaje (string mensaje) { cout << mensaje << endl;}

Llamado de la función ImprimirMensaje ImprimirMensaje (“Ingrese los siguientes datos:”);Parámetros formales de la función

Parámetros actuales de la función

Ejemplo de Funciones sin parámetrosvoid LimpiarPantalla () { system (“cls”);}

void DetenerPantalla () { system (“pause”);}

Igual se colocan paréntesis que abre y cierra (sin argumentos)

Funciones que no ameritan argumentos

Llamado de las funciones anterioresLimpiarPantalla ();DetenerPantalla ();

1.2 ESTADO DE LA MEMORIA EN UNA EJECUCIÓN

Cuando ejecutas un programa, para cada variable que usas se crea un espacio de memoria donde se almacenará el valor respectivo de la variable, normalmente múltiplos de bytes (8 bits); así por ejemplo, para un dato boolean se destinará 1 Byte (aunque sólo se guarde un uno o un cero), para un char también se destinará un Byte, para un integer se destinarán 4 bytes, u 8 si se trata de un long integer, etc.

De esta manera, se hará preciso tomar en consideración la necesidad de inicializar las variables que usarás en tus programa, ya que en caso contrario podrían estar “Embasuradas”, y producir resultados inesperados.

Cuando haces corridas en frío y tomas en consideración los valores que se van almacenando en cada variable, entonces estás simulando el estado de la memoria que usa tu programa.

Es de destacar que las funciones y métodos de los objetos no usan memoria para almacenar información, pero sí para las variables internas, a las cuales se les destina un espacio de memoria al momento de iniciar la ejecución de la rutina y el mismo se libera una vez termina la ejecución respectiva.

En las tablas de corridas en frío del tópico Corridas en frío, página Corridas en frío, podrás ver cómo cambia el valor de las variables (estado de la memoria) que se usan en el extracto de programa respectivo.

1.3 CORRIDAS EN FRÍO

Una corrida en frío es una prueba “manual” del funcionamiento de un programa. El objetivo es verificar cómo se producen paso a paso las instrucciones de un programa y cómo se modifican las variables utilizadas, para finalmente comprobar que el resultado es el deseado.

Las corridas en frío son un excelente mecanismo para comprobar la lógica de extractos de programas, e incluso programas extensos cuando se obvian instrucciones que se sabe funcionan bien.

Debes tener presente lo siguiente:

Cuando un programa te produzca resultados inesperados, una alternativa es recurrir a la corrida en frío en el papel; otra alternativa es la depuración.



No esperes que la corrida en frío te resuelva rápidamente un error en el programa: con frecuencia se necesita paciencia para revisar línea a línea el código. Cuando adquieras práctica identificarás más rápido un error.

Es mucho más difícil llevar un registro mental del estado de las variables que participan en un programa, por eso la corrida en frío usa tablas que permiten visualizar inequívocamente los cambios en las mismas.

Supón el siguiente extracto de programa que calcula la multiplicación de los primeros N números, donde N lo suministra el usuario:

Ilustración 6: Extracto de programa que multiplica los primeros N números.

La siguiente tabla demuestra la corrida en frío del extracto de programa anterior:

PRIMERA CORRIDA EN FRÍOCorrida

Línea

Variables Observaciones

2 N=3 Suponga que el usuario introduce 3; la multiplicación de los primeros 2 números debe resultar en: 1 * 2 * 3 = 6

3 N=3, Mult=0 Se inicializa Mult

4 N=3, Mult=0, i=0 Se crea i y comienza el ciclo

5 N=3, Mult=0, i=0 Mult debió cambiar a 1 !!! HAY UN ERROR: multiplicar por 0 da 0 ... Mult en este ejercicio debe iniciarse en 1

Tabla 3: Primera corrida en frío, se identifica un problema



:::1- cout << “Cuantos números a multiplicar?: ”;2- cin >> N;3- int Mult = 0;4- for (int i = 0; i <= N; i++)5- Mult *= i;6- cout << “La multiplicación de los primeros ” << N;7- cout << “ numeros es: ” << Mult;:::

Ilustración 7: Programa que multiplica los primeros N números. Corrección 1.

Se corrigió el error, veamos la corrida en frío con la corrección:

SEGUNDA CORRIDA EN FRÍOCorrida

LíneaVariables Observaciones

2 N=3 Suponga que el usuario introduce 23 N=3, Mult=1 Se inicializa Mult4 N=3, Mult=1, i=0 Se crea i y comienza el ciclo5 N=3, Mult=0, i=0 Mult debió cambiar a 1 !!! OTRO ERROR: habrá que

multiplicar por i+1... de nuevo multiplicar por 0 da 0Tabla 4: Segunda corrida en frío, se identifica otro problema

Ilustración 8: Programa que multiplica los primeros N números. Corrección 2.

De nuevo la corrida en frío con la corrección:

TERCERA CORRIDA EN FRÍOCorrida

Línea

Variables Observaciones

2 N=3 Suponga que el usuario introduce 23 N=3, Mult=1 Se inicializa Mult4 N=3, Mult=1, i=0 Se crea i y comienza el ciclo5 N=3, Mult=1, i=0 Mult se actualiza correctamente para el primer ciclo:





Mult *= (i+1), que significa: Mult = Mult * 14 N=3, Mult=1, i=1

Acá está iterando el ciclo for, mientras i <= N5 N=3, Mult=2, i=14 N=3, Mult=2, i=25 N=3, Mult=6, i=24 N=3, Mult=6, i=3 En este momento NO DEBERÍA volver a entrar al ciclo,

pero resulta que el ciclo se ejecuta mientras que i <= N. ES DECIR: HAY OTRO ERROR! El ciclo debería condicionarse por menor y no por menor e igual.

Tabla 5: Tercera corrida en frío, se identifica otro problema

Ilustración 9: Programa que multiplica los primeros N números. Solución final.

Lo anterior es el último ajuste luego de las corridas en frío. Como ya verificamos que lo único que faltaba era cambiar i <=N por i < N, el ciclo terminará y se mostrará correctamente la salida por la pantalla:

La multiplicacion de los primeros 3 numeros es: 6

1.1 DEPURACIÓN DE PROGRAMAS

Con la técnica de la corrida en frío, en el papel simulábamos el comportamiento de la memoria del computador en cada paso de la ejecución de un programa.

La depuración de programas consiste en hacer la ejecución del mismo con un conjunto de herramientas automáticas que incorpora la IDE (Interfaz de Desarrollo Integrado), tal como lo es Dev-C++, y que nos permiten “inspeccionar” de múltiples formas el comportamiento de la corrida de nuestro programa.

Gracias a las herramientas de depuración podemos:

Ver el valor de las variables que usa el programa.



:::1- cout << “Cuantos números a multiplicar?: ”;2- cin N;3- int Mult = 1;4- for (int i = 0; i < N; i++)5- Mult *= (i + 1);6- cout << “La multiplicación de los primeros ” << N;7- cout << “ numeros es: ” << Mult;:::

Ejecutar línea a línea el programa, bien sea entrando al detalle de cada método o función, u obviando los métodos en los que confiamos.

Ejecutar el programa hasta una línea en la que “sospechamos” se produce una falla, y ver la secuencia de las instrucciones respectivas.

En fin, el propósito último es verificar que la secuencia del programa y los valores de memoria se comportan tal y como lo planeamos.

1.1.1 CÓMO ACTIVAR LA DEPURACIÓN DE UN PROGRAMA CON DEVC++

De forma predeterminada, la depuración de un proyecto en Dev-C++ está desactivada. Esto es así ya que los programas corren un poco más lento en la IDE cuando está activada esta característica.

Es necesario “configurar” el proyecto para que active la depuración:

• Abra su proyecto.• Seleccione la opción de menú “Project / Project Options”• Seleccione la pestaña “Compiler”• Seleccione el vínculo “Linker” (Enlazador en español)• Cambie a “Yes” la opción “Generate Debugging information” (Generar

Información de Depuración)

Tanto el menú “Debug” como el panel inferior de Dev-C++ ofrecen las opciones para comenzar a depurar:

Ilustración 10: Cómo activar la depuración de un programa con DevC++.

1.1.1 COMENZAR A DEPURAR UN PROGRAMA

• Ubique la línea donde desea detener su programa.• Establezca un “punto de parada” del programa.

– Presione Ctrl+F5, o– Use el menú “Depurar / Alternar punto de parada”, o– Haga clic en la barra vertical negra junto al código.

• Inicie la depuración (Botón “Depurar” o tecla F8).



Cómo activar la depuración de un programa con DevC++

Ilustración 11: Cómo comenzar a depurar con DevC++.

1.1.1 DEPURAR PASO A PASO SU PROGRAMA

• El programa se detendrá justo en la línea del punto de parada.• Ahora Ud tiene las siguientes opciones:

– F7 (Próximo paso): el depurador avanzará una instrucción (línea de código)

– Shift+F7 (Entrar a instrucción): el depurador avanzará una instrucción, y si es una función, entrará.

– Ctrl+F7 (Continuar): el depurador continuará con la ejecución del programa hasta que consiga otro punto de parada

Ilustración 12: Depuración paso a paso con DevC++.



Cómo comenzar a depurar con DevC++

Depuración paso a paso con DevC++

1.1.1 OBSERVAR EL VALOR DE VARIABLES Y MIEMBROS DE CLASES

• La pestaña “Depuración” muestra el valor de las variables. Puede agregarlas:

– Colocando unos segundos el ratón encima de la variable.– Colocando el cursor en la variable y presionando “Añadir variable

vigilada”• La figura muestra la depuración de la siguiente línea del programa, y el

estado de la variable “opcion”.

Ilustración 13: Observar el valor de variables mientras depuras.

1.1.1 ENTRAR EN EL CÓDIGO DE SUBRUTINAS, FUNCIONES O MÉTODOS

• La figura muestra la que el depurador “entra” al código de CargarDatosEmpleado luego de haber presionado Shift+F7

• Ud podrá continuar paso a paso presionando F7



Observar el valor de variables mientras depuras

Ilustración 14: Entrar en el código de subrutinas, funciones o métodos.

1.1.1 OTRAS OPCIONES DE DEPURACIÓN

• Shift+F4, Ejecutar hasta el cursor: Ud coloca el cursor en la línea deseada y el programa se ejecutará hasta llegar allí

• F7, Siguiente paso: el programa se ejecuta hasta la próxima parada• Ctrl+Alt+F2, Detener ejecución: el programa termina• Cambiar el valor de una variable: haga clic derecho encima de la variable• Remover vigilancia: elimina de inspecciones una variable

1.1.1 APROVECHAR LAS HERRAMIENTAS DE DEPURACIÓN

• Los resultados no son los esperados: corra paso a paso y verifique que las instrucciones y las variables van tomando los valores esperados.

• Falla sólo un cálculo: establezca puntos de parada en los componentes (métodos) encargados de dichos procesos.

• Cuando los componentes están comprobados: use sólo F7 (siguiente instrucción), y no tendrá Ud. que ir paso a paso dentro del componente.

• Comprobar la corrida en frío: si Ud. planeó una secuencia de ejecución del programa, usando una tabla de datos de prueba, use las distintas combinaciones de depuración para verificar que a cada paso de la ejecución del programa los resultados en las tablas de datos y la inspección de variables coinciden. Cuando observe alguna falla, corrija, recompile y comience de nuevo.



Entrar en el código de subrutinas, funciones o métodos

Hasta ahora había sido imposible verificar la ejecución de nuestros programas; gracias a la depuración, podemos hacer

el equivalente a la corrida en frío pero con estas herramientas automatizadas

1.1 SINTAXIS DE COMANDOS DE PROGRAMACIÓN

Un programa en cualquier lenguaje se puede concebir como una serie de palabras escogidas de algún conjunto o alfabeto de palabras. Las reglas que determinan si un grupo de palabras es un programa válido o no, constituyen la sintaxis de un lenguaje

La sintaxis en programación de computadoras es una técnica que usa una simbología universal para explicar los comandos del lenguaje y las reglas para su construcción. Las reglas se expresan con algunos signos que tienen un significado particular.



Definición de sintaxis: Un conjunto finito de reglas (la gramática) del lenguaje de programación, para la construcción

de las sentencias “correctas” de un programa

| : Indica que las sentencias son mutuamente excluyentes (o se usa una o la otra)

::: Indica que se repite todas las veces necesarias.

Toda palabra o carácter que no esté entre signos es obligatorio.

1.1.1 EJEMPLOS DE SINTAXIS DE COMANDOS EN C++

Condicional if:if ( <ExpLogica> ) <sentencia1> | [{ <sentencia1> }]; [ else <sentencia1> | [{ <sentencia1> }]; ]

Sentencia for:for (inicializacion; condicion iteración; incremento) { Sentencia simple | Sentencia computesta}

Sentencia while:while (condición) Sentencia;

Condicional switch:switch ( <expresion> ) { case <const1> : <sentencia1>; <break>; case <const2> : <sentencia2>; <break>; :::: case <constN> : <sentenciaN>; <break>; [default : <sentenciaD>; ]}

Sentencia do-while:do { Sentencia 1; :::: Sentencia N;}while (condición);



1.1 MÉTRICAS DE PROGRAMACIÓN: LEGIBILIDAD DEL CÓDIGO

El compilador de un lenguaje de programación moderno entiende las instrucciones así no estén bien organizadas para la lectura por parte del ser humano; en realidad lo que le interesa al compilador es que se cumplan las reglas (la sintaxis), en lugar de que se vea organizado el código.

Observa el siguiente extracto de programa:cout << “Cuantos números a multiplicar?: ”; cin N; int Mult = 1; for (int i = 0; i < N; i++) Mult *= (i + 1); cout << “La multiplicación de los primeros ” << N; cout << “ numeros es: ” << Mult;

Ahora observa este otro extracto de programa:cout << “Cuantos números a multiplicar?: ”;cin N;int Mult = 1;for (int i = 0; i < N; i++) Mult *= (i + 1);cout << “La multiplicación de los primeros ” << N;cout << “ numeros es: ” << Mult;

Si examinas con detenimiento, verás que se trata del mismo extracto de programa, pero el segundo está organizado para que sea más fácil de leer por parte del programador. De esta manera, te recomendamos seguir las siguientes reglas al momento de programar:

Usa una sangría de 3 espacios para identificar las líneas que corresponden a cada bloque de instrucciones. Ej:

for (int i = 0; i < N; i++) { Mult *= (i + 1); ::: :::}

Cuando el bloque esté dentro de otro bloque, entonces aplicas una sangría de 3 espacios adicionales. Ej:

for (int i = 0; i < N; i++) { Mult *= (i + 1); ::: if (Mult == XX){ cout << ... ::: } else { cout << ... ::: }}



Asegúrate que los indicadores de inicio y fin de bloque están alineados con el comando respectivo. Ej: nota que en el caso anterior cada llave que cierra (fin de bloque) se alinea con el comando al que pertenece ese bloque.

Es posible que la IDE (DevC++) agregue espacios adicionales cuando presionas Enter al final de una instrucción que escribes, está pendiente de esto y ajusta (con Backspace) la posición del fin de bloque al lugar correcto.

En el cierre de cada bloque puedes colocar en comentario el nombre del comando al que pertenece dicho bloque; así te permitirá identificar más fácilmente el inicio del bloque correspondiente.

Cuando vayas a escribir el código correspondiente a un bloque, es recomendable que de inmediato coloques el indicador de cierre del mismo (“}” en C++), y lo vayas “empujando” con el editor en la medida que incorporas las líneas pertenecientes al bloque; esta práctica te permite evitar que olvides colocar el cierre del bloque y te ahorrarás errores al compilar.

Ilustración 15: Ejemplo de aplicación de métricas de programación.

La gran necesidad de aplicar estas métricas es que tus programas: i) al tiempo puedes olvidarlos y te costará entenderlos, ii) tendrás

que entenderte con un equipo de trabajo que programe similar, según las reglas, iii) el profesor (en este curso) entenderá más fácilmente lo que

programas si está bien organizado el código que entregas.



int main (){ ::: for (int i = 0; i < N; i++) { Mult *= (i + 1); ::: if (Mult == XX){ cout << ... ::: } //if else { cout << ... ::: } //else } //for :::} //main

El programa principal te da el primer nivel de sangría; observa que las instrucciones tienen cada una 3 espacios en relación al bloque principalDado que el for tendrá un nuevo bloque de instrucciones, debe dejarse una sangría adicional de 3 espacios en relación a la sentencia for.En esta situación, el if amerita un sangrado adicional ya que está dentro del forEjemplo de aplicación de métricas de programaciónEl fin de cada bloque se ha documentado (Ej. //main) con el nombre del comando respectivo

1.1 ENTRADA DE DATOS DESDE ARCHIVOS

Incluimos este apartado de manera que podamos presentar programas con entradas de datos más extensas de las que conoces hasta el momento.

Fíjate a cual problema nos referimos: si estás resolviendo un planteamiento que te pide procesar las cédulas, nombres y 3 notas de 20 estudiantes, entonces significa que para probar tu programa debes introducir cada vez 5 x 20 datos, esto es 100 entradas de datos, procurando que no te equivoques para que veas los resultados correctos.

Entonces lo que haremos, en lugar de transcribir a tu programa toda esta información cada vez que vayas a hacer una prueba de funcionalidad, es que la información de entrada la tomaremos de un archivo de texto. Un archivo de texto lo puedes crear rápidamente con un editor de textos como el bloc de notas, o incluso con el procesador de palabras Word.



Los archivos son medios que facilita el lenguaje para almacenar los datos en forma permanente (memoria

secundaria), es decir, los datos se pasan de la memoria principal a una unidad de almacenamiento secundario para posteriormente

recuperarlos y trabajar sobre ellos.

Las operaciones de entrada y salida se realizan en C++, mediante flujos (streams) o secuencias de datos.

Los flujos estándar son cout (flujo de salida) y cin (flujo de entrada). La salida fluye normalmente a la pantalla y la entrada representa los datos que proceden de teclado.

cin es un flujo de entrada, y se dice que está enlazado (o conectado) al dispositivo de entrada estándar que normalmente es el teclado: cin >> nota;

El operador de extracción de flujo “>>”, causa que un valor para la variable entera nota (suponiendo que calificación ha sido nota como int) se reciba desde cin hacia la memoria.

cout es un flujo de salida, y se dice que está enlazado al dispositivo de salida estándar que normalmente es la pantalla

cout << nota;

El operador de inserción de flujo “<<“, causa que al valor de la variable entera nota se le dé salida desde la memoria hacia el dispositivo de salida estándar.

Cuando se utilicen archivos en C++ se debe definir un (flujo) stream. Dicho stream permitirá la transferencia de datos entre el programa y el archivo en disco.

1.1.2 ARCHIVOS DE TEXTO

Son aquellos archivos que están expresados en formato ASCII, no contienen caracteres de control, por tanto se puede ver su información utilizando comandos de sistema operativo, procesador de textos o editores.

Los archivos de texto se pueden utilizar para almacenamiento de datos o crear imágenes de salida impresa que se pueden enviar más tarde a una impresora.



Para poder manipular archivos, C++ dispone de la biblioteca estándar fstream (file stream) donde se encuentran todas las funciones necesarias para abrir y cerrar archivos, así como para realizar las operaciones de lectura y escritura de datos en archivos:

#include <fstream>

Las siguientes operaciones están asociadas a los archivos:

• Abrir archivo: bien sea para lectura y/o para escritura.• Crear archivo: cuando no existe, esta operación lo crea.• Lectura y escritura: nos interesa por ahora la lectura, hacia variables

que usaremos en nuestros programas.• Funciones de control: por ejemplo i) se llegó al final del archivo, ii)

indicación de apertura exitosa, iii) Cerrar del archivo.

1.1.1 APERTURA Y LECTURA DE ARCHIVOS

Antes de que un programa pueda leer datos de un archivo o escribir datos en un archivo, este debe ser abierto.

Al igual que los flujos cin y cout, los flujos de archivos solo pueden transferir datos en una dirección, esto significa que se tienen que definir flujos diferentes para lectura y escritura de datos.

Para abrir un archivo solo para lectura, es decir, se quiere recuperar los datos que se encuentran en él (traer los datos de la memoria secundaria hacia la memoria principal), se debe definir un flujo de archivo de entrada con la sentencia ifstream.

Ilustración 16: Sintaxis para abrir un archivo de texto.

Ejemplo: La siguiente sentencia permite definir un flujo de archivo de entrada (solo para lectura) llamado archest, para trabajar con un archivo que se encuentra en el disco, cuyo nombre físico es: C:\Prog1\Estudiantes.txt



ifstream nombre_flujo_e (“ruta_de_localización”, ios::in)Input file streamNombre lógico (un identificador)Nombre físico (la ruta en el disco)Modo de aperturaSintaxis para abrir un archivo de texto

ifstream archest (“C:\Porg1\estudiantes.txt”, ios::in)

Una vez definidos los flujos con los que va a trabajar el programa, se pueden utilizar los operadores de inserción (<<) para grabar datos en el archivo y extracción (>>) para recuperar datos del archivo.

1.1.2 FUNCIONES DE CONTROL

• eof - Fin del archivo: La función eof sirve para comprobar si se ha alcanzado el final del fichero. Muy frecuentemente se deberá trabajar con todos los valores almacenados en un archivo de forma secuencial, la forma que suelen tener los bucles para leer todos los datos de un archivo es permanecer leyendo mientras no se detecte el fin de fichero. Esta función suele usarse como prueba para verificar si se ha alcanzado o no ese punto final: archivo.eof (), retorna cero (0) si no se ha alcanzado el final, o uno (1) cuando se llegó al fin del archivo.

• Indicación de apertura exitosa: Antes de intentar leer o escribir datos en un archivo, se debe verificar que se ha abierto con éxito. Cuando se hace referencia al identificador que se usa como nombre lógico del archivo, entonces C++ devuelve Verdadero cuando en efecto está a bierto. Como sigue:

ifstream archest(“estudiantes.txt”); if (!archest) { // Se interpreta: “Si no está abierto el archivo” cout<<"HAY UN ERROR, NO SE PUEDE ABRIR EL ARCHIVO"; system(“pause”)}else { // se colocan las instrucciones a ejecutar // si el archivo se abrió con éxito }

• Cerrar el archivo: Cuando el programa ha terminado de manipular el archivo, éste debe cerrarse. Para cerrar un archivo, basta con ejecutar la función close sobre el flujo asociado al fichero, la cual no utiliza parámetros ni devuelve valores. Ejemplo:

archest.close()



Ilustración 17: Programa con entrada exclusiva por archivo de texto.



Procesar mientras no sea fin del archivoLos datos de entrada vienen desde el archivo de textoSi no se abrió: ERROR#include <iostream>#include <fstream>using namespace std;

int main () { ifstream arch_nombres ("Nombres.txt"); if (!arch_nombres) cout << "El archivo no existe"; else { string nomb; long cedula; int edad; cout << "Nombres, cédulas y edades de estudiantes:" << endl; while (!arch_nombres.eof ()){ arch_nombres >> nomb >> cedula >> edad; cout << nomb << ", C.I. " << cedula << ", edad: " << edad << endl; } arch_nombres.close (); } system("PAUSE");}

Luis1111120Carlos5555519Maria4444421Juana7777720Ana9999919Rafael8888818Carmen6666620Diana2222220

Programa con entrada exclusiva por archivo de textoNombres.txt: creado con el bloc de notas, contiene el nombre, cédula y edad de varios alumnos (1 dato por línea, 1 registro cada 3 líneas)Apertura del archivoInclusión de biblioteca fstreamAl final se cierra el archivoEl programa podrás correrlo todas las veces necesarias sin tener que escribir cada vez docenas de datos

1 CONCEPTUALIZACIÓN DE PROGRAMACIÓN ORIENTADA A OBJETOS (POO)

1.1 ¿QUÉ ES LA PROGRAMACIÓN ORIENTADA A OBJETOS?

Es un paradigma de programación que usa objetos y sus interacciones, para diseñar aplicaciones y programas de computadora.

La Programación Orientada a Objetos (POO) es una forma especial de programar, más cercana a como expresaríamos las cosas en la vida real.

La Programación Orientada a Objetos se basa en la idea natural de la existencia de un mundo lleno de objetos, de modo que la resolución del problema se realiza en términos de objetos.

Un paradigma de programación representa un enfoque particular o filosofía para la construcción del software. No es

mejor uno que otro, sino que cada uno tiene sus ventajas y sus inconvenientes. También hay situaciones donde un paradigma resulta

más apropiado que otro, e incluso pueden usarse de manera combinada.

1.1.1 EJEMPLO DE OTROS PARADIGMAS DE PROGRAMACIÓN:

Programación Estructurada o por procedimientos: es considerado el más común y está representado, por ejemplo, por BASIC.

Funcional: está basado en el concepto matemático de función.

Lógico: representa conocimiento, el cual es manipulado mediante inferencias; trabajar con un paradigma lógico significa especificar qué hacer y no cómo hacerlo. Un ejemplo de este tipo de lenguaje es el Lenguaje de Consulta Estructurado SQL (Structured Query Language), el cual aprenderán en un semestre más avanzado.

Visual, orientada a eventos: es una forma más avanzada de programar con POO, permitiéndole al programador diseñar las aplicaciones con el uso del ratón y barras de herramientas con múltiples componentes que pueden “colocarse” en lo que será finalmente la interfaz del usuario.



Actualmente el paradigma de programación más usado es el de la programación orientada a objetos.

Si bien puede seleccionarse la forma pura de estos paradigmas al momento de programar, en la práctica es habitual que se mezclen, dando lugar a la programación multiparadigma.

1.1.1 EJERCICIOS RESUELTOS Y PROPUESTOS

a) ¿Cómo podrías identificar fácilmente un programa no orientado a objetos?. R. El código puede apreciarse en un solo bloque de instrucciones de principio a fin, a diferencia de un Programa Orientado a Objetos donde las partes están bien diferenciadas.

b) ¿Qué paradigma usaste cuando estuviste en Introducción a la Computación?. R. seguramente trabajaste tanto con Programación Estructurada como con Programación Orientada a Objetos; si haces un programa sin clases, es estructurado, incluso el código de cada método de las clases también lo es.

c) ¿Cuándo un lenguaje es Orientado a Objetos, sus programas usan exclusivamente este paradigma?. R. No. Como se ha mencionado, la POO usa programación estructurada en la implementación de sus métodos, por tanto es un paradigma mixto.

d) ¿Por qué crees que la programación visual también será POO?e) ¿Podrías identificar qué cosas de la vida real son objetos?f) ¿Qué significa diseñar las aplicaciones?, ¿qué significa implementarlas?g) Respuestas en la página respuestas a ejercicios propuestos. Antes de verlas, procura

tu mayor esfuerzo y resuelve.

1.1 CLASES, INSTANCIAS Y OBJETOS

Cuando vas usar una variable debes declararla, es decir indicar el tipo de dato que almacenará. Así por ejemplo:

Una variable para un número entero deberás declararla, p.ej: int edad.

Si necesitas un carácter char letra.

Un nombre string direccion.

Dado lo anterior, será más fácil que comprendas la diferencia entre clases y objetos: la clase es como el tipo de datos, el objeto es la variable.

Clase: Representa un dato de tipo objeto, es su definición, no puede tomar valores ni ejecutar métodos.

Instancia: Un ejemplar de una clase. Una variable de algún tipo de objeto.



Objeto: Un objeto es una Instancia de una Clase. Un objeto en POO, representa alguna entidad de la vida real, es decir, alguno de los objetos que pertenecen al negocio con que estamos trabajando o al problema con el que nos estamos enfrentando.

COMPARACIÓN ENTRE CLASES, INSTANCIAS Y OBJETOS

ElementoEntorno Si para variables es Para POO es

Declaración Un tipo de dato Una Clase

Nombre del dato Una variable Un Objeto o Instancia

Tabla 6: Comparación entre clases, instancias y objetos



Las clases son a los objetos como lo son los tipos de datos a las variables. Es decir, los tipos de datos definen el tipo de contenido

que tendrán las variables, las clases definen la estructura de los objetos

a) ¿Podrías ejemplificar lo qué es una instancia usando variables?. R. Sí, si declaro tres variables enteras < int a, b, c > entonces a, b y c son instancias de un tipo de dato de tipo entero. Las instancias pueden tomar valores, los tipos de datos no ya que son sólo una definición de lo que se puede almacenar.

b) ¿Cuál es la diferencia entre objeto e instancia?. R. Ninguna, puede usarse indistintamente un término u otro. En programación estructurada te referías a “la variable tal toma equis valores”... En POO dirás “el objeto tal tiene tal estado”, o “la instancia de la clase X tiene tal estado”.

c) ¿Los objetos son variables?. R. Sí, un objeto es una variable de un tipo de dato definido como “Clase”. Ahora con POO no deberás decir variable sino “el objeto X” o “la instancia X de la clase Y”, si quieres usar la palabra variable deberías decir “la variable tipo objeto de la Clase Y”; fíjate que es más “cómodo” decir “el objeto X”.

d) ¿Cuales reglas debes cumplir para declarar objetos? e) ¿De ahora en adelante ya no necesitarás más variables, sólo objetos?f) ¿Por qué necesitas declarar el uso de objetos, así como con variables?g) Respuestas en la página respuestas a ejercicios propuestos. Antes de verlas, procura


1.1 COMPOSICIÓN DE LOS OBJETOS

Los Objetos de Software, al igual que los objetos del mundo real, también tienen características y comportamientos. Un objeto de software mantiene sus características en una o más "variables" (denominadas propiedades o atributos) e implementa su comportamiento con "métodos". Un método es una función o subrutina asociada a un objeto.

Un Objeto en POO es cualquier cosa tangible o no, la cual se describe sobre la base de sus datos o propiedades (atributos) y funciones (métodos) que definen su comportamiento.

Los atributos y métodos que están asociados se dicen que están encapsulados en una única entidad (Encapsulación). Los métodos

dentro del objeto deben ser el único medio de acceder a los datos privados de ese objeto (Ocultación).



1.1.1 ATRIBUTOS

Los atributos son las características individuales que diferencian un objeto de otro y determinan su apariencia, estado u otras cualidades.

Los atributos se guardan en variables denominadas de instancia, y cada objeto particular puede tener valores distintos para estas variables.

Las variables de instancia, también denominadas o conocidas como miembros dato; son declaradas en la clase pero sus valores son fijados y cambiados en el objeto.

Los atributos pueden tomar un valor. Ejemplo de atributos: Edad, Color, Peso. Suma, etc.

Si piensas que Sumar pudiera ser un atributo, te equivocas. Fíjate: Sumar indica una acción y no un dato. Seguramente Sumar será un

proceso que calcula el atributo Suma.

1.1.2 MÉTODOS

Un método es un conjunto de instrucciones que realizan una determinada tarea y son similares a las funciones de los lenguajes estructurados.

La diferencia entre una función (o procedimiento) y un método es que éste último, al estar asociado con un objeto o clase en particular, puede acceder y modificar los datos privados del objeto correspondiente de forma tal que sea consistente con el comportamiento deseado para el mismo. Así, es recomendable entender a un método no como una secuencia de instrucciones sino como la forma en que el objeto es útil (el método para hacer su trabajo). Por lo tanto, podemos considerar al método como el pedido a un objeto para que realice una tarea determinada o como la vía para enviar un mensaje al objeto y que éste reaccione acorde a dicho mensaje.



Ahora sí podemos usar Sumar, ya que indica una acción (comportamiento) el cual será el cálculo del atributo Suma.

1.1.3 EJEMPLOS DE OBJETOS

Ilustración 18: Un Teléfono en términos de objetos.

Ilustración 19: Una Cuenta Bancaria en términos de objetos.



Métodos:- Llamar- Contestar- Encender- GuardarNro

Atributos:- Tipo- Numero- Operadora- Modelo

Fíjate que a cada uno de los atributos es posible asignarle un valor. Ej: Tipo=Celular, Numero=0414-123.45.67, Operadora=Cantv, Modelo=Samsung. Por su parte, los métodos denotan alguna acción con el celular.Un Teléfono en términos de objetos

Métodos:- Abrir- Depositar- Retirar- Cerrar

Atributos:- NumeroCta- Titular- FechaApertura - SaldoActual

Observa que una cuenta bancaria es un objeto intangible, una forma de representarla es con una libreta de ahorros. Otro ejemplo: si te piden calcular el promedio de 3 números, tendremos un objeto que llamaríamos Calculo.Una Cuenta Bancaria en términos de objetos

Ilustración 20: Un Automóvil en términos de objetos.


a) ¿Existe diferencias entre los términos miembros, componentes o partes de un objeto? R. No, significan lo mismo.

b) ¿Qué otra denominación se conoce para los atributos de objetos? R. Propiedades.

c) ¿Qué objetos son intangibles? R. son conceptualizaciones que no podemos ver materializadas. Ej: una cuenta bancaria, una factura, una reservación aérea, las notas de un estudiante; fíjate que en estos casos podrías tener un papel con la información de esos objetos, pero los mismos no se destruyen si rompes el papel.

d) ¿Qué significa “variables de instancia”? R. son los atributos de un objeto, que pueden tomar valores y cambiar para cada objeto en particular. Recuerda que los atributos son variables de los objetos, las variables propias de las instancias de una clase.

e) ¿En la vida real con qué podrías comparar los datos privados de un objeto en POO? R. Si tomamos una licuadora, p.ej., la cantidad de revoluciones de sus hojillas no la conoces, tú sólo pisas botones que hacen que cambie ese atributo (revoluciones). En un televisor, todos sus componentes internos se manipulan es a través del control remoto, éste con cada botón hace que los componentes del TV cambien en respuesta a la acción que corresponde al botón que presionas.

f) ¿Por qué es recomendable que sólo los métodos puedan acceder a los datos privados? R. así logras la mayor similitud con el mundo real; los métodos son como los botones del control remoto del TV, imagina que para cambiar un canal tengas que quitar la carcasa del TV, desenchufar y mover la conexión de cables... los objetos no funcionan así... si haces esto, es porque el objeto (TV) está descompuesto... si accedes los atributos de un objeto sin el uso de métodos, tienes una clase descompuesta y tendrás que repararla (redefinirla o reprogramarla).



Un Automóvil en términos de objetosAtributos:- Marca- Modelo- Año- Color- CapacidadPers- Placay cualquier otro dato

Métodos:- Encender- Arrancar- Cruzar- Izquierda- Cruzar- Derecha- Acelerar- Detenery cualquier otro comportamiento

g) Cuando describes los componentes de un objeto, ¿Cómo puedes distinguir qué será atributo y qué será método?

h) Describe en términos de objetos un ratón de computadoras, ¿es tangible o no?i) Describe en términos de objetos un número, ¿es tangible o no?j) Describe en términos de objetos un empleado, ¿es tangible o no?k) Describe en términos de objetos la fórmula de velocidad (v = d / t,

velocidad es distancia sobre tiempo), ¿es tangible o no?l) Describe en términos de objetos los alumnos de una clase, ¿es tangible o no?m) Describe en términos de objetos un triángulo, ¿es tangible o no?n) Respuestas en la página respuestas a ejercicios propuestos. Antes de verlas, procura


1.1 LENGUAJES ORIENTADOS A OBJETOS

En la actualidad la mayoría de los lenguajes de programación admiten la Programación Orientada a Objetos. Un lenguaje de programación orientado a objetos es aquel que admite el paradigma de la POO.

En este curso programarás con C++ y el entorno de desarrollo integrado (IDE) Dev-C++, el cual te ofrece una interfaz de fácil operación que te permite:

Escribir los programas

Compilarlos

Ejecutarlos

Depurarlos

Otros lenguajes que admiten objetos son los siguientes:

Object Pascal, y el entorno Borland Delphi

Java, con el entorno NetBeans

Basic, con el entorno Microsoft Visual Basic

XBase, con el entorno Microsoft Visual FoxPro

En semestres más avanzados de la carrera trabajarás con algunos de estos entornos de desarrollo.



Un Entorno de Desarrollo Integrado o IDE (acrónimo en inglés de Integrated Development Environment), es un

programa informático compuesto por un conjunto de herramientas de programación... consiste en un editor de código, un compilador,

un depurador y un constructor de interfaz gráfica.

Ilustración 21: IDE DevC++, para el Lenguaje Orientado a Objetos C++.



IDE DevC++, para el Lenguaje Orientado a Objetos C++Barras de herramientas que te permiten múltiples acciones: compilar, ejecutar, etc.Explorador de objetos que conforman tu proyecto.El código de cada objeto organizados en pestañas.Depurador de programas para que pruebes y corrijas.Poderoso editor que te facilita la escritura de tus programas.


a) ¿Crees que es posible hacer funcionar programas sin el uso de una IDE? R. Sí es posible. De hecho las IDEs se basan en compiladores más básicos que son invocados al momento de compilar con la IDE; estos compiladores son propios del Lenguaje de Programación. En realidad las IDEs lo que hacen es facilitar la escritura de los programas, la presentación de errores emitidos por el compilador básico y la depuración de los mismos.

a) ¿Cuál es el producto que obtienes luego de una compilación exitosa de un programa? R. cuando compilas exitosamente un programa se crea un archivo con extensión .EXE (ejecutable), el cual será ejecutado por la IDE y usado para efectos de hacer un seguimiento a su ejecución cuando se necesita depurar el mismo.

b) ¿Cuál es la diferencia entre compilar y depurar programas? R. La compilación convierte el código que escribes en lenguaje de máquina, el cual entiende la computadora; la depuración permite hacer un seguimiento a la ejecución de cada línea del código, en procura de solucionar errores lógicos.

c) ¿Qué son errores de compilación? R. Son errores producidos por faltas a las reglas de la escritura de los programas (Sintaxis). Compilar consiste en verificar que el programa escrito está SINTÁCTICAMENTE CORRECTO, es decir, verificar que se cumplen todas las reglas para las instrucciones usadas.

d) ¿Qué son errores de ejecución? R. también se conocen como errores lógicos, y se detectan durante la ejecución del programa. Se producen por errores de cálculos o procedimientos mal implementados, pero que no producen errores de compilación. Ej: si quiere calcular el promedio de 3 números, y escribes “prom = n1 + n2 + n3 / 3”, no tendrás errores de compilación pero el cálculo estará malo ya que la división se ejecutará antes de sumar los 3 números; correcto es prom = (n1 + n2 + n3) / 3

e) ¿Cuáles etapas puedes observar durante la implementación de un programa? R. se habla de “tiempos” durante la implementación: tiempo de diseño (mientras escribes el programa), tiempo de compilación (cuando solicitas compilar el programa), tiempo de ejecución (cuando el programa se está ejecutando),

f) ¿Los programas sólo pueden ser ejecutados en la IDE donde los programas? R. No, una vez que tu programa ha sido suficientemente probado tendrás el archivo .EXE, el cual puede ser ejecutado desde el explorador de archivos directamente.

g) ¿Qué puedes hacer para identificar y corregir errores de compilación? h) ¿Qué puedes hacer para identificar y corregir errores de ejecución?i) ¿Cuándo puedes saber que un programa ya no tiene errores de ejecución?j) ¿Bastará con probar un programa con un solo conjunto de datos de entrada?k) ¿Cuánto tiempo es el necesario para dedicar a cada etapa de la implementación?l) ¿Si dedicas toda una tarde a un ejercicio y no te da los resultados esperados, será

que no puede resolverse?m) ¿Con cuántos datos deberás probar tus programas para saber que están bien?



n) ¿Si un programa amerita 50 datos de entrada, o más, cómo puedes hacer para simplificar la entrada y hacer varias pruebas de ejecución?

o) Respuestas en la página respuestas a ejercicios propuestos. Antes de verlas, procura tu mayor esfuerzo y resuelve.

1.1 PILARES DE LA PROGRAMACIÓN ORIENTADA A OBJETOS

Existen cuatro principios básicos que cualquier sistema orientado a objetos debe incorporar, que se esquematizan en la siguiente figura:

Ilustración 22: Pilares de la Programación Orientada a Objetos.

Estos conceptos, que verás con más detalle seguidamente, hacen de la Programación Orientada a Objetos la forma idónea para programar las computadoras, gracias a que constituyen herramientas muy poderosas.

1.1.1 ABSTRACCIÓN

La abstracción consiste en aislar un elemento de su contexto o del resto de los elementos que lo acompañan.

En programación, el término se refiere al énfasis en el "¿qué hace?" más que en el "¿cómo lo hace?" (Característica de caja negra).

El común denominador en la evolución de los lenguajes de programación, desde los clásicos hasta los orientados a objetos, ha sido el nivel de abstracción del que cada uno de ellos hace uso.



Pilares de la Programación Orientada a Objetos

i) El proceso para calcular el promedio de 3 números puede explicarse así: “sumamos los números y dividimos entre 3”.

ii) Cuando vamos a programarlo, tenemos que: a- Declarar variables, b- mostrar un mensaje en pantalla para pedir cada número, c- leer los números, d- asignarlos la suma a una variable Total, e- Dividir el

total entre 3 y asignarlo a la variable Promedio, f- Mostrar un mensaje en pantalla indicando que se presentará el resultado, g-

Mostrar la variable Promedio.iii) ¿Puedes ver cómo el punto (i) “ignora” una serie de pasos y se

“concentra” en el proceso mismo?iv) El punto (ii) es más bien el “cómo se hace”, mientras el punto (i)

es el “qué hace”

• Cómo pasar de abstracción al detalle de la programación: paso a paso, dándole funcionalidad a cada componente. Cuando probamos esas partes o componentes, podemos identificar (ya que estamos imaginando las partes de cada objeto) cual es la que está fallando cuando interactúa con el resto.

• Abstracción en Programación Orientada a Objetos es programar imaginando que estamos inventando un “aparato mecánico”, y estamos construyendo y armando sus partes; cuando estamos probando el “aparato” y falla, identificamos cual “pieza” falla, la “rehacemos” y volvemos a probar.

• Gracias a que imaginamos que nuestros programas son objetos que interactúan, la abstracción es una herramienta muy poderosa ya que permite un fácil mantenimiento y actualización del software.

1.1.1 ENCAPSULAMIENTO

En programación orientada a objetos, se denomina encapsulamiento al ocultamiento del estado de los componentes de un objeto, de manera que sólo se pueden cambiar mediante las operaciones definidas para ese objeto.

El aislamiento protege a los datos asociados a un objeto contra su modificación por quien no tenga derecho a acceder a ellos, evitando que el usuario pueda cambiar su estado de maneras imprevistas e incontroladas.



La mejor forma de comprender el encapsulamiento es imaginar que todo objeto tiene un número determinado de “acciones” o

comportamientos, cada uno de los cuales se “activa” pulsando un botón. Cada botón le envía el mensaje al objeto para que procese y cambie sus atributos dentro de su “caja negra”. Más adelante en este curso veremos cómo para cada requerimiento de un objeto

tendremos que programarle un “botón”; finalmente, usar el objeto (correr el programa) consistirá en pisar los botones necesarios.

1.1.2 HERENCIA

En orientación a objetos la herencia es el mecanismo fundamental para implementar la reutilización y extensibilidad del software. A través de ella los diseñadores pueden construir nuevas clases partiendo de una jerarquía de clases ya existente (comprobadas y verificadas) evitando con ello el rediseño, la remodificación y verificación de la parte ya implementada.

La herencia facilita la creación de objetos a partir de otros ya existentes, obteniendo características (métodos y atributos, que es lo mismo que comportamiento y propiedades) similares a los ya existentes.

• Jerarquía de clases: se denomina así al diagrama o esquema que muestra la herencia que se transmite entre diversas clases.

Ilustración 23: Jerarquía de clases de transportes



Jerarquía de clases de transportes

¿Por qué es importante el concepto y la implementación de herencia en programación?. Considere lo siguiente:

• Cuando estamos haciendo programas, y en la medida que practicamos nuevos ejercicios y retos, comenzamos a notar que existen ciertas cuestiones o situaciones que se repiten, y pensamos “eso es similar a lo que hice en los otros programas”.

• Si logramos identificar los elementos y las características comunes a esas situaciones, podremos programar objetos que permitirán encapsular estas cuestiones repetitivas.

• Cuando nos enfrentemos a nuevos programas, y gracias a la herencia, podremos transmitir esas características a los nuevos objetos que estamos programando, y así simplificar la programación ya que parte del programa ya estará resuelto en la clase básica.

• Llegará un momento en que varios de tus programas heredan de una o varias clases básicas que has diseñado; imagina todo el tiempo que ahorraste al resolver todos esos programas ya que fue mucho lo que reutilizaste.

• Ahora, imagina que luego de haber reutilizado una docena de veces las clases base sucede que te das cuenta que había un error en ella. SOLUCIÓN: corriges SÓLO UNA VEZ y el ajuste se transmite a todos los programas derivados; si no heredaras, habrías tenido que corregir una docena de veces.

• Por otra parte, sucede que en determinado momento te das cuenta que puedes “mejorar” la clase base incorporándole nueva funcionalidad; de nuevo lo haces sólo una vez, y YA todos los programas derivados pueden hacer uso de esas nuevas características de la clase base.

• Las dos situaciones anteriores corresponden a mantenimiento y actualización del software, respectivamente, y es por eso que los programas orientados objetos son de fácil adecuación y mantenimiento.



Fíjate en la <Ilustración 23> cómo la herencia se produce en múltiples niveles. La herencia de características de clases es un

mecanismo que se puede aplicar en todos los ámbitos de los objetos del mundo real, y también modelarse para la programación con POO.

En Programación Orientada a Objetos el polimorfismo se refiere a la posibilidad de definir en una jerarquía de clases métodos y/o atributos denominados de forma idéntica, pero que se comportan de manera distinta.

Por ejemplo, podemos crear dos clases distintas: Pez y Ave que heredan de la superclase Animal. La clase Animal tiene

el método abstracto mover que se implementa de forma distinta en cada una de las subclases (peces y aves se mueven de forma

distinta).

Como ves, el polimorfismo tiene que ver con la herencia y la posibilidad de que las clases derivadas se comporten de manera diferente para componentes de mismo nombre. Lee detenidamente los siguientes planteamientos y aclara mejor la idea del polimorfismo:



Ilustración 24: Demostración de un caso de polimorfismo

Hay algunos aspectos de la importancia del polimorfismo que no se ven claramente en una ilustración como la anterior. Observe:

• La clase Persona seguramente servirá de Clase Base para ser utilizada múltiples veces en innumerables aplicaciones. Lo mejor en este caso será crear una librería reutilizable (compilándola) de la clase Persona.

• Las aplicaciones que usan a Persona en clases derivadas necesitarán calcular de otras maneras el TotalCapital, pero sin recompilar la clase base.

• Luego, es claro que el TotalPatrimonio de una persona sería el TotalCapital menos el TotalDeudas; pero observa que en las clases derivadas sólo está el cálculo de TotalCapital. Gracias a la herencia todos esos totales sí están disponibles en las clases derivadas.

• Entonces sucede el polimorfismo cuando queremos calcular el Disponible: la aplicación del estudiante pregunta por el TotalPatrimonio (que está en persona), pero como la clase derivada tiene “repetido” el TotalCapital,



Para cada clase derivada también cuenta BsEnBancoPara Estudiante hay que sumarle Computador y CelularPara Profesor hay que sumarle Carro y Casa

El TotalCapital para las clases derivadas tendrá algunas variantesClase Estudiante- ValorComputador- ValorCelular- TotalCapital

La clase base Persona con sus componentes (Propiedades: Nombre, Cedula, BsEfectivo, BsDebe, Comportamiento: cálculos de Totales)Demostración de un caso de polimorfismoClase Persona- Nombre- Cédula- BsEfectivo- BsDebe- TotalCapital- TotalDeudas- TotalPatrimonio

Clase Profesor- ValorCarro- ValorCasa- TotalCapital

Asumiremos de la manera más elemental, que el TotalCapital de cualquier persona es el dinero en efectivo que tiene, y TotalDeudas es lo que debe en efectivo; así, TotalPatrimonio es la diferencia entre los totales anterioresCon estas flechas queremos denotar que hay una herencia entre las clases señaladasUn profesor es una persona; componentes adicionales: ValorCarro y ValorCasaUn estudiante es una persona; componentes adicionales: ValorCelular y ValorComputador

entonces el cálculo se hará con la fórmula correcta que está en estudiante; de manera similar sucederá con la clase derivada Profesor.

• Incluso, fíjate que la ilustración señala que el TotalCapital para el estudiante hay que “sumarle” Computador y Celular; es decir: también se cuenta BsEfectivo. Algo similar podrás observar en la clase derivada Profesor.

• Es decir: la fórmula en estudiante para el cálculo del TotalCapital será algi así: Estudiante.TotalCapital = Persona.TotalCapital + ValorComputador + ValorCelular. Fíjate que se re-usa el cálculo base del TotalCapital.

Una aplicación “Estudiante”, según la <Ilustración 24>, cuando pregunte por TotalPatrimonio estará invocando un

comportamiento de clase Persona, quien tiene TotalCapital PERO como clase estudiante también lo tiene, entonces se invoca es el segundo.

Esto sucede SIN NECESIDAD DE RECOMPILAR la clase base Persona.

El momento cuando se enlazan los comportamientos entre las clases de una jerarquía de clases da lugar a los siguientes tipos:

• Métodos Estáticos: se conocen cuando se compila un programa. Todos los métodos (comportamientos) de las clases están disponible al momento de compilar.

• Métodos Dinámicos: propios del polimorfismo; se conocen en tiempo de ejecución, es decir cuando se está corriendo el programa.

En nuestro ejemplo de la clase base persona, supón que la clase base persona se compiló hace 2 años, y hoy compilas la clase estudiante, entonces fíjate que al calcular TotalPatrimonio (que está en Persona de hace 2 años) estarás usando TotalCapital (que está en Estudiante, de hoy), y todo sin recompilar la clase base.


a) ¿Cómo podrías describir con tus palabras la abstracción? R. podrías decir que son las fórmulas, los cálculos o los pasos que a la final te darán la respuesta a los requerimientos de los problemas, pero sin mencionar pasos “obvios”, como por ejemplo leer datos o mostrarlos, borrar la pantalla, etc.

b) ¿Cómo interpretas el concepto de caja negra usado en sistemas? R. Es como el encapsulamiento, donde sabes lo que hace un objeto pero no sabes cómo lo hace. Cuando “pisas” los botones de los objetos, entonces “sabes” lo que debe hacer, pero no conoces el funcionamiento interior (cómo lo hace).



c) ¿Qué significa que un lenguaje de programación te proporcione más o menos nivel de abstracción? R. En la medida que un lenguaje de programación te permita simular (o modelar) mejor las situaciones de la vida real, te proporciona mayor nivel de abstracción.

d) ¿De qué otra forma podrías denominar a la abstracción? R. podríamos decir que es la lógica asociada a un planteamiento, la forma más medular (más simple) para resolverlo.

e) Cómo podrías abstraer el siguiente planteamiento: “Dada la edad de una persona, determinar si es o no mayor de edad.” R. Si la edad es mayor a 17, es mayor de edad.

f) Plantea la abstracción para el siguiente problema: “A un vendedor se le asignará una comisión del 5% si sus ventas son hasta Bs. 500.000, el 10% si son hasta Bs. 1.000.000, y el 15% si vende más de 2.000.000. Calcular la comisión”. R. Si venta < 500000 => comisión = venta * 0,05, si venta <= 1000000 => comisión = venta * 0,1, sino es venta * 0,15.

g) Describe en términos de abstracción: “En la UCLA a cada estudiante le suministra su nota en una escala de 100 puntos, ¿Cuánto sacó sobre 20?”. R. es una regla de 3: si en 100 es X, en 20 será Y.

h) ¿Cómo podrías describir con tus palabras el encapsulamiento? R. es como la cubierta que se les pone a todo “aparato electrónico”, el cual luego sólo puede operarse a través de sus “botones”, dejando dentro toda una serie de componentes inaccesibles. Ej. Un ratón encierra toda una circuitería interna, pero tiene 2 ó 3 botones para operarlo, además que arrastrarlo también sirve para algo; unas cornetas tiene cables y conectores, pero seguramente tendrán para operarlo solamente un botón de encendido y un botón de volumen.

i) ¿Qué reglas deberás seguir para garantizar que tus programas orientados a objetos queden encapsulados? R. i) todos los atributos deberán ser privados o protegidos cuando uses herencia, ii) Cada atributo debe tener un método que le asigne un valor (Set), iii) Cada atributo debe tener un método que permita devolver su valor (Get).

j) Una cuenta de correo electrónico es un concepto abstracto, haciendo analogía con un buzón físico de correo, ¿cómo puedes identificar allí la abstracción? R. La abstracción está cuando imaginas que la lista de mensajes recibidos son el buzón de entrada, y que también tienes un buzón de salida, etc. Nota que una persona que nada sabe de computación también manejaría esos términos, pero los asociaría con una “caja de madera” (el buzón) y que los correos son sobres que contienen papeles. Tú también usas esos términos pero de forma análoga, así simplificas su entendimiento.

k) Cómo puedes aplicar herencia en varios niveles de jerarquía a los teléfonos. R. Defines una clase básica “Teléfono” cuyos miembros serán: propietario, número, tipo (analógico, digital), marcar, colgar, enmudecer; Un “teléfono fijo” hereda de “Teléfono”, con miembros: memoria, guardar número, remarcar, altavoz; Un “Tele-fax” hereda de “Teléfono fijo”, con miembros: resolución, velocidad transferencia, recibir fax, enviar fax; Un “teléfono público” hereda de “Teléfono”, con miembros:



ubicación, revisar saldo tarjeta, descontar saldo tarjeta. Nota que todos esos teléfonos comparten los miembros del teléfono básico.

l) ¿Qué significa la jerarquía de clases en una implementación de herencia? R. Significa que tienes herencia en múltiples niveles; una clase B hereda de una clase base A, luego una clase C hereda de la clase derivada B, convirtiéndola así en una clase base de otro nivel. Un diagrama de jerarquía de clases demuestra gráficamente la herencia que se produce entre distintas clases, representando de alguna manera que las clases derivadas se asocian con la clase base respectiva.

m) Plantea la abstracción para el siguiente problema: “Para una discoteca irán varias personas, entre chicos y chicas; la entrada de un chico cuesta Bs. 40, para una chica le cuesta el 50%, ¿Cuánto dinero deberán llevar cada grupo para que puedan entrar?”.

n) ¿Cómo podrías describir con tus palabras la herencia?o) ¿Cómo podrías describir con tus palabras el polimorfismo?p) Describe en términos de abstracción: “Dado un número entero, determinar si el

mismo es positivo o negativo”.q) Describe en términos abstractos: “Dado el saldo actual de una cuenta bancaria, el

tipo de una nueva operación (R:etiro, D:epósito) que se realizó y el monto de la misma, determinar el nuevo saldo de la cuenta”.

r) Describe en términos de abstracción: “En la UCLA hay 5 decanatos y se conoce de cada uno: el número de alumnos que se retiraron y el porcentaje que representan, ¿Cuántos alumnos quedan inscritos en cada decanato?”.

s) Según lo visto hasta ahora, ¿cómo logras el encapsulamiento cuando haces un programa con POO?

t) Identifica la herencia que puedes idear del siguiente planteamiento: “Un triángulo y un círculo son figuras geométricas con su área y perímetro, cada uno con su fórmula particular”.

u) ¿Cómo podrías aplicar polimorfismo al ejemplo de las figuras geométricas?v) Identifica la herencia que puedes aplicar a los electrodomésticos que usas en casa.w) Cómo puedes aplicar herencia a los distintos tipos de cuentas bancarias sabiendo que

toda cuenta tiene un número y un titular, una cuenta de ahorros paga intereses, una cuenta corriente cobra comisión y el plazo fijo es un caso especial de cuenta de ahorros donde el dinero se deposita durante un lapso de tiempo establecido.

x) ¿Cómo podrías aplicar polimorfismo al ejemplo de los electrodomésticos?y) ¿Cómo podrías aplicar polimorfismo al ejemplo de los teléfonos?a) Respuestas en la página respuestas a ejercicios propuestos. Antes de verlas, procura




1 IDENTIFICACIÓN DE OBJETOS

En programación te enfrentarás a innumerables situaciones donde tendrás que “identificar” o visualizar cuales son los objetos que intervienen en cada planteamiento.

En la etapa de análisis, se deben identificar cuáles son los objetos presentes en el dominio del problema, es decir, se debe determinar el objeto o colección de objetos que el programa debe representar y manejar, para solucionar la situación planteada.

Una técnica a seguir para lograr la identificación de los objetos es subrayar cada sustantivo (nombre) presente en el planteamiento del problema. Ej:

➢ Hacer un programa que permita leer las operaciones realizadas a una cuenta bancaria y determinar al final el saldo de la misma.

➢ Se desea determinar la nota final de un estudiante sabiendo que presentó 3 pruebas parciales.

➢ En una organización laboran varios trabajadores que tienen un sueldo base, asignaciones y deducciones. Se desea determinar el sueldo neto de cada trabajador.

Considere lo siguiente al momento de identificar los objetos que participan en un planteamiento:

➢ Posiblemente subrayarás múltiples sustantivos, no todos tendrás que usarlos en tu programa.

➢ Inicialmente cuando haces el subrayado, lo que tienes es varias objetos candidatos (candidatos a ser el objeto que usarás).

➢ Producto de un análisis más detallado terminarás determinando cual (o cuales) objetos serán los definitivos.

➢ Los objetos que determinas que no usarás simplemente forman parte de la redacción del enunciado, pero no de la solución del problema. De alguna manera u otra estos objetos que no usarás te servirán para comprender la información que te suministra el planteamiento.

Algunos criterios a seguir para identificar los objetos son:

➢ Cosas tangibles (mesa, carro, avión).



➢ Organizaciones (empresa, departamentos, divisiones)

➢ Incidentes (representa un suceso, Ej: vuelo, inscripción, transacción).

➢ Papeles o roles (cliente, empleado, médico).

➢ Interacciones (compras, ventas).

➢ Lugares (ciudad, muelle de carga, sala de embarque).

1.1 TÉCNICAS PARA IDENTIFICAR OBJETOS Y COMPONENTES

Cuando te enfrentes a una situación de identificación de objetos, podrás aplicar la siguiente técnica que te permitirá identificar rápidamente los objetos que participan en un enunciado y también su composición.

Revisa el planteamiento e identifica las entidades, tal como se explicó previamente.

Identifica la información con la que contarás para la entrada de datos.

Identifica los requerimientos que se hacen; los requerimientos es lo que te pide el problema que hagas.

Finalmente, la información que identificaste seguramente se convertirá en atributos, mientras que los requerimientos se convertirán en métodos.

Tendrás que asociar a cuál de los objetos seleccionados para el problema pertenece cada atributo y método identificado.

Observa el siguiente ejemplo:

Ilustración 25: Identificación de objetos y sus componentes (Ejemplo Organización).



En una organización laboran varios trabajadores que tienen un sueldo base, asignaciones y deducciones. Se desea determinar el sueldo neto de cada trabajador y el total a pagar por la empresa.

Identificación de objetos y sus componentesInformación de entrada: sueldo base, asignaciones, deduccionesObjetos candidatos: organización, trabajadores, trabajador, empresaRequerimientos: determinar el sueldo neto de cada trabajadorImportante: en ocasiones la información de entrada está implícita

Debes tener presente lo siguiente cuando haces el análisis a planteamientos:

No siempre está directa la información en el planteamiento; con frecuencia tendrás que hacer indagatorias para aclarar lo requerido.

Es frecuente observar planteamientos que tienen cierta información implícita, o sobreentendida. Ej: “determinar la nota final de un estudiante del DCyT dadas sus notas parciales”, en este caso quedará sobreentendido que son 3 pruebas parciales.

Para aquellos ejercicios donde se considere que intervienen múltiples instancias de un mismo objeto (Ej: “laboran varios trabajadores”), es posible que esta aseveración termine necesitando un atributo de tipo Arreglo que permita almacenar a todas las instancias.

Todos los programadores se enfrentan a problemas que plantean los clientes, pudiendo considerar como clientes: el profesor (cuando resuelves ejercicios asignados), tú mismo (cuando te planteas algún problema) o cualquier persona a la que le prestes un servicio de programación.

Las necesidades de los clientes (requerimientos) las conocen mejor ellos mismos, pero en ocasiones no están bien especificadas, o están confusas; recuerda que como “cada cabeza es un mundo”, lo que a ti te parece ser claro no necesariamente lo es para otros.

En vista de lo anterior, la solución es indagar con el cliente (lo que se conoce en materia de Sistemas como Levantamiento de Información) todo detalle necesario para aclarar los requerimientos.

Quiere decir, cuando un planteamiento sea ambiguo, debes remitirte al cliente para resolver la situación: si es un ejercicio de clase, acude a tu profesor para que te aclare, si es un ejercicio tuyo, rehaces el planteamiento, si es un tercero lo abordas e investigas.

1.1 EJEMPLIFICACIÓN DE REQUERIMIENTOS

La forma más inequívoca de expresar los requerimientos es con la formulación de al menos una situación que ejemplifique lo que se necesita.

Ejemplificar requerimientos es en programación de computadoras similar a:

Una maqueta de un centro comercial, presentada por un arquitecto.

La radiografía de un hueso roto que muestra un doctor.



El dibujo de un vestido que presenta un diseñador.

Una tabla con la información de sueldos de los trabajadores de la organización

Nota que todas las situaciones mencionadas presentan visualmente lo requerido por parte de un cliente:

Construir un Centro Comercial, que es requerido por un inversionista con mucho dinero que no sabe nada de Ingeniería Civil.

Enyesar un brazo, que es requerido por una persona herida.

Elaborar un vestido, que es requerido por la novia que va a casarse.

Hacer un programa que determine el sueldo neto de cada trabajador y el total a pagar por la empresa.

Lo más común en el planteamiento de problemas de programación es que te enfrentes a un texto con la redacción

de requerimientos, o sea un montón de palabras. Cuando se hace la ejemplificación de lo requerido, logras una completa comunicación

con el cliente y lo que necesita.

Todo esto sucede ya que el análisis, interpretación y deducción de requerimientos forman parte del perfil de un programador. Imagina lo siguiente:

El inversionista le pedirá al Ingeniero Civil un Centro Comercial con fuentes aéreas, 50 locales donde caben 20, todas las paredes de madera, etc.

La persona herida pedirá que se cure lo más rápido posible y sin yeso.

La novia querrá un vestido multicolor, con diversos tipos de acabados, retoques, adornos.

En fin: SEGURAMENTE EL CLIENTE SABE LO QUE QUIERE PERO NO CON TODO DETALLE Y ADEMÁS ESPERA DEMASIADO, el especialista (Ing. Civil, Doctor, Diseñador) indagará y logrará un MODELO POSIBLE (maqueta, radiografía, dibujo) de lo requerido, antes de proceder a la solución propiamente.



El planteamiento de problemas de programación seguramente no contará con todo detalle, tendrás que abordar al cliente y

lograr mayores especificaciones a fin de que puedas crear una EJEMPLIFICACIÓN CON LA QUE ESTÉN AMBOS EN ACUERDO.

Finalmente, cuando logras la ejemplificación de los requerimientos de un planteamiento tendrás mucho más claros los componentes que intervienen.

TABULACIÓN DE LA INFORMACIÓN Y REQUERIMIENTOS DE LA ORGANIZACIÓN

RegistroInfo Nombre Sueldo base Asignaciones Deducciones Sueldo neto

1 Carla 1500,00 500,00 300,00 1700,00

2 Luis 2500,00 200,00 400,00 2300,00

3 Marielena 1800,00 300,00 100,00 2000,00

4 Rafaela 3000,00 500,00 1000,00 2500,00

Total a pagar por la empresa: 8500,00

Tabla 7: tabulación de información y requerimientos (ejercicio de la organización)

1.1 EQUIVALENCIAS ENTRE EJEMPLIFICACIÓN TABULADA Y POO

Cuando logras la ejemplificación tabulada de un planteamiento podrás visualizar más fácilmente los elementos que intervienen, observa la ilustración:



Ilustración 26: Identificación de objetos y miembros por ejemplificación tabulada.

Cuando un valor se obtiene con un cálculo con atributos y/o otros cálculos, entonces estamos frente a un método.

1.2 EL CONTROL REMOTO DE LOS OBJETOS

Recuerda que los objetos en POO representan el mundo real en el contexto del planteamiento que estamos resolviendo para cada problema, y encapsulan los componentes respectivos, atributos y métodos.

Así, otra técnica para identificar los componentes de los objetos es precisamente imaginarlos como un aparato (o robot) que opera con un control remoto, donde:

El aparato tiene componentes internos, que tal vez no sea preciso visualizarlos en primera instancia (están encapsulados). Estos componentes internos serán los atributos y métodos.

También tiene botones, cada uno de los cuales permitirá resolver un requerimiento del problema.

Cuando presionamos los botones, según necesitemos, el objeto realizará algunas acciones (procesos) que alterarán los atributos, o bien nos mostrarán el resultado de lo que deseamos hacer.



Identificación de objetos y miembros por ejemplificación tabuladaToda la tabla representa la información del objeto OrganizaciónCada registro muestra la información de un objeto trabajadorLos datos de entrada por columnas serán atributos del trabajadorCálculos por registro serán métodos del trabajadorCálculos totales de la tabla serán métodos de la organizaciónDatos generales de entrada serían atributos de la organización. Para este ejemplo, podría ser el total que dispone la empresa para pagar sueldos. Así, si se pide el restante luego del pago, tendríamos otro método para organización: TotalRestante.

Los botones servirán entonces tanto para que veamos el funcionamiento de nuestro programa, como para que los objetos que lo conforman se comuniquen entre sí.

Es más, imagina que el objeto está en la pantalla del computador y la única forma de operarlo es con los botones del teclado. En ocasiones, esta práctica será la mejor alternativa para identificar los componentes de un objeto.

Observa el siguiente requerimiento: “describir en términos de objetos al cielo”. Ok, imaginemos que el cielo está en la pantalla del computador.

Ilustración 27: El cielo en la pantalla del computador.

Ahora, recuerda que no puedes hacer nada con el cielo si no es a través del teclado de la computadora. ¿Qué quieres que haga el cielo?, ¿qué atributos tiene el cielo?. Las respuestas a estas preguntas te permiten identificar los componentes del objeto aunque sea intangible:

¿Qué atributos tiene?, p.ej: cantidad de nubes, color, muestra el sol (si o no), con arco iris (si o no), está lloviendo (si o no), qué turno muestra (día, atardecer, noche), etc.

¿Qué quieres que haga?: que cambie de turno, que llueva, que muestre el sol o la luna, que incremente la cantidad de nubes, que muestre el arco iris.

Entonces haces que cada acción se convierta en un botón de tu control remoto, y ahora puedes operar el objeto cielo.



Ilustración 28: El control remoto del cielo.

Fíjate cómo cuando usas el control remoto del cielo entonces empieza a cobrar sentido de cuáles son los métodos que tendrás que implementar; dentro de cada método estará el proceso necesario (encapsulado) para cada cosa:



Cambiar TurnoLloverMostrar solMostrar lunaMás nubesArco Iris

Ilustración 29: funcionamiento del control remoto del cielo.

Observa este otro caso con el ejemplo de la organización y los trabajadores, así empezará la organización en la pantalla del computador:

Ilustración 30: El ejemplo Trabajadores en la pantalla del computador.

¿Qué quieres o qué necesitas hacer?: incluir empleados, eliminar empleados, mostrar sueldos netos, mostrar totales, entre otros.

Observa en la ilustración cómo los botones del control remoto hacen que funcione tu programa.



Más nubesCambiar turnoCambiar turnoMostrar SolArco IrisLlover

Ilustración 31: funcionamiento del control remoto del problema Organización.

Visualizar objetos operados en la pantalla del computador, a través de un control remoto, facilita la identificación de los

métodos que necesita el objeto.Como una primera muy buena aproximación, cada requerimiento de un problema, y cada cálculo sobre la base de los datos de entrada, se convertirá en un método del objeto respectivo, el cual se activa

con un botón (imagínalo).

1.1 EJERCICIOS RESUELTOS Y PROPUESTOS a) Circo: En el siguiente planteamiento identifica los sustantivos que participan, objetos

candidatos y objetos finales: “Para un espectáculo de circo se tienen 3 tipos de entrada: niños, adolescentes y adultos (hasta 12 años, hasta 18 y mayores de 18, respectivamente); conociendo la cantidad de personas de cada tipo que viene por familia, ¿Cuánto dinero paga cada familia?. Procese varias familias”. R. Se muestran resaltadas las entidades en el planteamiento. Los objetos finales serán: Espectáculo y Familia, donde un espectáculo procesará varias familias; también podría ser Circo – Familia. El resto de entidades son candidatas: entrada, persona, dinero.

a) UCLA: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: “En la UCLA hay 5 decanatos y se conoce de



Agregar trabajadorMostrar sueldo netoAgregar trabajadorTotalizar empresaAgregar trabajadorAgregar trabajador

cada uno: el número de alumnos que se retiraron y el porcentaje que representan, ¿Cuántos quedan inscritos por decanato?, ¿Cuántos en la UCLA?”. R. Las entidades están resaltadas. Los objetos definitivos serán: UCLA y Decanato, teniendo la UCLA varios decanatos. Observa que la información requerida se refiere a los decanatos.

b) Estado civil: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: “Dado el estado civil de una persona, determinar la prima a pagar por un seguro según lo siguiente: Solteros o Viudos 10%, Casados 15%, Divorciados 20%. Calcular el monto de la prima dado el estado civil de la persona y el valor del bien a asegurar”. R. Objeto final: Persona. Debes observar en el planteamiento que todo lo requerido se trata de una entidad única: la persona.

c) Empresa: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: “En una empresa se asignará un aumento del 10% a todo el personal obrero y un 5% al personal administrativo. Calcular el nuevo sueldo de un empleado dado su tipo y sueldo actual”. R. Nota que lo requerido se refiere a un solo empleado; el objeto final será Empleado.

d) Banco: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: “En un banco el dinero disponible de la cuenta de un cliente se calcula restando al total depositado el total de retiros y el total de comisiones al banco. Teniendo el monto de creación del banco y la información de varios clientes, ¿Cuánto dinero le quedará a cada uno?, ¿Cuánto al banco?”. R. Los objetos finales serán Banco y Cliente, donde un banco tiene muchos clientes.

e) Profesores: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: “A un profesor le pasaron varios alumnos y se le quedaron unos pocos, ¿qué porcentaje de los alumnos aprobaron y qué porcentaje reprobó? Procese esta información para varios profesores; ¿Qué porcentaje resulta para la Universidad?”. R. los objetos serán: Universidad y Profesor; la universidad es la que tendrá varios profesores.

f) Para el ejercicio del Circo identifica los atributos de los objetos, requerimientos y la abstracción de la solución. R. Se requiere la cantidad que paga cada familia. Los atributos de una familia: Cantidad de niños, de adolescentes y de adultos. Ya que no se indica el precio de cada entrada, asume por ejemplo 10, 15 y 20. Se procesa cada familia y se multiplica la cantidad de niños por 10, adolescentes por 15 y adultos por 20. El circo no necesita atributos ya que este solamente leerá los datos de las familias sin hacer ningún cálculo, la cantidad que paga cada familia lo procesa ella misma.

g) Para el ejercicio de las Letras (Letras: En el siguiente planteamiento identifica lossustantivos que participan, objetos candidatos y objetos finales: “Dadas variasletras, determinar: la cantidad y el porcentaje de vocales procesadas”.) identifica los atributos de los objetos, requerimientos y la abstracción de la solución. R. Requerimientos: 1- Cantidad de vocales, 2- Porcentaje de vocales. Del objeto letra el



atributo será carácter; del objeto letras serán un contador de vocales y uno de consonantes.

h) Para el ejercicio de los Billetes (Describe en términos de objetos (3 atributos y 3comportamientos):) realiza una ejemplificación con al menos 5 registros (si aplica). Demuestra la correspondencia con los componentes de los objetos. R. las columnas Cant5,... Cant50 son atributos de la persona, BsTotal es método de la persona.

EJEMPLIFICACIÓN DEL EJERCICIO DE LOS BILLETES

RegistroPersona Cant5 Cant10 Cant20 Cant50 BsTotal

1 0 1 2 0 50,002 3 0 1 2 135,003 2 2 2 0 70,004 5 1 0 1 85,00

Tabla 8: Ejemplificación del ejercicio de los billetes

i) Para el ejercicio de los Artículos (Artículos: En el siguiente planteamiento identificalos sustantivos que participan, objetos candidatos y objetos finales: “Una personacompra un artículo a un valor de costo, si quisiera ganarle el 50% de lo invertido ¿encuánto debería venderlo?, ¿en cuánto si quisiera el 50% del precio de venta?. Repitael proceso para re-calcular hasta que el usuario lo indique”.) realiza una ejemplificación con al menos 5 registros (si aplica). Demuestra la correspondencia con los componentes de los objetos. R. CostoArt es atributo de la persona y PVP50AlCosto y PVP50AlPVP son métodos de la persona

EJEMPLIFICACIÓN DEL EJERCICIO DE LOS ARTÍCULOS

RegistroPersona CostoArt PVP50AlCosto PVP50AlPVP

1 1000,00 1500,00 2000,002 2000,00 1000,00 4000,003 500,00 750,00 1000,004 3000,00 4500,00 6000,00

Tabla 9: Ejemplificación del ejercicio de los artículos

j) Para el ejercicio de los Sobres de dinero (Sobres de dinero: En el siguienteplanteamiento identifica los sustantivos que participan, objetos candidatos y objetosfinales: “Se tienen 20 sobres con dinero, cada uno con billetes del mismo valor. Decada sobre se conoce el valor del billete y la cantidad. Se requiere determinar eltotal de dinero entre todos los sobres”.) realiza una ejemplificación con al menos 5 registros (si aplica). Demuestra la correspondencia con los componentes de los objetos. R. Valor y CantidadBillete son atributos del sobre; BsTotalSobre es método del sobre; TotalDinero es atributo y propiedad de la caja.



EJEMPLIFICACIÓN DEL EJERCICIO DE LOS SOBRES DE DINERO (muestra con 4 sobres)

RegistroSobre ValorBillete CantidadBilletes BsTotalSobre

1 50 10 500,002 20 15 300,003 100 2 200,004 10 25 250,00

Total de dinero 1250,00Tabla 10: Ejemplificación del ejercicio de los sobres de dinero

k) Describe en términos de objetos (3 atributos y 3 comportamientos):• El arco iris: atributos= cantidad de franjas, diámetro, altura;

comportamiento= aumentar brillo, crecer/decrecer diámetro, aumentar altura.

• El aire: atributos= color, olor, humedad; comportamiento= cambiar temperatura, ventear, formar nube.

• Un árbol: atributos= Nro ramas, Nro hojas, Color hojas; comportamiento= florecer, dar frutos, crecer.

• La felicidad: atributos= intensidad, duración, inicio, fin; comportamiento= intensificar, terminar, reiniciar, establecer tiempo.

a) Billetes: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: “Sabiendo cuantos billetes de 5, 10, 20 y 50 tiene una persona en su cartera, calcular la cantidad total de dinero con que cuenta. Hacer el cálculo para varias personas”.

b) Artículos: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: “Una persona compra un artículo a un valor de costo, si quisiera ganarle el 50% de lo invertido ¿en cuánto debería venderlo?, ¿en cuánto si quisiera el 50% del precio de venta?. Repita el proceso para re-calcular hasta que el usuario lo indique”.

c) Sueldo: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: “Si un empleado gana un sueldo básico y además se le asigna una comisión del 25% sobre las ventas que realizó, determinar cuánto cobrará el empleado. Procesar esta información para varios empleados”

d) Enelbar: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: “ENELBAR cobra por servicio de la siguiente manera: si consumió menos de 1000 impulsos cada uno costará Bs. 0,01, si consumió menos de 2000 costará Bs. 0,08 y Bs. 0,05 si consumió al menos 2000. Calcular el monto a pagar a ENELBAR dada toda la información necesaria”.

e) Nota apreciativa: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: “Una nota mayor a 80 puntos es



excelente, mayor de 50 es bueno, mayor de 30 es deficiente y si no es malo. Determinar la condición de un alumno dada su nota final”.

f) Sobres de dinero: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: “Se tienen 20 sobres con dinero, cada uno con billetes del mismo valor. De cada sobre se conoce el valor del billete y la cantidad. Se requiere determinar el total de dinero entre todos los sobres”.

g) Pares de números: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: “Dado varios pares de números, determinar el porcentaje de pares donde ambos suman más de 10”.

h) Letras: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: “Dadas varias letras, determinar: la cantidad y el porcentaje de vocales procesadas”.

i) Para el resto de los ejercicios anteriores identifica los atributos de los objetos, los requerimientos y la abstracción de la solución.

j) Para el resto de los ejercicios realiza una ejemplificación con al menos 4 registros (si aplica). Demuestra la correspondencia con los componentes de los objetos.

k) ¿Qué nemotecnia puedes aplicar para identificar en las tablas de ejemplos los componentes de los objetos involucrados?

l) Describe en términos de objetos (3 atributos y 3 métodos): 5- el estudio, 6- la luz, 7- un número, 8- un poco de agua, 9- una cuerda, 10- un pañuelo, 11- un vidrio, 12- la flama de un fósforo, 13- el chorro de agua de una manguera, 14- una tela que va cayendo.

m) Respuestas en la página respuestas a ejercicios propuestos. Antes de verlas, procura tu mayor esfuerzo y resuelve.

1



2 REPRESENTACIÓN DE CLASES

Existe una nomenclatura universal usada para representar clases y las relaciones entre ellas. Se trata del Lenguaje de Modelado Unificado (UML), el cual es la unificación (estandarización) de los métodos de modelado orientado a objetos de varias investigaciones a nivel mundial.

Para este curso básicamente nos interesa el Diagrama de Clases, aunque existen muchos diagramas más que conforman el UML.

2.1 UML

UML es un Lenguaje de Modelado Unificado basado en una notación gráfica la cual permite: especificar, construir, visualizar y documentar los objetos de un sistema programado.

2.2 NOTACIÓN GRÁFICA DE CLASES CON UML

En UML, las clases se representan mediante un rectángulo que está dividido en tres partes:

Ilustración 32: Representación de una clase según la notación UML.



Fecha- dia : int- mes : int- anno : int

+ Fecha ()+ Fecha (d:int, m:int, a:int)+ SetDia (d:int)+ SetMes (d:int)+ SetAnno (d:int)+ GetDia () :int+ GetMes () :int+ GetAnno () :int

Nombre del objetoPrivado (-)Público (+)Protegido (#)AtributosOperaciones (Métodos)Representación de una clase según la notación UML

La visibilidad (público, privado, protegido) establecerá la forma como el miembro será accesible o no a las clases derivadas cuando se utiliza herencia. Público: está visible para todas las clases derivadas y también para las instancias de objetos; Privado: no visible para las clases derivadas ni instancias; protegido: visible para clases derivadas pero no para objetos.

EFECTO DEL TIPO DE VISIBILIDAD DE MIEMBROS

ÁmbitoMiembro Público Privado Protegido

Misma clase Los miembros están disponiblesClase derivada Disponible No disponible Disponible

Instancias Disponible No disponible No disponibleTabla 11: Efecto del tipo de visibilidad de miembros

Para representar un atributo en un diagrama de clases ( revisa el tópico Sintaxis de comandos de programación de sintaxis, página Sintaxis decomandos de programación):

Ilustración 33: Sintaxis para representar los atributos en la clase, según UML.

Para representar un método en un diagrama de clases:

Ilustración 34: Sintaxis para representar los métodos en la clase, según UML.



Visibilidad <nombre>: tipo [= valor inicial]Privado (-), público (+), protegido (#)Nombre del atributoTipo de dato del atributoEl valor inicial es opcionalSintaxis para representar los atributos en la clase, según UML

visibilidad nombre ([lista de parámetros]): tipo retornoPrivado (-), público (+), protegido (#)Nombre del atributoArgumentos del método (opcionales). Los paréntesis siempre debes colocarlos.El tipo de valor que retornaSintaxis para representar los métodos en la clase, según UML

2.3 RELACIONES ENTRE CLASES - DIAGRAMAS DE CLASES

La solución a problemas de programación seguramente mostrará que se necesitan distintas clases que se relacionarán entre ellas para producir los resultados que requiere cada problema.

De esta manera, será preciso mostrar todas las clases en un diagrama de clases, donde también se muestran las relaciones que existen.

En UML, un diagrama de clases es un tipo de diagrama estático que describe la estructura de un sistema mostrando sus clases, componentes y las relaciones entre ellos.

Observa el diagrama de clases que te presentamos a continuación; no profundizaremos en el tema de notación UML ya que este objetivo de aprendizaje se abordará en otro momento de este curso.

Ilustración 35: Diagrama de clases base para ejemplo de la Organización.

2.4 PASO DE MENSAJES

Una aplicación orientada a objetos consiste en un número determinado de objetos que interactúan entre sí enviándose mensajes unos a otros para invocar



Organización- ArrayTrabajadores : vector- BsDisponeParaSueldos : float- SetBsDisponeParaSueldos (Bs : float)- GetBsDisponeParaSueldos () : float- IncluirTrabajador (Nomb...)- GetTotalNomina () : float::::::::::::

Trabajador- Nombre : string- SueldoBase : float- Asignaciones : float- Deducciones : float- Sets...- Gets...- CalcularSueldoNeto () : float::::::::::::

11..*

En este caso la relación se llama composición, ya que la organización está compuesta por varios trabajadores. Los números indican: una organización tiene al menos 1 trabajador (1..*), pero un trabajador siempre pertenece a una organizaciónEl diagrama de clases muestra todas las clases que participan en la solución del problema y las relaciones entre ellas.Diagrama de Clases (incompleto) del ejercicio de la Organización

sus métodos. Este intercambio de mensajes facilita su comportamiento, cambios de estado, destrucción o almacenamiento.

Ya que todo lo que un objeto puede realizar está expresado en sus métodos, este simple mecanismo de mensajes soporta todas las posibles interacciones entre ellos.

Mediante el paso de mensajes, un objeto puede solicitar de otro objeto que realice una acción determinada o que modifique su estado.

El paso de mensajes se suele implementar como llamadas a los métodos de otros objetos

2.5 EJERCICIOS RESUELTOS Y PROPUESTOS a) ¿Por qué es importante una representación gráfica de las clases? R. una

representación gráfica de clases es una forma sintética de mostrar los objetos que participan en un problema; permiten obtener una visión general de la solución.

a) ¿Podrías hacer alguna analogía de lo que significa la elaboración del diagrama de clases? R. un diagrama de clases es como una maqueta en materia de Arquitectura; las maquetas permiten tener una idea más exacta de cómo quedará la obra final.

b) Realiza el diagrama de clases para el siguiente planteamiento: “Dadas varias letras, determinar: la cantidad y el porcentaje de vocales procesadas”. R.

c) Realiza el diagrama de clases para el siguiente planteamiento: “Sean 20 sobres con dinero, cada uno con billetes del mismo valor. De cada sobre se conoce el valor del billete y la cantidad. Determinar el total de dinero entre todos los sobres”. R.



Letras- ContaVocal : int- ContaTotal : int- DetCantVocales () : int- DetPorcVocales () : float

Letra- Caracter : char- EsVocal () : boolean

11..*

Caja- AcumulaDinero : int- DetTotalDinero () : float

Sobre- ValorBillete : int- CantBilletes : int- DetBsTotalSobre () : float

11..*

d) Realiza el diagrama de clases para el siguiente planteamiento: “Dado el estado civil de una persona, determinar la prima a pagar por un seguro según lo siguiente: Solteros o Viudos 10%, Casados 15%, Divorciados 20%. Calcular el monto de la prima dado el estado civil de la persona y el valor del bien a asegurar” R.

e) Si un atributo es de tipo privado, ¿podrás hacer referencia a él en alguna instancia?f) ¿Qué tal si el atributo sea protegido?g) ¿La visibilidad sólo se aplica a los atributos de las clases?h) ¿Qué significa en la práctica el pase de mensajes entre clases?i) Realiza el diagrama de clases para el siguiente planteamiento: “Dado varios

pares de números, determinar el porcentaje de pares donde ambos suman más de 10”j) Realiza el diagrama de clases para el siguiente planteamiento: “En un banco el dinero

disponible de la cuenta de un cliente se calcula restando al total depositado el total de retiros y el total de comisiones al banco. Teniendo el monto de creación del banco y la información de varios clientes, ¿Cuánto dinero le quedará a cada uno?, ¿Cuánto al banco?”

k) Realiza el diagrama de clases para el siguiente planteamiento: “ENELBAR cobra por servicio de la siguiente manera: si consumió menos de 1000 impulsos cada uno costará Bs. 0,1, si consumió menos de 2000 costará Bs. 0,08 y Bs. 0,05 si consumió al menos 2000. Calcular el monto a pagar a ENELBAR dada toda la información necesaria”

l) Respuestas en la página respuestas a ejercicios propuestos. Antes de verlas, procura tu mayor esfuerzo y resuelve.



Persona- EdoCivil : char- ValorBien : float- MontoPrima () : float

1 OBJETOS EN C++

C++ es un Lenguaje de Programación diseñado a mediados de los años 1980 por Bjarne Stroustrup. La intención de su creación fue el extender al exitoso lenguaje de programación C con mecanismos que permitan la manipulación de objetos.

En ese sentido, desde el punto de vista de los lenguajes orientados a objetos, el C++ es un lenguaje híbrido.

Para que logres hacer funcionar tus programas Orientados a Objetos con C++, deberás hacer lo siguiente:

➢ Diseñar los objetos que participan en la solución del problema, preferiblemente con un diagrama de clases ( tópico Relaciones entreclases, página Relaciones entre clases); quizá necesites una ejemplificación de la solución ( tópico Ejemplificación de requerimientos, página Ejemplificación de requerimientos).

➢ Seguir las reglas (sintaxis) de C++ para definir las clases e implementar sus métodos (logrando el programa fuente, tópico Creación de programas, página Creación de programas).

➢ Compilarlos, ejecutarlos y probarlos (al final tendrás un programa ejecutable). Revisa: corridas en frío y depuración, tópicos Estado de lamemoria en una ejecución y Depuración de programas.

1.1 BATERÍA DE EJERCICIOS RESUELTOS

Todos los ejercicios resueltos que se presentan a continuación podrás encontrarlos en la plataforma SEDUCLA y bajarlos para su análisis y estudio.

Recuerda que cada ejercicio corresponderá a una carpeta, de manera que identifica el ejercicio que estás buscando por el nombre de la carpeta que se indica en la ilustración de la solución.

1.2 ESTRUCTURA DE UN POO CON C++

Un Programa Orientado a Objetos en C++, está compuesto por:

Varias librerías de uso genérico, bien sean incorporadas al lenguaje o programadas por el usuario.

Una carpeta en el disco duro (o pendrive) con el nombre del proyecto.



Clases propias para el programa. Cada clase se almacena en 2 archivos: uno para la interfaz (extensión .h) y otro para la implementación (extensión .cpp). Estos archivos van dentro de la carpeta del proyecto.

Un programa principal, el cual realiza las definiciones e invocaciones necesarias para que operen los objetos (extensión .cpp).

Nuestro ejemplo de la organización requerirá al menos 5 archivos: Organización.h, Organización.cpp, Trabajador.h,

Trabajador.cpp y Principal.cpp

1.1 INTERFAZ E IMPLEMENTACIÓN DE CLASES

Cada clase que se diseña tendrá 2 partes: la interfaz y la implementación.

La interfaz: contiene solamente la declaración de los componentes de la clase, siguiendo la sintaxis de C++.

La implementación: contiene la programación de los métodos de la clase.

1.1.1 INTERFAZ DE CLASES CON C++

Por cada clase del problema tendrás que crear un archivo .h

Considera lo siguiente:

• La interfaz de la clase deberá indicar al principio los archivos a incluir (directivas #include).

• Seguidamente colocarás la definición propiamente de la clase.• Al final del archivo con la interfaz, deberás invocar la inclusión del

archivo de implementación correspondiente.• Cuando veas un archivo de interfaz de clase notarás que es corto,

Básicamente serán las líneas que definen cada componente de la clase.

La Ilustración 36 resume la sintaxis (reglas) para la creación del archivo con la interfaz de la clase. Nota lo siguiente en la sintaxis para la definición de la interfaz de una clase en C++:

• El comando #ifndef realmente es opcional, pero es muy recomendable incluirlo ya que si usas múltiples veces la clase (en herencias) no te compilará el programa.

• El comando #ifndef va acompañado con #define y #endif, y son instrucciones que le dicen al compilador lo siguiente: “si no está definido <NombreArchivo_H>, entonces defina <NombreArchivo_H> desde acá hasta #endif”



• La visibilidad de los componentes es opcional.• Debes colocar al menos un componente.• Al final de cada definición de componente debes colocar punto y coma (;).• Los parámetros de los métodos son opcionales, pero los paréntesis son

obligatorios; esto es para diferenciar métodos sin argumentos de los atributos de la clase.

• El punto y coma es obligatorio luego del paréntesis que cierra la clase.• Antes del comando de cierre #endif es necesario hacer la referencia

para que incluya el .cpp, con el comando #include “NombreArchivo.cpp”.

Ilustración 36: Sintaxis para la programación de la interfaz de una clase



#ifndef <NombreArchivo_H>#define <NombreArchivo_H>#include <NombreLibreria>[#include <NombreLibreria> [...]]

class <nombreClase> { <componentes>};#include “NombreArchivo.cpp”#endif

Componentes de tipo atributo=[private:|public:|protected:] <TipoCampo> <NombreCampo>; [<TipoCampo> <NombreCampo>; [...]]

Componentes de tipo método=[private:|public:|protected:] <TipoDevuelto> <NombreMétodo> ([<parametros>]); [<TipoDevuelto> <NombreMétodo> ([<parametros>]); [...]]

Sintaxis para la programación de la interfaz de una clase

Busca la carpeta Proy-Empresa en nuestro Banco de Ejercicios. Observa la siguiente interfaz para la clase

trabajador de nuestro ejemplo; el archivo respectivo se llamará Trabajador.h, dentro de la carpeta Proy-Empresa. Se han omitido

algunas instrucciones que se explicarán luego.

Ilustración 37: Archivo Trabajador.h con la interfaz de la clase.

1.1.1 IMPLEMENTACIÓN DE CLASES CON C++

Por cada clase del problema tendrás que crear un archivo .cpp, que corresponderá a la implementación (programación) de los métodos de la clase.

Considera lo siguiente:

• La implementación de la clase contiene una función por cada método declarado en la interfaz de la clase.

• Es preciso usar como prefijo el nombre de la clase al programar cada método.



Proy-Empresa\Trabajador.h#ifndef TRABAJADOR_H#define TRABAJADOR_H

#include <string>

class trabajador {private: float sueldo_base, asignaciones, deducciones;public:// Acá se omiten algunas líneas que veremos más adelante float CalcularSueldoNeto ();};

#include "Trabajador.cpp"#endif

Interfaz de la clase Trabajador

Ilustración 38: Archivo Trabajador.cpp con la implementación de la clase.

Nota lo siguiente en la sintaxis para la definición de la implementación de una clase en C++:

• El comando :: debes usarlo para identificar que el método pertenece a la clase; primero el nombre de la clase, luego :: y finalmente el método.

• Las sentencias pueden ser cualquier comando o grupos de comandos válidos en C++.

Busca la carpeta Proy-Empresa en nuestro Banco de Ejercicios. Observa la siguiente implementación para la clase

trabajador de nuestro ejemplo; el archivo respectivo se llamará Trabajador.cpp, dentro de la carpeta Proy-Empresa. Se han omitido

algunas instrucciones que se explicarán luego.


1.1 EL PROGRAMA PRINCIPAL Y SU COMPILACIÓN

El programa principal corresponderá a las líneas de arranque del programa, es decir, contiene la primera instrucción a ejecutar.



<nombreClase> :: <NombreMetodo> { <sentencias>}[<nombreClase> :: <NombreMetodo> { <sentencias>}[...]]

<sentencias> = una sentencia simple o un bloque de instrucciones

Sintaxis para la programación de la implementación de una clase

Proy-Empresa\Trabajador.cpp// Acá se omiten algunas líneas que veremos más adelantefloat trabajador :: CalcularSueldoNeto () { return sueldo_base + asignaciones - deducciones;}

Implementación de la clase TrabajadorFaltan las líneas para: el constructor, los Sets y los Gets, lo cual se explicará más adelante

Cuando se hace la compilación de nuestro proyecto, el compilador busca primeramente el programa principal y luego prosigue con los archivos que son referenciados allí, en el orden en que los consigue:

Los archivos referenciados son los que se indican con #include.

Algunos #include corresponden a librerías propias de C++.

La primera librería #include de las clases propias del proyecto se procede a compilar por parte del compilador.

Luego se produce una compilación en cadena: los #include dentro de cada clase se compilan a su vez en la medida en que los encuentra el compilador; si usa clase hace referencia a otra clase (con #include), entonces el compilador sigue con esa clase, y así sucesivamente.

Cuando la primera secuencia de compilación termina, con el último #include de compilación en cadena, entonces el compilador vuelve al programa principal y procede con el siguiente #include de las clases propias del proyecto.

Nota que producto de esta compilación en cadena es posible que varias clases hagan referencia a una misma clase base (por medio de herencia), y entonces es cuando cobra importancia la directiva #ifndef - #define - #endif, de manera que sólo la primera vez que el compilador se consiga con esa clase la misma será compilada; la segunda y siguientes veces, el compilador no entra a compilar dicha clase.

Ilustración 40: Sintaxis para la programación del programa principal.



[#include <<LibsDeC++>>][#include <“LibsPropias”>]using namespace std;

int main () { <sentencias>}

<sentencias> = una sentencia simple o un bloque de instrucciones

Sintaxis para la programación del Programa Principal

Busca la carpeta Proy-Empresa en nuestro Banco de Ejercicios. Observa el programa principal de nuestro

ejemplo; el archivo respectivo se llamará Principal.cpp, dentro de la carpeta Proy-Empresa.

Observa la línea con el comentario de creación de la instancia, es en ese momento (cuando se especifica que se creará un objeto del tipo trabajador) cuando el programa en ejecución destinará espacios de memoria para la creación del objeto. Es en ese momento cuando se ejecuta el constructor respectivo a los argumentos enviados (verás

la explicación más adelante).

Ilustración 41: Archivo Principal.cpp con el Programa Principal.

1.1 ACCESO A LOS DATOS DE UNA CLASE

Una vez que logras el diseño correcto de los objetos que intervienen en tu proyecto, y comienzas con la programación, entonces debes contemplar lo siguiente a los efectos de garantizar las propiedades de la POO:

Los objetos deben ser inicializados para que puedan procesar información. Esto es, proporcionarle valores a los atributos de los objetos; si los valores de los objetos no están cargados entonces los métodos no podrán funcionar.

En primera instancia, los objetos pueden inicializarse al momento de crearlos, esto es con el uso de constructores.



Proy-Empresa\Principal.cpp#include <iostream>#include "Trabajador.h"

using namespace std;

int main () { float sueldo, asig, deduc; cout << "Introduzca sueldo base: "; cin >> sueldo; cout << "Introduzca asignaciones: "; cin >> asig; cout << "Introduzca deducciones: "; cin >> deduc; trabajador t (sueldo, asig, deduc); // Creación de la instancia cout << "El sueldo neto es: " << t.CalcularSueldoNeto () << "\n"; system("PAUSE");}

Implementación del Programa Principal

Los constructores son métodos especiales que te permitirán cargar de información a los objetos en el momento de su creación, bien sea asignándoles valores predeterminados, o recibidos por parámetros.

Por otra parte, es preciso definir métodos de acceso que permitan asignar nuevos valores a los atributos. Estos métodos para la asignación de valores se conocen como Setters (asignadores), y normalmente se usa el prefijo Set para su implementación.

La contraparte de los asignadores son los Getter (Obtenedores) que posibilitan la extracción de la información (por cada atributo) de los objetos.

Debes recordar la propiedad de encapsulamiento de los objetos, de manera que los Setters (Sets) y los Getters (Gets) juegan un papel muy importante al momento de garantizar que los atributos sólo pueden ser accedidos a través de los métodos.

Sólo un conjunto restringido de métodos tiene acceso a los atributos del objeto, o lo que es lo mismo, los atributos deben

accederse exclusivamente a través de los métodos del objeto.

1.1.1 CONSTRUCTORES Y DESTRUCTORES

Un constructor es un método especial que se ejecuta automáticamente al momento de la creación de un objeto; su propósito es la inicialización de los atributos del objeto, bien sea con valores predefinidos o con valores que se “pasan” al objeto a través de parámetros.

Por otra parte, también existen los destructores, que también son métodos especiales pero que se ejecutan cuando el objeto deja de utilizarse, siendo su propósito principal el de liberar la memoria usada por las variables de tipo dinámicas que se crearon en el constructor. Dado que en este curso no se usará memoria dinámica, los destructores son tema de otra materia.

Los constructores tienen las siguientes consideraciones:

• Se denominan exactamente igual que la clase; esta cualidad es la que le indica al compilador que se trata de un método constructor.

• Pueden haber varios constructores en una clase, con la diferenciación entre ellos de los argumentos que reciben. Esto es lo que se denomina sobrecarga de métodos.



• Para efectos de este curso, principalmente se usarán 2 constructores: uno que inicializa al objeto con valores predeterminados, y otro que recibe los argumentos de inicialización.

• En la interfaz de la clase, solamente colocarás al encabezado del constructor, es decir, el nombre de la clase y los argumentos de inicialización.

• En la implementación, entonces declaras la implementación del constructor, tal como se hace con el resto de los métodos, y asignas los valores de inicialización a los atributos.

• En caso de que sea un constructor de inicialización predeterminada, colocarás valores base, Ej: 0 para int y float, ‘’ para string, “ ” para char, etc.

• Observa la Ilustración 42, página Ilustración 42: ArchivoTrabajador.h con la interfaz de la clase., para que veas la interfaz de la clase trabajador con sus constructores.

1.1.1 SOBRECARGA DE MÉTODOS

Normalmente una clase tiene múltiples constructores, lo cual es posible gracias a la sobrecarga de métodos y/o funciones que permite el lenguaje.



La sobrecarga de métodos y/o funciones es una cualidad de los lenguajes de programación que permite la definición de

métodos / funciones con el mismo nombre pero con diferentes argumentos; el programador, al momento de necesitar el método /

función, decidirá cuales argumentos enviar, y de esta manera, casando la cantidad, tipos y orden de los argumentos, el compilador

identifica cual es la implementación respectiva.

1.1.2 SETTERS (SETS) Y GETTERS (GETS)

Una clase contiene una serie de variables privadas, a las que solo puede acceder la clase, por lo tanto, para poder utilizarlas (modificarlas, acceder su valor) es necesario la existencia de un par de funciones miembros. Estas funciones generalmente se denominan Set y Get.

• La función Set es un método que nos permite modificar el valor (asignar) de una variable privada (atributo) de una clase.

• La función Get es un método que nos permite visualizar el valor de una variable privada (atributo) de una clase, en otras palabras provee el valor del atributo a quien lo solicite.

Considera lo siguiente en relación a los Sets y Gets:

• Por cada atributo debería existir un Set y un Get.• Con frecuencia podrás solamente implementar los Sets y Gets de los

atributos que necesites para resolver el problema que se te plantea. Queda a discreción del profesor si te permite esto.

• Los Sets constituyen un método cuya única función será asignarle un valor a un atributo en particular, el cual viene por parámetro. Dado que no tiene que retornar valor, los Sets son procedimientos, o funciones void.

• Los Gets son métodos que se invocarán para que retornen el valor de una atributo en particular, de manera que el tipo de retorno de cada Get dependerá del tipo del atributo que retorna.

• Observa la Ilustración 42, para que veas la interfaz de la clase trabajador con sus Sets y Gets.




Ilustración 43: Archivo Trabajador.cpp con la implementación de la clase.



:::class trabajador {private: float sueldo_base, asignaciones, deducciones;public: // Este es el constructor predeterminado trabajador (); // Este es el constructor de inicialización trabajador (float, float, float); void SetSueldo_Base (float); void SetAsignaciones (float); void SetDeducciones (float); float GetSueldo_Base (); float GetAsignaciones (); float GetDeducciones (); float DetSueldoNeto ();};:::

Proy-Empresa\Trabajador.hInterfaz de la clase TrabajadorConstructor predeterminadoConstructor de inicializaciónSets (Setters)Gets (Getters)Métodos de requerimientosSe omitieron las directivas #ifndef, #include, etc

trabajador :: trabajador (){ sueldo_base = asignaciones = deducciones = 0;}trabajador :: trabajador (float sb, float a, float d){ sueldo_base = sb; asignaciones = a; deducciones = d;}void trabajador :: SetSueldo_Base (float sb){ sueldo_base = sb;}:::float trabajador :: GetSueldo_Base (){ return sueldo_base;}:::float trabajador :: DetSueldoNeto () { return sueldo_base + asignaciones - deducciones;}

Proy-Empresa\Trabajador.cppImplementación de la clase TrabajadorConstructor predetConstructor de inicializaciónSets (Setters)Gets (Getters)Métodos de requerimientosSe omitieron algunos Sets y Gets... su implementación es similar

1.1 INTEGRACIÓN DE LOS COMPONENTES DEL PROYECTO CON POO Y DEVC++

Todos los componentes que conforman un proyecto de Programación Orientada a Objetos con DevC++ se integran por medio de un archivo con extensión .DEV, el cual administra la IDE de DevC++ de manera que posibilite la compilación y creación de la aplicación ejecutable.

La siguiente ilustración muestra la integración de los componentes del proyecto POO con la IDE DevC++ que usamos en este curso.

Ilustración 44: Integración de componentes de un POO con el proyecto en DevC++.

Respecto a lo necesario para almacenar tus proyectos, bien sea en el disco duro de tu computador, o en tu Pen-Drive, ten presente lo siguiente:

Cada proyecto se organiza en una carpeta independiente, la cual contiene todos los archivos necesarios para crear el programa ejecutable.

Es recomendable crear una carpeta principal para esta asignatura, llamada, p.ej., “_Programacion” (el piso es obligatorio!, así verás esa carpeta siempre



Vea depuración en , pág Integración de componentes del proyectoPestaña que lleva al contenido del archivo Principal.cppPestaña que lleva al contenido del archivo Trabajador.hPestaña que lleva al contenido del archivo Trabajador.cppEn el proyecto se agregan: el archivo principal y todas las interfaces de clases (.h); las implementaciones (.cpp) no deben agregarse ya que se producen errores de compilación.PARA ACCEDER AL .CPP: abra la interfaz de la clase respectiva, mantenga presionada la tecla Ctrl y haga clic en el #include del .cpp La interfaz de desarrollo integrado (IDE) de DevC++ te permite:Escribir los programasCompilarlos y ejecutarlosCrear el programa ejecutableProbarlos y depurarlos

de primero) y dentro de ella otra carpeta por cada proyecto que programes en el curso.

Siempre (siempre) debes trabajar en un disco duro; recuerda que los Pen-Drives fallan o son “tropezados” y se desconectan y pierdes el trabajo.

Es decir, date cuenta, los Pen-Drive son dispositivos de trasbordo, o sea, llevar tus proyectos de un computador a otro; terminas de trabajar en tu casa u oficina, pasas al Pen-Drive para trasladar los proyectos a otro computador, y antes de comenzar los copias al disco duro, pero no trabajas en el mismo Pen-Drive ya que corres el riesgo de perder tu trabajo.

Posiblemente no sea en el “disco C” donde podrás copiar tus proyectos cuando estés en otro computador; puede que tengas que hacerlo en una unidad de red o en alguna carpeta que te indique el profesor o encargado.

Cuando no estés en tu computador crea una carpeta que llamarás con tu número de cédula (sin puntos ni letras, ej: así 25478186, y no así C.I.-25.478.186) y allí colocarás tus proyectos; de esta manera no tendrás conflictos con los proyectos de tus compañeros de clase.

Cuando termines de trabajar en un computador que no es el tuyo, entonces asegúrate de pasar los proyectos a tu Pen-Drive, y si prefieres los borras del equipo.

Asegúrate de no perder tu trabajo: GRABA CON FRECUENCIA EL PROYECTO.

En esta ilustración tienes un resumen de las opciones principales que te brinda la barra de herramientas en la IDE de DevC++ para crear tus proyectos:

Ilustración 45: Barra de herramientas en la IDE de DevC++.



Barra de herramientas en la IDE de DevC++Vea depuración en , pág Crear nuevo proyectoAbrir proyectoNuevo archivo fuenteSólo compilarEjecutarCompilar y EjecutarReconstruir todo (recomendable)DepuraciónAñadir o quitar archivo del proyectoOpciones para guardar archivo o todo el proyecto

1.1 DEMOSTRACIÓN PASO A PASO: CREAR UN POO CON DEVC++

Ilustración 46: Paso a paso para crear un POO con DevC++.



Paso a paso para crear un POO con DevC++1- Crea la carpeta del proyecto con el Explorador de Windows2- Entra a DevC++ y crea un nuevo proyecto3- El proyecto es de tipo Console Application4- Asigna un nombre significativo al proyecto, y clic en Aceptar.5- Ubica la carpeta del proyecto, asigne el mismo nombre que usó en el paso anterior, y clic en Guardar6- Clic en “+” para ver todos los archivos del proyecto7- Seleccionar todo el texto (Ctrl+A), borrar y escribir tu Programa Principal8- Guarda el archivo actual con nombre Principal.cpp9- Agrega un nuevo archivo fuente (para cada clase), clic en Yes y graba archivo con nombre Trabajador.h10- Agregas otro nuevo archivo fuente (para el .cpp), y grabas con nombre Trabajador.cpp, pero debes eliminarlo de la lista de archivos para que te compile el proyecto11- Seleccionando Trabajador.cpp, clic derecho y Remover Archivo lo quita del proyecto12- Compilar todo. Obtendrás Done (listo) cuando no tengas errores13- Ejecutar14- Tu programa está corriendo!

1.2 RECOMENDACIONES PARA LA IDENTIFICACIÓN DE ERRORES AL COMPILAR

Cuando compilas tu programa, la IDE de DevC++ utiliza el compilador del Lenguaje C++ para verificar el cumplimiento de la sintaxis. Este compilador es de uso común para varias IDEs disponibles que te permiten programar con el Lenguaje C++. Una vez termina el proceso de compilación, entonces la IDE DevC++ te muestra los errores de sintaxis encontrados en el programa.

Ilustración 47: Identificación de errores de compilación.

Por cada error de compilación, el compilador de C++ produce varias líneas que explican el mismo. El panel inferior de la

IDE DevC++ muestra estos errores, te permite hacer doble clic en cada una y te lleva a la línea de código donde se produce el error.

Cuando compilas tu programa:

DevC++ revisa la sintaxis de todos los archivos que conforman tu proyecto.

La secuencia de comandos #include establece el orden en que se realiza la compilación.

En ese mismo orden se muestran los errores que va identificando el compilador de C++.



Revisa la carpeta con el proyecto Proy-EstudPatIdentificación de errores de compilaciónclass CtaBanco {private: float saldo_actual; char tipo_op; float monto;public: CtaBanco (); CtaBanco (float, char, float); void SetSaldoActual (float); void SetTipoOp (char); void SetMonto (float); float GetSaldoActual (); char GetTipoOp (); float GetMonto (); float DetNvoSaldo ();}

El error que ves en la imagen se produce por la falta del punto y coma al final de la interfaz de la clase CtaBanco.

El compilador al conseguir el primer error continúa avanzando hasta el final del programa principal, intentando identificar tantos errores como sea posible; producto de esto, algunos errores secundarios se producen por un error anterior. Gracias a esto, en frecuente poder corregir varios errores antes de recompilar.

Hay otros tipos de compiladores que identifican el primer error y no continúan, esto obliga a recompilar e identificar uno a uno los errores.

1.1.1 METODOLOGÍA PARA CORREGIR ERRORES DE COMPILACIÓN CON DEVC++

• Comience con el primer error mostrado, haga doble clic en él. Si no le lleva a una línea con el error propiamente, siga con la siguiente línea de error y repita el proceso.

• Debes aprender el significado del mensaje de error; es muy común que se repitan los errores y cuando veas el mensaje respectivo ya sabrás qué hacer.

• Lo mejor es resolver un error y volver a compilar; con frecuencia esta práctica resuelve varios errores de una sola vez ya que es posible que algunos de los errores siguientes se deban a este primero. Ej: referencia a una variable mal declarada.

• Si cuando compilas identificas más de un error, entonces aprovecha y corrige tantos errores como puedas, así avanzarás más rápido en la resolución de los errores de compilación.

• Ya sabes que la ventanita con el mensaje “Done” te indica que ya tu programa es sintácticamente correcto.

1.1.1 ALGUNOS ERRORES TÍPICOS QUE REPORTA EL LENGUAJE C++

Para la demostración de los errores típicos se usó el programa de la carpeta Proy-Banco.

• Se omiten los 2 puntos en el comando private

– expected `:' before "float"– El error aparece en la línea siguiente al

private.



• Tipo desconocido de dato– Ej: cha tipo_op;– 'cha' does not name a type– Nota que la segunda línea de mensaje de

error es la que te lleva al mismo

• Identificador no declarado– 'tipo_oper' undeclared (first use this

function)– Nota que ahora fue necesario hacer

doble clic hasta la cuarta línea de mensajes para llegar al error

• No declarado un identificador usado en método

– 's' undeclared (first use this function)– Este error es típico cuando se copia y

pega la cabecera del método desde la interfaz de la clase, ya que allí es opcional colocar el oidentificador.

• Miembro no existe en la clase– 'void CtaBanco::Set_Monto(float)'

member function declared in class `CtaBanco'

– Observa que el método debe llamarse SetMonto, y acá se escribió Set_Monto

• No se coloca el nombre de la clase en la implementación del método

– Debió ser float CtaBanco :: GetS...– Nota que el mensaje dice es que

saldo_actual está indefinido.– Sucede ya que el compilador cree que se

es una función independiente, no puede asociarlo a la clase que pertenece.



Para que la IDE DevC++ te muestre la línea con el error deberás hacer doble clic en cada mensaje de error, comenzando en el

primero, hasta que el cursor se ubique en el comando con el problema. Los primeros mensajes te llevan a líneas de #include, lo que significa que

debes seguir la “pista” al enlace respectivo y así sucesivamente hasta que llegues a la línea con el comando respectivo.

• Se omite el indicador de inicio de bloque– Expected `,' or `;' before

"saldo_actual"– Nota que falta la llave que abre el inicio

del bloque correspondiente al método.– Fíjate que el mensaje no te indica la

falta del inicio de bloque

• Se omite el #include de la clase– El error que reporta C++ es que no está

declarada CtaBanco; precisamente esa definición está en el archivo CtaBanco.h

– Fíjate que el último error que se aprecia dice que ‘c’ no está declarado; C++ intenta compilar líneas posteriores.

• Se omite el #include para la implementación de la clase

– undefined reference to `CtaBanco::DetNvoSaldo()': Referencia indefinida a la definición de un método

– Este error no te lleva a la línea respectiva; esto sucede ya que el .cpp no forma parte del proyecto.

• Se omite separador de sentencias “;”– Expected `;' before "tipo_op"– Se espera “;” antes de la siguiente

instrucción– Recuerda que toda instrucción termina

en punto y coma “;”



1.1 EJERCICIOS RESUELTOS Y PROPUESTOS a) ¿Qué novedad incorpora el lenguaje C++, comparado con lenguaje C? R. El C

resultó ser un lenguaje muy poderoso, con la introducción del C++ se posibilitó la Programación Orientada a Objetos.

b) ¿Qué pasos debes seguir para hacer correr un programa con DevC++, comenzando con un planteamiento de problema? R. 1- Crear la carpeta para el proyecto (con el explorador), 2- Crear un nuevo proyecto en DevC++, 3- Grabarlo con un nombre significativo en la carpeta que se destinó para ello, 4- Renombrar el programa principal a Principal.cpp, 5- Crear nuevos archivos para cada interfaz de clase (.h), 6- Crear nuevos archivos para implementación de clases (.cpp), pero sin incluirlos al proyecto. 7- En caso de que en el panel de archivos del proyecto veas archivos .cpp, debes removerlos del proyecto. 8- Compilar sucesivamente hasta corregir todos los errores de compilación que te reporta C++.

c) ¿Qué aplicaciones necesitas para poder hacer un programa con C++? R. Sólo necesitas una IDE como la de DevC++; en la IDE tienes integrado el editor de programas, el compilador y el depurador.

d) ¿Qué es una IDE y por qué se necesita? R. la IDE te brinda todo lo necesario para escribir tus programas, compilarlos, correrlos y depurarlos.

e) ¿Podrás hacer un programa en C++ sin una IDE? R. Sí se puede, pero es mucho más complejo que usando una IDE. Para hacer un programa sin IDE deberías crear los programas con el bloc de notas (p. ej.) y usar líneas de comando de DOS para compilarlos. Es mucho más complejo.

f) ¿Qué partes tiene una definición de clases en C++? R. Tiene la palabra clave “class” seguida del nombre de la clase, y entre llaves (el bloque de la interfaz de la clase) declaras los miembros (atributos y los métodos). La visibilidad para los sub-bloques de miembros se especifica con la palabra “private”, “protected” o “public”, seguido de dos puntos “:”.

g) ¿Qué consideraciones en general tiene la interfaz de una clase en C++? R. 1- debes especificar el tipo de visibilidad de los miembros, 2- los atributos deben ser “private”, o “protected” para el caso de herencia, 3- luego del nombre de un miembro método debe colocarse paréntesis, así no lleve argumentos; de esta manera C++ distingue métodos de atributos, 4- luego de la llave que cierra el bloque de la interfaz de la clase, debe colocarse un punto y coma “;”, 5- al final del archivo de interfaz debe colocarse el #include de la implementación respectiva. 6- debe usarse la directiva #ifndef - #endif de manera que el compilador no reporte error si se hacen múltiples referencias a la clase (múltiples #include en otros archivos).

h) ¿Qué consideraciones en general tiene la implementación de una clase en C++? R. 1- el nombre de la clase siempre debe estar como prefijo en la implementación de cada método o constructor, 2- luego del nombre de la clase como prefijo, se colocan 2 veces los dos puntos (::), 3- se coloca el nombre del método o constructor y se abre la llave indicando el inicio del bloque de implementación, 4- el fin del bloque de implementación se cierra con otra llave.



i) ¿Puedes identificar la analogía entre el programa principal y el control remoto de los objetos, explicado en esta guía? R. En el programa principal es donde presionas los botones del control remoto (invocas los métodos), así “solicitas” al objeto que estás ejecutando que “realice” las tareas para las cuales fue programado. Cuando terminar de programar el objeto, en el programa principal lo usas a control remoto (a través de los métodos).

j) ¿Qué consideraciones puedes mencionar para la programación del programa principal? R. 1- declaras el #include para la librería iostream y colocas la sentencia using namespace std, 2- el programa principal siempre se denomina int main (), 3- el cuerpo del programa principal lo encierras entre llaves.

k) ¿Qué etapas tiene la vida de una instancia de una clase? R. la instancia de una clase se crea cuando haces la definición de una variable de una clase (ej: CtaBanco c), y existirá en memoria mientras uses dicho objeto (variable), si se creó en el main, se destruirá al terminar el programa; cuando instancias objetos dentro de un método, la instancia se destruye automáticamente cuando se acaba el método.

l) ¿Para qué sirven los constructores? R. un constructor es un método especial que crea todos los componentes cuando se instancia el objeto, y también permite recibir argumentos que permitirán inicializar los valores de los atributos; de esta manera, con sólo una instrucción se crea la instancia y se inicializan atributos.

m) ¿Qué son destructores? R. los destructores se ejecutan cuando el objeto se está liberando, y permiten liberar memoria dinámica que se creó cuando se construyó la instancia de un objeto.

n) ¿Por qué la recomendación de un Set y un Get por cada atributo? R. esto es ya que la regla establece que los atributos deben ser privados, y sólo accederse a través de métodos; accederlos significa asignar un valor u obtener su valor (Set - Get)

o) ¿Es obligatorio crear todos los Gets y Sets de los atributos? ¿Qué pasaría si no lo haces? R. no es obligatorio; si estás haciendo ejercicios académicos, sólo podrías programar los Sets y Gets que necesites en esa prueba. Si haces un proyecto real y no declaras algún Set o Get, entonces te encontrarás con algunos atributos inaccesibles cuando estés avanzado en tu programa, y tendrás que hacer ajustes.

p) ¿Cómo integra DevC++ todos los componentes de un proyecto de POO? q) ¿Qué cuidados debes tener al momento de organizar tus proyectos en tu

computador o en tu pen-drive?r) ¿Cómo hacer para interpretar los errores que te reporta DevC++?s) ¿Quién identifica los errores que ves en la IDE DevC++?t) ¿Qué son las librerías de uso genérico?u) ¿Cuáles son los tipos de librerías que pueden usarse con C++?v) ¿Por qué se necesitan 2 archivos por cada clase que usa un proyecto?w) ¿Cuántos archivos tiene típicamente un proyecto de POO con C++?x) ¿Qué propósito tiene la directiva #include?y) ¿Cómo se usa y qué función cumple cada parte de la directiva #ifndef?z) ¿Cómo distingue el compilador de C++ que un miembro de clase es un método?



aa) ¿Cómo enlaza el compilador la interfaz de la clase con su implementación?bb)¿Cómo se indica el tipo de visibilidad que tendrá cada miembro de una clase?cc) ¿Si deseas hacer algún comentario en tu programa, cómo lo logras?dd)¿Qué reglas debes cumplir en la implementación de una clase?ee) ¿Qué significa implementar la clase?ff) ¿Qué secuencia de compilación de los archivos del proyecto sigue C++?gg) ¿Cuál es la utilidad de la directiva #ifndef?hh)¿En qué momento se crean las instancias de una clase?ii) ¿De qué formas puedes inicializar los atributos de un objeto?jj) ¿Qué son constructores?kk) ¿Para qué sirven los métodos Setters y Getters?a) ¿Qué significa “Sólo un conjunto restringido de métodos deben acceder a los

atributos”?b) ¿Qué es sobrecarga de métodos?c) ¿Qué utilidad tiene la sobrecarga de métodos?d) ¿Qué utilidad tiene una IDE como DevC++?e) ¿Cuáles recomendaciones debes considerar para almacenar los proyectos?f) ¿Qué propósito tiene cada paso de la creación de un programa con DevC++?g) Respuestas en la página respuestas a ejercicios propuestos. Antes de verlas, procura


1



2 METODOLOGÍA PARA EL ANÁLISIS Y PROGRAMACIÓN ORIENTADA A OBJETOS

Cuando te enfrentas a un problema de programación, o incluso a cualquier otro tipo de tarea, seguramente tu primer impulso es comenzar de inmediato a programar (o en las otras tareas con la realización propiamente de la actividad); de esta manera tenemos la sensación de que “terminaremos más rápido”.

Ahora fíjate que en situaciones reales las cosas no suceden así:

➢ Para construir un Centro Comercial hay preliminares laboriosos, de estudio y diseño de requerimientos, análisis y decisiones de factibilidad, etc.

➢ Para la elaboración de un nuevo modelo de vehículo deportivo se elaboran innumerables modelos y diseños preliminares, incluso se forjan con yeso, o materiales similares, modelos en tamaño original de los “diseños propuestos”.

➢ Cuando los médicos operan a una persona lo hacen luego de numerosos estudios y análisis de alternativas, salvo en situaciones de emergencia.

Cuando hacemos un programa nos enfrentamos a la elaboración de un producto (en este caso un producto software), y por tanto

es preciso cumplir una serie de etapas de análisis y diseño que permitan el logro de los requerimientos por parte del cliente. Además, en la

medida que se hacen cada vez más complejos los programas, el diseño preciso de la solución nos permitirán lograr más rápidamente la

solución.

La siguiente metodología, la cual ha sido revisada y simplificada lo más posible, te permitirá lograr rápidamente tus programas:

➢ 1- LEE Y COMPRENDE EL ENUNCIADO: identificando mentalmente las entidades participantes y sus componentes.

➢ 2- IDEA UN EJEMPLO Y LA ABSTRACCIÓN: con frecuencia es tabulado, lo cual refinarás hasta lograr conjuntamente con el cliente (por ahora es tu profesor) un modelo representativo del planteamiento y su solución.

➢ 3- IDEA EL DIAGRAMA DE CLASES: partiendo de la identificación en la ejemplificación de los objetos participantes y sus componentes.



➢ 4- REALIZA LA PROGRAMACIÓN DE LA SOLUCIÓN: para el programa que harás tendrás como guía tanto el ejemplo como el diagrama de clases, de los cuales si están bien planteados surgirá el programa definitivo.

1.1 JUSTIFICACIÓN DE LA NECESIDAD DE UNA METODOLOGÍA

Analiza los siguientes planteamientos y verás que resulta más rápido terminar tu programa si cumples con la metodología recomendada:

Cuando haces un ejemplo que incluya lo requerido en el planteamiento, puedes mostrar al cliente que “entiendes” qué información se tiene de entrada y qué información debes producir de salida.

En caso de que presentes al cliente un ejemplo que no corresponde a lo que está esperando, entonces estarás a tiempo de hacer los ajustes necesarios.

Imagina que empiezas a programar sin antes analizar y ejemplificar, entonces sólo luego que terminas el programa es que el cliente (por ahora es el profesor) podría decirte que estabas confundido en algo.

Fíjate: una ejemplificación incluso es válida en borrador, a mano alzada, y puedes lograrlo en 2 minutos o menos; recuerda un gráfico dice más que mil palabras. Con sólo 2 minutos el cliente puede orientarte y resolver las dudas que presentes en la ilustración de la situación.

Para lograr un programa funcional, sin cumplir metodología, tendrás que invertir mucho más tiempo; como referencia, algunos ejercicios ameritan 45 minutos o más. Imagínate que luego de ese tiempo el profesor te diga: “ESTÁS CONFUNDIDO, DEBES HACER AJUSTES”.

Cuando aprendes a cumplir metodología, entonces del propio análisis PODRÁS SACAR TODA LA INFORMACIÓN para hacer el programa, ¿por qué? Porque en la ejemplificación puedes visualizar los objetos que participan y usar los mismos nombres de componentes que allí colocaste; también es posible que hayas colocado algunas fórmulas y esas van directo a la implementación de los métodos (es decir, a la programación).

Por otra parte, cada vez que hagas más ejercicios, menos análisis tendrás que hacer ya que tendrás práctica; lo que es indudable es que ante planteamientos complejos será imprescindible la elaboración de situaciones ejemplificantes que puedas comprobar con los clientes.

Hasta ahora hemos visto POO donde participa una sola clase, para lo cual la ejemplificación es simple. En situaciones donde participan



más clases, y una está compuesta por muchos objetos de la otra (Ej: Empresa-Trabajadores) es donde se recomienda usar tablas.

1.1 DEMOSTRACIÓN DE LA APLICACIÓN DE LA METODOLOGÍA

Seguidamente verás 3 ejemplos donde se aplica la metodología hasta el punto de elaborar el diagrama de clases; revisa el tópico Ejemplos deprogramas orientados a objetos, página Ejemplos de programas orientados aobjetos para que veas los programas respectivos.

Ilustración 48: Ejemplo 1 de aplicación de metodología.



Ejemplo 1 de aplicación de metodologíaPlanteamiento del problemaProgramar con POO: Dado el saldo actual de una cuenta bancaria, el tipo de una nueva operación que se realizó y el monto de la misma, determinar el nuevo saldo de la cuenta.

Dado el saldo actual de una cuenta bancaria, el tipo de una nueva operación que se realizó y el monto de la misma, determinar el nuevo saldo de la cuenta.

1- Comprende: resalta las entidades que participan y los datos que te dan; la clase final está subrayadaSi tengo 2000 Bs en el banco (saldo_actual)Las operaciones??? Retiro – depósito (tipo_op)Ok!, si deposito 1000... (monto)Entonces tendré 3000 Bs (nvo_saldo)Pero si retiro 1500 (monto)... me quedan 500 Bs

Ta’ fácil: al saldo actual le sumo si es deposito o le resto si es

retiro (DetNvoSaldo)

2- Ejemplo: Este proceso de análisis te llevará a la solución final. El cliente puede decirte rápidamente si vas bien.2- Abstracción: Este razonamiento es una excelente abstracción del problemaLos nombres de variables (en paréntesis) puedes idearlos una vez aprobado el ejemploCtaBancosaldo_actual : floattipo_op : charmonto : floatDetNvoSaldo () : float

3- Clases: Observa que los componentes vienen desde el ejemplo: con el nombre que ideaste!... si es dato de entrada, será atributo, los cálculos son métodos...Recuerda que todos los métodos llevan paréntesis así no tengan argumentos.




Con frecuencia te enfrentarás a planteamientos de problemas donde no están explícitos los datos de entrada ni los

requerimientos; algunos pueden estar implícitos (sobreentendidos), y otros tendrás que incluirlos ya que si no, no te funciona el modelo (la

ejemplificación). Deberás practicar mucho.

Ejemplo 2 de aplicación de metodologíaProgramar con POO: Dado un número entero, determinar si el mismo es positivo o negativo.Dado un número entero, determinar si el mismo es positivo o negativo.

1- Comprende: resalta las entidades que participan y los datos que te danEl número 10 es positivo... 0 (cero) también...

2- Ejemplo: Este proceso de análisis te llevará a la solución final. El cliente puede decirte rápidamente si vas bien.2- Abstracción: Este razonamiento es una excelente abstracción del problemaNroEnterovalor : intDetEsPositivo () : bool

3- Clases: Observa que los componentes vienen desde el ejemplo: con el nombre que ideaste!... si es dato de entrada, será atributo, los cálculos son métodos...Planteamiento del problemaCómo saber si un valor es positivo???Ya sé!! Si el número es mayor que cero, entonces es positivo (DetEsPositivo)

Nota que en el planteamiento sólo resaltaste número entero (la clase), el valor estaba implícito.




Ejemplo 3 de aplicación de metodologíaProgramar con POO: Se sabe que una llamada local cuesta Bs. 0,1 el minuto y a celular Bs. 0,3, dada la duración de la llamada, calcular el monto a pagar por el servicio.

... una llamada local cuesta ...celular cuesta ... dada duración... calcular monto...

1- Comprende: resalta las entidades que participan y los datos que te danSi llama local 10 minutos son 1 Bs (tipo=L)

2- Ejemplo: Este proceso de análisis te llevará a la solución final. El cliente puede decirte rápidamente si vas bien.2- Abstracción: Este razonamiento es una excelente abstracción del problemaLlamadatipo : charminutos : intDetMtoServicio () : float

3- Clases: si es dato de entrada, será atributo, los cálculos son métodos...Planteamiento del problemaSi llama celular 20 minutos son 6 Bs (tipo=C)

Condicionado al tipo (L - C) se multiplican los minutos por 0,1

ó 0,3 (DetMtoServicio)

Con frecuencia cuando hay 2 ó más opciones para determinar algo, tendrás que incluir un atributo tipificador.

1.2 EJEMPLOS DE PROGRAMAS ORIENTADOS A OBJETOS

Ilustración 51: Ejemplo 1 de POO (Proy-CtaBanco).

Ilustración 52: Del ejemplo y abstracción al POO (Proy-CtaBanco).



Ejemplo 1 de POO(Carpeta Proy-CtaBanco)

CtaBanco :: CtaBanco (){ saldo_actual = 0; tipo_op = 'D'; monto = 0;}CtaBanco :: CtaBanco (float s, char t, float m){ saldo_actual = s; tipo_op = t; monto = m;}void CtaBanco :: SetSaldoActual (float s){ saldo_actual = s;}::: // ACÁ VAN EL RESTO DE LOS GETs Y SETsfloat CtaBanco :: GetMonto (){ return monto;}

float CtaBanco :: DetNvoSaldo (){ if (tipo_op == 'D') return saldo_actual + monto; else return saldo_actual - monto;}

#include <iostream>#include "CtaBanco.h"using namespace std;

int main (){ float saldo, mto; char t_op; cout << "Introduzca el saldo actual: "; cin >> saldo; cout << "Tipo de operación "; cout << "(R=Retiro, D=Deposito): "; cin >> t_op; cout << "Introduzca el monto: "; cin >> mto; CtaBanco c (saldo, t_op, mto); cout << "El nuevo saldo de la cuenta es: "; cout << c.DetNvoSaldo () << endl; system("PAUSE");}

#ifndef CTABANCO_H#define CTABANCO_H

class CtaBanco {private: float saldo_actual; char tipo_op; // "D"=Depósito, "R"=Retiro float monto;public: CtaBanco (); CtaBanco (float, char, float); void SetSaldoActual (float); void SetTipoOp (char); void SetMonto (float); float GetSaldoActual (); char GetTipoOp (); float GetMonto (); float DetNvoSaldo ();};

#include "CtaBanco.cpp"#endif

Interfaz de clase CtaBanco (CtaBanco.h)Crear POO paso a paso en , pág.

Este punto y coma es importantísimo!, si no, no compila!Implementación de clase CtaBanco (CtaBanco.cpp)Programa Principal (Principal.cpp)Programa en ejecución

Del ejemplo y abstracción al POOAbstracción en , pág. Identificación de objetos en , pág.

La ejemplificación te da nombres de atributos y nombres de métodosc l a s s C t a B a n c o { p r i v a t e : f l o a t s al d o _ a c t u a l ; c h a r t i p o _ o p ; / / " D " = D e p ó s i t o , " R " = R e t i r o f l o a t m o n t o ; p u b l i c : : : : : :

: : : : : : f l o a t C t a B a n c o : : D e t N v o S a l d o ( ) { i f ( t i p o _ o p = = ' D ' ) r e t u r n s a l d o _ a c t u a l + m o n t o ; e l s e r e t u r n s a l d o _ a c t u a l - m o n t o ; }

La abstracción te lleva a la implementación de los métodos

Si tengo 2000 Bs en el banco (saldo_actual)

Las operaciones??? Retiro – depósito (tipo_op) Ok!, si deposito 1000... (monto)

Entonces tendré 3000 Bs (nvo_saldo) Pero si retiro 1500 (monto)... me quedan 500 Bs

Ta’ fácil: al saldo actual le sumo si es deposito o le resto si es retiro (DetNvoSaldo)

Ilustración 53: Ejemplo 2 de POO (Proy-NroEntero).

Ilustración 54: Ejemplo 3 de POO (Proy-Llamada).



Ejemplo 2 de POO(Carpeta Proy-NroEntero)

NroEntero :: NroEntero (){ valor = 0;}NroEntero :: NroEntero (int v){ valor = v;}void NroEntero :: SetValor (int v){ valor = v;}int NroEntero :: GetValor (){ return valor;}bool NroEntero :: DetEsPositivo (){ if (valor >= 0) return 1; else return 0;}

#include <iostream>#include "NroEntero.h"using namespace std;

int main (){ int Nro; cout << "Introduzca el Nro entero: "; cin >> Nro; NroEntero n (Nro); if (n.DetEsPositivo ()) cout << "El numero es positivo." << endl; else cout << "El numero es negativo." << endl; system("PAUSE");}

#ifndef NROENTERO_H#define NROENTERO_H

class NroEntero {private: int valor;public: NroEntero (); NroEntero (int); void SetValor (int); int GetValor (); bool DetEsPositivo();};

#include "NroEntero.cpp"#endif

NroEntero.hCrear POO paso a paso en , pág.

Este punto y coma es importantísimo!, si no, no compila!NroEntero.cppPrograma Principal (Principal.cpp)Programa en ejecución

Llamada :: Llamada (){ tipo = 'L'; minutos = 0;}Llamada :: Llamada (char t, int m){ tipo = t; minutos = m;}float Llamada :: DetMtoServicio (){ if (tipo == 'L') return minutos * 0.1; else return minutos * 0.3;}

:::class Llamada {private: char tipo; int minutos;public: Llamada (); Llamada (char, int);// Se omiten Sets y Gets float DetMtoServicio ();};::::

#include <iostream>#include "Llamada.h"using namespace std;

int main (){ int mins; char tipo; cout << "Tipo llamada (L=ocal, C=elular): "; cin >> tipo; cout << "Cantidad de minutos: "; cin >> mins; Llamada ll (tipo, mins); cout << "El monto del servicio es: "; cout << ll.DetMtoServicio () << endl; system("PAUSE");}

Ejemplo 3 de POO(Carpeta Proy-Llamada)

Llamada.hCrear POO paso a paso en , pág.

Este punto y coma es importantísimo!, si no, no compila!Llamada.cppPrograma Principal (Principal.cpp)Programa en ejecución

La ejemplificación te da nombres de atributos y nombres de métodos

Ilustración 55: Del ejemplo y abstracción al POO (Proys Llamada y NroEntero).

1.3 EJERCICIOS PROPUESTOS

Resuelve los siguientes planteamientos siguiendo la metodología sugerida en esta sección: 1- Identificación de entidades, 2- ejemplificación y abstracción, 3- diseño de clases y 4- programación.

a) Dada la letra del sexo de una persona (F o M), programe y muestre si es hombre o mujer.

b) Dada la edad de una persona, determinar si es o no mayor de edad.c) En una empresa se asignará un aumento del 10% a todo el personal obrero y un 5% al

personal administrativo. Calcular el nuevo sueldo de un empleado dado su tipo y sueldo actual.

d) En una academia se admiten a aquellos jóvenes venezolanos mayores de 18 años, o extranjeros mayores de 21. Dada esta información, determinar si el aspirante es admitido o no.

e) Dado un número entero, determinar si es múltiplo de 3 y si es múltiplo de 5.f) ENELBAR cobra por servicio de la siguiente manera: si consumió menos de 1000

impulsos cada uno costará Bs. 0,1, si consumió menos de 2000 costará Bs. 0,08 y Bs. 0,05 si consumió al menos 2000. Calcular el monto a pagar a ENELBAR dada toda la información necesaria.

g) A un vendedor se le asignará una comisión del 5% si sus ventas son hasta Bs. 500, el 10% si son hasta Bs. 2.000, y el 15% si vende más de 2.000. Calcular la comisión.

h) Una nota mayor a 80 puntos es excelente, mayor de 50 es bueno, mayor de 30 es deficiente y si no es malo. Determinar la condición de un alumno dada su nota final.

i) Dado el estado civil de una persona, determinar la prima a pagar por un seguro según lo siguiente: Solteros o Viudos 10%, Casados 15%, Divorciados 20%. Calcular el monto de la prima dado el estado civil de la persona y el valor del bien a asegurar.



El número 10 es positivo... 0 (cero) también...

Cómo saber si un valor es positivo???

Ya sé!! Si el número es mayor que cero, entonces es positivo (DetEsPositivo)

Del ejemplo y abstracción al POOAbstracción en , pág. Identificación de objetos en , pág. Si llama local 10 minutos son 1 Bs (tipo=L)

Si llama celular 20 minutos son 6 Bs (tipo=C)

Condicionado al tipo (L - C) se multiplican los minutos por 0,1 ó 0,3 (DetMtoServicio)

c l a s s N r o E n t e r o { p r i v a t e : i n t v a l o r ; p u b l i c : : : : : : : : :

b o o l N r o E n t e r o : : D e t E s P o s i t i v o ( ) { i f ( v a l o r > = 0 ) r e t u r n 1 ; e l s e r e t u r n 0 ; }

c l a s s L l a m a d a { p r i v a t e : c h a r t i p o ; i n t m i n u t o s ; : : : : : :

f l o a t L l a m a d a : : D e t M t o S e r v i c i o ( ) { i f ( t i p o = = ' L ' ) r e t u r n m i n u t o s * 0 . 1 ; e l s e r e t u r n m i n u t o s * 0 . 3 ; }

La abstracción te lleva a la implementación de los métodos

La solución a estos ejercicios la conseguirás en la página respuestas a ejercicios propuestos.

Ten presente que hay múltiples formas de resolver un mismo ejercicio, de manera que tu respuesta puede diferir pero también estará buena

siempre que produzca los mismos resultados y cumplas con la metodología establecida.



1 RESPUESTAS A EJERCICIOS PROPUESTOS

1.1 PLANTEAMIENTOS DEL TÓPICO EJERCICIOS RESUELTOS Y PROPUESTOS

¿Por qué crees que la programación visual también será POO? R. cuando el programador diseña con aplicaciones visuales y usa el ratón y barras de herramientas (como las que tiene Excel y Word), entonces cada uno de esos múltiples componentes que se colocan son objetos que pueden a su vez programarse y configurarse como tales.

¿Podrías identificar qué cosas de la vida real son objetos? R. Todo lo que nos rodea son objetos que pueden describirse en términos de sus propiedades y su comportamiento; si miras a tu alrededor verás: puertas, ventanas, mesas, sillas, libros, techo, piso, árboles, cables de electricidad, edificios, casas, vehículos, montañas, vidrios, cuadros, equipos electrónicos y muchas cosas más. Mira a tu alrededor y date cuenta que cualquier cosa tiene propiedades (VALORES, Ej: color, tamaño, peso, longitud) y comportamiento (ACCIONES, Ej: mover, cambiar forma, encender, etc.).

¿Qué significa diseñar las aplicaciones?, ¿qué significa implementarlas? R. diseñar una aplicación consiste en analizar sus requerimientos y conseguir alguna forma de resolverlos (abstracción), posiblemente ideando un ejemplo (un modelo, tal y como los arquitectos hacen maquetas) que represente la requerido y su solución; por otro lado, implementarlas consiste en la programación propiamente de la solución ideada con el uso de un lenguaje de programación para producir un programa ejecutable .EXE (en el caso de la maqueta, los Ingenieros Civiles implementan lo representado en las maquetas).


¿Cuales reglas debes cumplir para declarar objetos? R. las mismas reglas que cuando se declaran variables: primero indicar el tipo de dato y luego el nombre de un identificador que será la variable; para objetos: primero indicar el nombre de la clase y luego el nombre de un identificador que será el objeto. Así: <Nombre-Clase> <Lista de identificadores de objetos>; Ej. ClasePersona Pers1, Pers2, Pers3 (así creo 3 objetos).

¿De ahora en adelante ya no necesitarás más variables, sólo objetos? R. Falso, sí se necesitan variables a los efectos de almacenar valores atómicos (datos simples) como un número, una edad, un nombre y luego enviarlos por argumentos o para asignarle valores a los atributos de objetos.



¿Por qué necesitas declarar el uso de objetos, así como con variables? R. Recuerda que dijimos que los objetos también son variables, en este caso de algún tipo Clase X, por tanto hay que declararlas para el C++ les asigne espacios en memoria donde se guardarán los valores asignados a los atributos del objeto. Es decir, un objeto es como una composición de varias celdas de memoria (una por cada atributo), y al ser declarado se asigna espacio de memoria para su procesamiento.


Cuando describes los componentes de un objeto, ¿Cómo puedes distinguir qué será atributo y qué será método? R. si haces una enumeración de los componentes de un objeto que analizas, aquellos componentes que puedan tomar un valor serán los atributos, los que signifiquen una acción o un cambio de estado serán métodos. Ej: ATRIBUTOS DEL OBJETO CELULAR: número, marca, modelo, cantidad de números para almacenar, permite mensajes sms, MÉTODOS: remarcar, enviar mensaje sms, y otros.

Describe en términos de objetos un ratón de computadoras, ¿es tangible o no? R. sí es tangible, ATRIBUTOS: cantidad de botones, color, marca, tipo de señal (alámbrico, inalámbrico, bluetooth), tamaño (pequeño, mediano, grande), COMPORTAMIENTO: subir flecha, bajar flecha, clic, doble clic, arrastrar, etc.

Describe en términos de objetos un número, ¿es tangible o no?. R. es intangible, ATRIBUTOS: valor, signo, admite decimales (si o no), COMPORTAMIENTO: es par (si o no), es primo (si o no), duplicarlo, valor absoluto, parte entera, parte decimal, etc.

Describe en términos de objetos un empleado, ¿es tangible o no?. R. es tangible, ATRIBUTOS: nombre, cédula, sexo, sueldo base, asignaciones, deducciones, fecha de nacimiento, COMPORTAMIENTO: Edad, sueldo neto, aumentar sueldo, Asignar cargo, etc.

Describe en términos de objetos la fórmula de velocidad (v = d / t, velocidad es distancia sobre tiempo), ¿es tangible o no?. R. es intangible, ATRIBUTOS: distancia, tiempo, MÉTODOS: Calcular velocidad.

Describe en términos de objetos los alumnos de una clase, ¿es tangible o no?. R. es tangible, ATRIBUTOS: lista de cédulas, lista de nombres, lista de notas primero, segundo y tercer parcial, COMPORTAMIENTO: cantidad de estudiantes, nota promedio, mayor nota, mejor y peor estudiante.



Describe en términos de objetos un triángulo, ¿es tangible o no?. R. es tangible, ATRIBUTOS: longitud de la base, longitud de la altura, color de relleno, color de fondo, COMPORTAMIENTO: calcular área, calcular perímetro, determinar tipo de triángulo, etc.


¿Qué puedes hacer para identificar y corregir errores de compilación? R. debes verificar la sintaxis del comando donde se produce el error. Es importante que te familiarices con la sintaxis de cada comando, de manera que poco a poco vayas adquiriendo la experiencia que te permitirá cada vez más lograr programas sintácticamente correctos.

¿Qué puedes hacer para identificar y corregir errores de ejecución? R. lo primero es determinar cuál es el conjunto de valores de entrada que hacen que se produzca el error (esto es reproducir el error), luego puedes revisar los procesos asociados a los cálculos erróneos (tal vez con corridas en frío), y en los casos más difíciles tendrás que hacer una depuración paso a paso inspeccionando el contenido de cada variable durante la ejecución.

¿Cuándo puedes saber que un programa ya no tiene errores de ejecución? R. Un programa en ejecución debes probarlo con múltiples datos de entrada, es posible que alguna combinación de datos de entrada te produzca un error. La práctica te permitirá identificar cada vez mejor la combinación de datos de entrada más apropiada para comprobar la funcionalidad de tus programas.

¿Bastará con probar un programa con un solo conjunto de datos de entrada? R. No siempre; como viste en la pregunta anterior, es posible que una combinación de datos de entrada produzca errores en la ejecución. Como regla general, considera conjuntos de datos que pongan a prueba los procesos en sus etapas iniciales o finales.

¿Cuánto tiempo es el necesario para dedicar a cada etapa de la implementación? R. si cumpliste la etapa de análisis y tienes listo el diseño de la solución, la escritura del programa sólo dependerá de tu velocidad de transcripción; la etapa de compilación durará menos en la medida que más conozcas la sintaxis de los comandos y sepas interpretar los mensajes de error; la corrección de errores durante el tiempo de ejecución en ocasiones puede resultar largo, pero puedes simplificar si aprendes a reproducir los errores y usas la herramienta automatizada de depuración.



¿Si dedicas toda una tarde a un ejercicio y no te da los resultados esperados, será que no puede resolverse? R. Falso, completamente falso. Es sumamente extraño cuando un lenguaje de programación tiene errores “por su culpa”; la gran mayoría de las veces se trata de errores de lógica, tal vez difíciles de identificar. Incluso la depuración de un solo error puede ser una actividad de varios días. El Internet y la consulta a expertos pueden ayudar.

¿Con cuántos datos deberás probar tus programas para saber que están bien? R. si es un programa sencillo (tal vez trivial) entonces córrelo unas 2 veces con datos muy diferentes; para problemas más complejos, selecciona casos de entrada atípicos y también prueba con situaciones excepcionales o fuera de lo común.

¿Si un programa amerita 50 datos de entrada, o más, cómo puedes hacer para simplificar la entrada y hacer varias pruebas de ejecución? R. puedes reemplazar la entrada por teclado con entrada por un archivo de texto; así para crear situaciones diversas en la entrada, sólo cambias algunos valores en el archivo de texto y te puedes concentrar en depurar en lugar de tipear.


Plantea la abstracción para el siguiente problema: “Para una discoteca irán varias personas, entre chicos y chicas; la entrada de un chico cuesta Bs. 40, para una chica le cuesta el 50%, ¿Cuánto dinero deberán llevar cada grupo para que puedan entrar?”. R. Multiplico la cantidad de chicos por 40 y la de chicas por 20.

¿Cómo podrías describir con tus palabras la herencia? R. Es cuando puedes identificar las características comunes entre cosas (entidades) afines y estableces una entidad “básica” que te servirá para decir que todas las demás son así.

¿Cómo podrías describir con tus palabras el polimorfismo? R. Sucede cuando tienes herencia y en la jerarquía de clases hay comportamientos que puedes llamar de igual manera pero que en realidad tienen variaciones dependiendo de cada clase derivada.

Describe en términos de abstracción: “Dado un número entero, determinar si el mismo es positivo o negativo”. R. El número es positivo si es mayor o igual a cero.

Describe en términos abstractos: “Dado el saldo actual de una cuenta bancaria, el tipo de una nueva operación (R:etiro, D:epósito) que se realizó y



el monto de la misma, determinar el nuevo saldo de la cuenta”. R. Al saldo actual se le suma el depósito o se le resta el retiro.

Describe en términos de abstracción: “En la UCLA hay 5 decanatos y se conoce de cada uno: el número de alumnos que se retiraron y el porcentaje que representan, ¿Cuántos alumnos quedan inscritos en cada decanato?”. R. 100 menos el porcentaje de retirados me da el porcentaje de inscritos, luego hago regla de 3 con la cantidad de alumnos retirados.

Según lo visto hasta ahora, ¿cómo logras el encapsulamiento cuando haces un programa con POO? R. asegurándote de que los atributos de cada objeto sean privados (no pueden accederse desde fuera del objeto), y que sólo los métodos del mismo objeto sean quienes accedan (modifiquen) sus valores.

Identifica la herencia que puedes idear del siguiente planteamiento: “Un triángulo y un círculo son figuras geométricas con su área y perímetro, cada uno con su fórmula particular”. R. Defines la clase base “Figura” con métodos para cálculo de área y perímetro, y las clases derivadas serían “Triángulo” y “Círculo”.

¿Cómo podrías aplicar polimorfismo al ejemplo de las figuras geométricas? R. El método que calcula el área y el que calcula el perímetro retornan cero (0) en la clase base, pero en las clases derivadas está la fórmula correcta para cada una; un nuevo método en la clase base que haga referencia al área o al perímetro, p.ej. FiguraGrande, invocará correctamente al método de una clase derivada, aunque esté ubicado en la clase base “Figura”.

Identifica la herencia que puedes aplicar a los electrodomésticos que usas en casa. R. la clase base la llamarías “Electrodoméstico” con métodos de encender, apagar, temporizar, y las clases derivadas: “Lavadora”, “Licuadora”, “Pulidora”

Cómo puedes aplicar herencia a los distintos tipos de cuentas bancarias sabiendo que toda cuenta tiene un número y un titular, una cuenta de ahorros paga intereses, una cuenta corriente cobra comisión y el plazo fijo es un caso especial de cuenta de ahorros donde el dinero se deposita durante un lapso de tiempo establecido. R. defines la clase base “Cuenta” con miembros: titular, Nro cuenta, monto apertura, fecha apertura; la clase derivada “Cuenta ahorros” hereda de “Cuenta” y tiene adicional el porcentaje de interés; la clase derivada “Cuenta corriente” hereda de “Cuenta” y tiene adicional la comisión que cobra; el “Plazo fijo” hereda de “Cuenta ahorros” teniendo como miembro adicional el lapso de tiempo.



¿Cómo podrías aplicar polimorfismo al ejemplo de los electrodomésticos? R. El cálculo del saldo actual seguramente se verá afectado por las comisiones e intereses de las clases derivadas; así, podrías definir un método CalcularSaldoActual en la clase base el cual invoca a “CalculosEspeciales”, mismos que en “Cuenta” dan cero (0) pero en las clases derivadas tienen algún proceso particular.

¿Cómo podrías aplicar polimorfismo al ejemplo de los teléfonos? R. por ejemplo en el método “Marcar” de “Teléfono” defines un método “PrepararMarcado”, el cual no hace nada en la clase “Teléfono” pero en “Teléfono fijo” te presenta una lista de contactos, y en “Fax” además te pregunta si está lista la hoja para enviar.


Billetes: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: “Sabiendo cuantos billetes de 5, 10, 20 y 50 tiene una persona en su cartera, calcular la cantidad total de dinero con que cuenta. Hacer el cálculo para varias personas”. R. El objeto final es Inversionistas y persona; los inversionistas son varias personas; también podría ser Cuentas y Persona.

Artículos: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: “Una persona compra un artículo a un valor de costo, si quisiera ganarle el 50% de lo invertido ¿en cuánto debería venderlo?, ¿en cuánto si quisiera el 50% del precio de venta?. Repita el proceso para repetir los cálculos hasta que el usuario lo indique”. R. Los objetos son Vendedores y Persona, donde los vendedores son varias personas que invierten.

Sueldo: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: “Si un empleado gana un sueldo básico y además se le asigna una comisión del 25% sobre las ventas que realizó, determinar cuánto cobrará el empleado. Procesar esta información para varios empleados”. R. Objetos finales: empresa y vendedores, siendo la empresa quien tiene varios vendedores.

Enelbar: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: “ENELBAR cobra por servicio de la siguiente manera: si consumió menos de 1000 impulsos cada uno costará Bs. 0.1, si consumió menos de 2000 costará Bs. 0.08 y Bs. 0.05 si consumió al menos 2000. Calcular el monto a pagar a ENELBAR dada toda la



información necesaria”. R. Puedes asumir que se trata de una sola persona que pagará en Enelbar, por tanto el objeto sería Persona.

Primas: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: “Dado el estado civil de una persona, determinar la prima a pagar por un seguro según lo siguiente: Solteros o Viudos 10%, Casados 15%, Divorciados 20%. Calcular el monto de la prima dado el estado civil de la persona y el valor del bien a asegurar”. R. Se trata de una sola persona, el objeto sería Persona.

Nota apreciativa: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: “Una nota mayor a 80 puntos es excelente, mayor de 50 es bueno, mayor de 30 es deficiente y si no es malo. Determinar la condición de un alumno dada su nota final”. R. El objeto es Alumno, o estudiante.

Sobres de dinero: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: “Se tienen 20 sobres con dinero, cada uno con billetes del mismo valor. De cada sobre se conoce el valor del billete y la cantidad. Se requiere determinar el total de dinero entre todos los sobres”. R. Será una caja con 20 sobres; los objetos serán Caja y sobre.

Pares de números: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: “Dado varios pares de números, determinar el porcentaje de pares donde ambos suman más de 10”. R. Imagina un casino donde se juegan dados; los objetos serán Casino y Dados.

Letras: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: “Dadas varias letras, determinar: la cantidad y el porcentaje de vocales procesadas”. R. Los objetos serán Letras y Letra.

Para el resto de los ejercicios anteriores identifica los atributos de los objetos, los requerimientos y la abstracción de la solución.

Ejercicio Atributos Requerimientos Abstracción

UCLA

UCLA: innecesarioDecanato: Nro y Porcentaje de retirados

Cantidad de alumnos que quedan en cada decanato

La diferencia entre 100% y %retirados da %quedan; por regla de tres sale la cantidad partiendo del Nro retirados

Estado civil

Persona: Edo Civil, valor del bien

Monto de la prima

Según el estado civil, se le saca el 10, 15 ó 20% al valor del bien




EmpresaEmpleado: tipo (obrero, admon), sueldo actual

Nuevo sueldo Condicionado al tipo, sumar un 10% ó 15% al sueldo actual

Banco

Banco: monto creaciónCliente: total depositado, total retiros, total comisiones

Cantidad dinero le quedará al banco y a cada cliente

El total de cada cliente es lo depositado menos los retiros menos las comisiones; para el banco se suma cada total de cliente al monto de creación

Profesores

Universidad: Acumulador de cantidad de aprobados y reprobadosProfesor: Cantidad de aprobados y reprobados

% aprobados y % reprobados por cada profesor y % aprobados y % reprobados para toda la universidad

Los aprobados y reprobados dan el 100%, de allí sale el porcentaje de cada uno. Para la Universidad se acumulan los aprobados y reprobados y se sacan los % de manera similar.

Billetes

Inversionistas: innecesarioPersona: CantBill5, CantBill10, CantBill20, CantBill50

Cantidad total de dinero

Se multiplican la CantBill5 X 5, CantBill10 X 10, CantBill20 X 20, CantBill50 X 50 y se suman

Artículos Persona: Costo del artículo

PVP50alCosto y PVP50alPVP

Para ganarle el 50% de lo invertido le suma la mitad del costo; para ganar el 50% del PVP multiplica Costo X 2

SueldoEmpresa: innecesarioVendedor: sueldo base, ventas

Cuánto cobrará el empleado

Se le calcula el 25% de las ventas y se le suma al sueldo base

Enelbar Persona: cantidad de impulsos

Monto a pagar a Enelbar

Condicionado a la cantidad de impulsos, se multiplica el valor respectivo en Bs por la misma

Primas Persona: valor del bien y estado civil

Monto de la prima

Condicionado al estado civil, se calcula por el porcentaje respectivo el valor del bien

Nota apreciativa Alumno: Nota La condición del

alumnoCondicionado a la nota, se determina la condición

Sobres de Dinero

Caja: acumulador de dineroSobre: valor del billete y cantidad de billetes

Total de dinero en la caja

Se multiplica para cada sobre la cantidad por el valor del billete, y se suman los resultados




Pares de números

Casino: Contador de mayores a 10 y cantidad de lanzamientosDados: Número1 y Número2

Porcentaje de lanzamientos que suman más de 10

Se cuentan las veces que suman más de 10 y se divide entre la cantidad de lanzamientos, X 100

Para el resto de los ejercicios realiza una ejemplificación con al menos 5 registros (si aplica). Demuestra la correspondencia con los componentes de los objetos.

Ejercicio Ejemplificación

Circo

Asume entradas a 10, 15 y 20 respectivamenteReg. CantNinos CantAdoles CantAdult PagaFamilia

1 2 0 1 40,002 4 1 2 95,003 2 2 0 50,004 1 1 1 45,00

El objeto familia tiene atributos: CantNinos, CantAdoles, CantAdult y PagaFamilia es un método

UCLA

Nota que se toman ejemplos de fácil procesamientoDecanato Nº retiros % retiros % quedan Total alum TotQuedan

1 40 40% 60% 100 602 20 50% 50% 40 203 10 1% 99% 1000 9904 50 10% 90% 500 4505 1 2% 98% 50 49

Quedan inscritos en la UCLA: 1569Los atributos de Decanato: NroRetiros y PorcRetirosLos métodos de Decanato: PorcQuedan, TotalAl y TotalQuedanMétodos de UCLA: QuedanUCLA

Estado civil

Sea un persona casada con un carro de Bs 100.000, la prima sería de 15.000Para una persona divorciada la prima sería de Bs 20.000

Empresa Si un obrero gana 1500 Bs, el nuevo sueldo será de 1650 BsSi un empleado gana 3000 Bs, el nuevo sueldo será de 3150 Bs



Banco

El banco se crea con Bs 10000,00Cliente BsDeposito BsRetiro BsComision BsQueda

1 1000 500 50 450,002 5000 1000 100 3900,003 8000 1000 50 6950,004 3000 2000 40 960,00

Total le queda al Banco: 22600,00Cliente: atributos= BsDeposito, BsRetiro, BsComision; métodos=BsQuedaBanco: atributos= BsCreacion, métodos= BsQueda

Profesores

Profesor Aprobaron Reprobaron TotalAl %Aprob %Reprob1 90 10 100 90% 10%2 198 2 200 99% 1%3 60 40 100 60% 40%4 20 20 40 50% 50%

Total UCLA 368 72 440 83,63% 16,36%Profesor: atributos= Aprobaron, reprobaron; métodos= TotalAl, PorcAprob, PorcReprobUCLA: atributos: Aprobaron, reprobaron; métodos= TotalAl, PorcAprob, PorcReprob

Sueldo

Empleado SueldoBase Ventas Comisión25 Cobrará1 1500 10000 2500 4000,002 2000 20000 5000 7000,003 1000 4000 1000 2000,004 3000 3000 750 3750,00

Empleado: SueldoBase y Ventas son atributos; Comision25 y Cobrara son métodos

Enelbar Si una persona consume 1500 impulsos, deberá pagar 1500 x 0,08 = Bs 120Si consume 2000, pagará Bs 100

Nota apreciativa Si la nota es 80 sería bueno, 81 sería excelente, 30 deficiente

Pares de números

Reg Valor1 Valor2 Mayor101 5 6 12 2 5 03 1 2 04 4 6 0

Porcentaje donde ambos pares > 10 25%Dados: Atributos= Valor1 y Valor2, Métodos= Mayor10Casino: Atributos= ContaMayor10 y ContaTotal, Métodos= PorcMayor10



Letras

Letra EsVocalS 0E 1O 1I 0P 0

% Vocales: 40%Letra: Atributos= Carácter, Método= EsVocalLetras: Atributos= ContaVocal, ContaTotal, Método= PorcVocales

¿Qué nemotecnia puedes aplicar para identificar en las tablas de ejemplos los componentes de los objetos involucrados? R. Los registros corresponden a una instancia de una clase menor; toda la tabla es un objeto mayor; las columnas de entrada son atributos, las columnas de cálculos son métodos del objeto menor; los cálculos relativos a la tabla son métodos de la clase mayor; los datos de entrada correspondientes a la tabla son atributos de la clase mayor.

Describe en términos de objetos (3 atributos y 3 métodos):

• El estudio: atributos= frecuencia (cada 5 Hrs, diaria, semanal), duración, lugar de estudio; comportamiento= aumentar frecuencia, iniciar estudio, establecer duración

• La luz: atributos= color, intensidad, duración; comportamiento= encender, aumentar intensidad, apagar, colorear

• Un número: atributos= valor, decimales a mostrar, redondear (si o no); comportamiento= quitar decimales, determinar si es par, raíz cuadrada.

• Un poco de agua: atributos= color, sabor, volumen; comportamiento= colorear, vaciar, ondear.

• Una cuerda: atributos= longitud, color, grosor; comportamiento= enrollar, estirar, amarrar.

• Un pañuelo: atributos= alto, ancho, color; comportamiento= doblar, arrugar, lavar.

• Un vidrio: atributos= alto, ancho, espesor; comportamiento= superficie, volumen, colorear

• La flama de un fósforo: atributos= color, tamaño, temperatura; comportamiento= encender, soplar, humear.

• El chorro de agua de una manguera: atributos= velocidad de salida, longitud, altura; comportamiento= abrir, subir, aumentar volumen.

• Una tela que va cayendo: atributos= altura, velocidad, con brisa; comportamiento= lanzar, soplar, plegar.




Si un atributo es de tipo privado, ¿podrás hacer referencia a él en alguna instancia? R. No, la única forma de que las instancias vean los miembros es cuando son de visibilidad pública.

¿Qué tal si el atributo sea protegido? R. igualmente no se puede; la única forma es que sean de tipo público y esto no se recomienda.

¿La visibilidad sólo se aplica a los atributos de las clases? R. No, la visibilidad se aplica a los miembros de los objetos, y los miembros pueden ser tanto atributos como métodos.

¿Qué significa en la práctica el pase de mensajes entre clases? R. Cuando estás programando, el pase de mensajes ocurre cuando una clase invoca un método de otra clase, y le envía argumentos.

Realiza el diagrama de clases para el siguiente planteamiento: “Dado varios pares de números, determinar el porcentaje de pares donde ambos suman más de 10” R.

Realiza el diagrama de clases para el siguiente planteamiento: “En un banco el dinero disponible de la cuenta de un cliente se calcula restando al total depositado el total de retiros y el total de comisiones al banco. Teniendo el monto de creación del banco y la información de varios clientes, ¿Cuánto dinero le quedará a cada uno?, ¿Cuánto al banco?” R.



Casino- ContaMayor10 : int- ContaTotal : int- PorcMayor10 () : float

Dados- Valor1 : int- Valor2 : int- Mayor10 () : boolean

11..*

Banco- BsCreacion : int- BsQueda () : float

Cliente- BsDeposito : float- BsRetiro : float- BsComision : float- BsQueda () : boolean

11..*

Realiza el diagrama de clases para el siguiente planteamiento: “ENELBAR cobra por servicio de la siguiente manera: si consumió menos de 1000 impulsos cada uno costará Bs. 100, si consumió menos de 2000 costará Bs. 80 y Bs. 50 si consumió al menos 2000. Calcular el monto a pagar a ENELBAR dada toda la información necesaria” R.


¿Cómo integra DevC++ todos los componentes de un proyecto de POO? R. lo integras con un archivo con extensión .DEV (Development = desarrollo), el cual se crea cuando haces un proyecto nuevo. Dentro de ese archivo DevC++ coloca toda la información de los archivos que conforman tu proyecto.

¿Qué cuidados debes tener al momento de organizar tus proyectos en tu computador o en tu pen-drive? R. 1- cada proyecto va en una carpeta independiente, 2- los proyectos deben estar guardados en tu computadora, 3- los pen-drive son exclusivamente de trasbordo (puedes perderlos, no guardes allí la copia original de tu proyecto), 4- si no dispones de computador personal, puedes usar tus cuentas de correo o algunas aplicaciones web que te permiten almacenar información.

¿Cómo hacer para interpretar los errores que te reporta DevC++? R. debes leer detenidamente cada mensaje de error y hacer doble clic desde el primero hasta el que te lleve a la línea con el error; preferiblemente toma nota de la traducción de cada error nuevo que identificas, y haces una lista de errores.

¿Quién identifica los errores que ves en la IDE DevC++? R. los identifica el compilador de C++, el cual es un programa de uso común para muchos otras IDEs para el desarrollo de programas con C++

¿Qué son las librerías de uso genérico? R. las librerías de uso genérico almacenan código reusable; la idea es tener fácil acceso a este código con sólo aplicar la directiva #include.

¿Cuáles son los tipos de librerías que pueden usarse con C++? R. están las librerías propias de C++ (tales como iostream, string, vector, etc) y las desarrolladas por ti (definidas por el usuario).



Enelbar- CantImpulsos : int- MontoPagar () : float

¿Por qué se necesitan 2 archivos por cada clase que usa un proyecto? R. un archivo corresponde a la interfaz de la clase (.h = header) y el otro a la implementación (.cpp). El objetivo de separar interfaz de implementación es asegurar el ocultamiento de la información de la implementación (a los usuario finales se les entrega el .h y un pre-compilado de la implementación, así se oculta este código).

¿Cuántos archivos tiene típicamente un proyecto de POO con C++? R. tiene el programa principal y 2 archivos por cada clase (.h + .cpp).

¿Qué propósito tiene la directiva #include? R. esta directiva incluye en tu proyecto las definiciones que están en la librería que se referencia, esto posibilita el uso de las clases y procedimientos reusables.

¿Cómo se usa y qué función cumple cada parte de la directiva #ifndef? R. esta directiva permite indicarle al compilador de C++ que debe compilar sólo una vez la clase en cuestión; cuando se hace referencia a un archivo de clase (con #include) C++ intentará compilarla, pero si lo hace más de una vez se produce un error (en virtud a que ya existe la definición); en tus proyectos posiblemente hagas varios #include a la misma clase en virtud de que la herencia hace necesario estas definiciones en múltiples archivos.

¿Cómo distingue el compilador de C++ que un miembro de clase es un método? R. los métodos se diferencian de los atributos ya que siempre tienen paréntesis en la declaración; si no colocas paréntesis, C++ los tomará como atributos y no como métodos.

¿Cómo enlaza el compilador la interfaz de la clase con su implementación? R. al final del archivo .h debes colocar la directiva que incluye la implementación de la clase (#include xx.cpp)

¿Cómo se indica el tipo de visibilidad que tendrá cada miembro de una clase? R. debes colocar “private:” antes de miembros privados, “protected:” antes de miembros protegidos o “public:” antes de miembros públicos.

¿Si deseas hacer algún comentario en tu programa, cómo lo logras? R. los comentarios de una sola línea van luego de doble signo de división ( // ); también es posible colocar comentarios más largos encerrándolos entre /* y */ (inicio de comentario: /*, fin de comentario: */).

¿Qué reglas debes cumplir en la implementación de una clase? R. cada implementación de un método o un constructor debe llevar el nombre de la



clase como prefijo, luego :: y finalmente el nombre del método o el constructor

¿Qué significa implementar la clase? R. implementar es sinónimo de programar (hacer el programa, desarrollarlo).

¿Qué secuencia de compilación de los archivos del proyecto sigue C++? R. comienza por el programa principal y continúa con los archivos que va consiguiéndose en las referencia #include; cuando termina con ese #include vuelve al punto donde se invocó; si un #include contiene otros #include entonces C++ compila esos archivos, esto sucede en tantos niveles como lo especifique el código fuente.

¿Cuál es la utilidad de la directiva #ifndef? R. para que no se produzca el error de “redefinición de clase”, ya que cada clase sólo debe compilarse una vez.

¿En qué momento se crean las instancias de una clase? R. cuando se declaran variables (objetos) de alguna clase predefinida.

¿De qué formas puedes inicializar los atributos de un objeto? R. pueden inicalizarse si algún constructor se programó para que inicializara los atributos, o también invocando los Sets respectivos.

¿Qué son constructores? R. son un tipo especial de métodos que se invocan automáticamente cuando se declara una instancia de una clase. Su objetivo es la creación de los componentes del objeto y permiten inicializarlos en valores neutros (cero, cadena vacía, espacio en blanco), o con valores de inicialización que vienen por argumentos al constructor.

¿Para qué sirven los métodos Setters y Getters? R. respectivamente para asignar y para obtener el valor de un atributo (Set=Asignar, Get=Obtener).

¿Qué significa “Sólo un conjunto restringido de métodos deben acceder a los atributos”? R. que los atributos no deben accederse directamente desde las instancias, sólo a través de los métodos (usualmente Set o Get).

¿Qué es sobrecarga de métodos? R. la sobrecarga de métodos permite definir métodos o funciones con igual nombre pero con diferentes argumentos; al momento de usar la función o el método, se escogerá el más apropiado dados los datos con los que se cuenta en el momento de la invocación.

¿Qué utilidad tiene la sobrecarga de métodos? R. permite la definición de procesos que pueden realizarse con distintos grupos de argumentos,



posibilitando una misma denominación para el proceso. Ej: una clase Universidad permitiría BuscarAlumno bien sea por cédula o por nombre, pero el método se llamaría igual; en ese caso habrían 2 métodos: uno con un argumento de tipo numérico y el otro con argumento de tipo string, al momento de invocarlo C++ sabría por el argumento a cuál de los 2 se hace referencia.

¿Qué utilidad tiene una IDE como DevC++? R. es una aplicación que ofrece todo lo necesario para desarrollar los programas, desde escribirlos hasta compilarlos, probarlos y depurarlos.

¿Cuáles recomendaciones debes considerar para almacenar los proyectos? R. 1- deben estar cada proyecto en una carpeta, 2- guardar la copia original en tu computador personal (y no en pen-drives), 3- los pen-drives son dispositivos de trasbordo: no debes confiar y guardar allí la copia original ya que puedes perderlos o se dañan.

¿Qué propósito tiene cada paso de la creación de un programa con DevC++? R. 1- Proyecto nuevo crea el .DEV en la carpeta que destinaste, 2- Seleccionas tipo Consola ya que tu programa no correrá en ventanas tipo Windows (eso es más avanzado), 3- cuando incluyes archivos a tu proyecto estás creando tales archivos en la carpeta (bien sea para el .h o para el .cpp), 4- remueves el .cpp del proyecto ya que en caso contrario se producirán errores de compilación. Revisa la ilustración paso a paso para la creación de un proyecto y pregunta el propósito del resto de los pasos.

1.1 PLANTEAMIENTOS DEL TÓPICO EJERCICIOS PROPUESTOS

Dada la letra del sexo de una persona (F o M), programe y muestre si es hombre o mujer. Resuelto en carpeta Proy-Genero

1- Identificación: Dada la letra del sexo de una persona (F o M), programe y muestre si es hombre o mujer

2- Ejemplo: si la letra es ‘f’ o ‘F’ entonces es mujer. Abstracción: condicionado a la letra se retorna el género de la persona

3- Clase: Personasexo: charEsHombre(): booleanDetGenero(): string

4- Programa:#include <iostream>using namespace std;

#include "Persona.h"int main(){ char sexo; cout << "Sexo de la persona (F-M): "; cin >> sexo; Persona p (sexo); cout << "El genero es "; cout << p.DetGenero () << endl; system ("PAUSE");}



#ifndef PERSONA_H#define PERSONA_H#include <string>using namespace std;

class Persona {private: char sexo;public: Persona (char); void SetSexo (char); char GetSexo (); bool EsHombre (); string DetGenero ();};#include "Persona.cpp"#endif

Persona :: Persona (char s){ sexo = s;}void Persona :: SetSexo (char s){ sexo = s;}char Persona :: GetSexo (){ return sexo;}bool Persona :: EsHombre (){ if (sexo == 'f' or sexo == 'F') return false; else return true;}string Persona :: DetGenero (){ if (EsHombre ()) return "Masculino"; else return "Femenino";}

Dada la edad de una persona, determinar si es o no mayor de edad. Resuelto en carpeta Proy-MayorEdad

1- Identificación: Dada la edad de una persona, determinar si es o no mayor de edad.

2- Ejemplo: si la edad es 17 entonces no es mayor de edad. Abstracción: se compara con mayor o igual a 18 para que sea mayor de edad.

3- Clase:Personaedad: intMayorEdad(): boolean


#include "Persona.h"int main(){ int ed; cout << "Edad de la persona: "; cin >> ed; Persona p (ed); if (p.MayorEdad ()) cout << "Es mayor de edad"; else cout << "No es mayor de edad"; cout << endl; system("PAUSE");}


class Persona {private: int edad;public: Persona (int); void SetEdad (int); char GetEdad (); bool MayorEdad();};#include "Persona.cpp"#endif

Persona :: Persona (int e){ edad = e;}void Persona :: SetEdad (int e){ edad = e;}char Persona :: GetEdad(){ return edad;}bool Persona :: MayorEdad (){ if (edad >= 18) return true; else return false;}



En una empresa se asignará un aumento del 10% a todo el personal obrero y un 5% al personal administrativo. Calcular el nuevo sueldo de un empleado dado su tipo y sueldo actual. Resuelto en carpeta Proy-Aumento

1- Identificación: En una empresa se asignará un aumento del 10% a todo el personal obrero y un 5% al personal administrativo. Calcular el nuevo sueldo de un empleado dado su tipo y sueldo actual.

2- Ejemplo: si es obrero y gana 2000, entonces nuevo sueldo es 2200; de ser administrativo el nuevo sueldo sería 2100. Abstracción: condicionado al tipo de empleado, se incrementa 5%ó 10%.

3- Clase:Empleadotipo: charsueldo_act: floatNuevoSueldo(): float

4- Programa:#include <iostream>using namespace std;#include "Empleado.h"int main(){ char tip; cout << "Tipo personal (O=brero, E=mpleado): "; cin >> tip; float sdo; cout << "Sueldo base: "; cin >> sdo; Empleado e (tip, sdo); cout << "El nuevo sueldo es: "; cout << e.NuevoSueldo () << endl; system("PAUSE");}

#ifndef EMPLEADO_H#define EMPLEADO_H#include <string>using namespace std;

class Empleado {private: char tipo; //E:mpleado, O:brero float sueldo_act;public: Empleado (char, float); float NuevoSueldo ();};#include "Empleado.cpp"#endif

Empleado :: Empleado (char t, float s){ tipo = t; sueldo_act = s;}

float Empleado :: NuevoSueldo (){ if (tipo == 'o' or tipo == 'O') return sueldo_act * 1.1; else return sueldo_act * 1.05;}

En una academia se admiten a aquellos jóvenes venezolanos mayores de 18 años, o extranjeros mayores de 21. Dada esta información, determinar si el aspirante es admitido o no. Resuelto en carpeta Proy-Admitido

1- Identificación: En una academia se admiten a aquellos jóvenes venezolanos mayores de 18 años, o extranjeros mayores de 21. Dada esta información, determinar si el aspirante es admitido o no.

2- Ejemplo: si es venezolano con la edad 18 entonces no es admitido; extranjero de 22 años es admitido. Abstracción: se admite si es venezolano > 18 años, o si edad > 21 .



3- Clase:Jovenedad: intvenezolano: boolEsAdmitido(): boolRespAdmitido(): string


#include "Joven.h"int main(){ int ed; cout << "Edad del joven: "; cin >> ed; char resp; bool venz; cout << "Es venezolano (S-N): "; cin >> resp; Joven j (ed, resp == 's' or resp == 'S'); cout << "El joven es: "; cout << j.RespAdmitido () << endl; system ("PAUSE");}

#ifndef JOVEN_H#define JOVEN_H#include <string>using namespace std;

class Joven {private: int edad; bool venezolano; //1=si, 0=nopublic: Joven (int, bool); bool EsAdmitido (); string RespAdmitido ();};#include "Joven.cpp"#endif

Joven :: Joven (int e, bool v){ edad = e; venezolano = v;}

bool Joven :: EsAdmitido (){ if (venezolano and edad > 18 or edad > 21) return 1; else return 0;// Tambien sirve: return venezolano and edad > 18 or edad > 21}

string Joven :: RespAdmitido (){ if (EsAdmitido ()) return "ADMITIDO"; else return "NO ADMITIDO";}

Dado un número entero, determinar si es múltiplo de 3 y si es múltiplo de 5. Resuelto en carpeta Proy-Multiplo

1- Identificación: Dado un número entero, determinar si es múltiplo de 3 y si es múltiplo de 5.

2- Ejemplo: si el número es 10 sólo es múltiplo de 5; de ser 15 sí es múltiplo de 3 y 5. Abstracción: se usa el operador módulo (#) y se verifica con 3 y con 5.

3- Clase:Numeroentero: intMultiplo3y5 (): booleanRespMultiplo (): string


#include "Numero.h"int main (){ int e; cout << "Numero entero: "; cin >> e; Numero n (e); cout << "El numero "; cout << n.RespMultiplo (); cout << " es multiplo de 3 y de 5" << endl; system ("PAUSE");}



#ifndef NUMERO_H#define NUMERO_H#include <string>using namespace std;

class Numero {private: int entero;public: Numero (int); bool Multiplo3y5 (); string RespMultiplo ();};#include "Numero.cpp"#endif

Numero :: Numero (int n){ entero = n;}

bool Numero :: Multiplo3y5 (){ return entero % 3 == 0 and entero % 5 == 0;}

string Numero :: RespMultiplo (){ if (Multiplo3y5 ()) return "SI"; else return "NO";}



ENELBAR cobra por servicio de la siguiente manera: si consumió menos de 1000 impulsos cada uno costará Bs. 100, si consumió menos de 2000 costará Bs. 80 y Bs. 50 si consumió al menos 2000. Calcular el monto a pagar a ENELBAR dada toda la información necesaria. Resuelto en carpeta Proy-ENELBAR

1- Identificación: ENELBAR cobra por servicio de la siguiente manera: si consumió menos de 1000 impulsos cada uno costará Bs. 100, si consumió menos de 2000 costará Bs. 80 y Bs. 50 si consumió al menos 2000. Calcular el monto a pagar a ENELBAR dada toda la información necesaria.

2- Ejemplo: Si una persona consume 1500 impulsos, deberá pagar 1500 x 0,08 = Bs 120; Si consume 2000, pagará Bs 100. Abstracción: Un anidamiento de if resuelve el problema.

3- Clase:Servicioimpulsos: intMontoAPagar (): float


#include "Servicio.h"int main (){ int imp; cout << "Cantidad impulsos: "; cin >> imp; Servicio s (imp); cout << "El monto a pagar es: "; cout << s.MontoAPagar () << endl; system ("PAUSE");}

#ifndef SERVICIO_H#define SERVICIO_Husing namespace std;

class Servicio {private: int impulsos;public: Servicio (int); float MontoAPagar ();};#include "Servicio.cpp"#endif

Servicio :: Servicio (int i){ impulsos = i;}

float Servicio :: MontoAPagar (){ if (impulsos < 999) return impulsos * 0.1; else if (impulsos < 1999) return impulsos * 0.08; else return impulsos * 0.05;}

A un vendedor se le asignará una comisión del 5% si sus ventas son hasta Bs. 500, el 10% si son hasta Bs. 2.000, y el 15% si vende más de 2.000. Calcular la comisión. Resuelto en carpeta Proy-Comision

1- Identificación: A un vendedor se le asignará una comisión del 5% si sus ventas son hasta Bs. 500, el 10% si son hasta Bs. 2 .000 , y el 15% si vende más de 2.000. Calcular la comisión.

2- Ejemplo: Si una vendedor vende 400 la comisión será Bs 20; Si vende 2000, será Bs 200. Abstracción: Un anidamiento de if resuelve el problema.



3- Clase:Vendedorventas: floatDetComision (): float


#include "Vendedor.h"int main (){ float vt; cout << "Monto de ventas: "; cin >> vt; Vendedor v (vt); cout << "La comision es: "; cout << v.DetComision () << endl; system ("PAUSE");}

#ifndef VENDEDOR_H#define VENDEDOR_Husing namespace std;

class Vendedor {private: float ventas;public: Vendedor (float); float DetComision ();};#include "Vendedor.cpp"#endif

Vendedor :: Vendedor (float v){ ventas = v;}

float Vendedor :: DetComision (){ if (ventas <= 500) return ventas * 0.05; else if (ventas <= 2000) return ventas * 0.1; else return ventas * 0.15;}

#ifndef SERVICIO_H#define SERVICIO_Husing namespace std;

class Servicio {private: int impulsos;public: Servicio (int); float MontoAPagar ();};#include "Servicio.cpp"#endif

Servicio :: Servicio (int i){ impulsos = i;}

float Servicio :: MontoAPagar (){ if (impulsos < 999) return impulsos * 0.1; else if (impulsos < 1999) return impulsos * 0.08; else return impulsos * 0.05;}

Una nota mayor a 80 puntos es excelente, mayor de 50 es bueno, mayor de 30 es deficiente y si no es malo. Determinar la condición de un alumno dada su nota final. Resuelto en carpeta Proy-CondicionAl

1- Identificación: Una nota mayor a 80 puntos es excelente, mayor de 50 es bueno, mayor de 30 es deficiente y si no es malo. Determinar la condición de un alumno dada su nota final.

2- Ejemplo: Si la nota final es 50, la condición es deficiente; 51 es bueno. Abstracción: Un anidamiento de if resuelve el problema.



3- Clase:Alumnonota: intDetCondicion (): string


#include "Alumno.h"int main (){ int nt; cout << "Nota del alumno: "; cin >> nt; Alumno al (nt); cout << "La condicion es: "; cout << al.DetCondicion () << endl; system ("PAUSE");}

#ifndef ALUMNO_H#define ALUMNO_H#include <string>using namespace std;

class Alumno {private: int nota;public: Alumno (int); string DetCondicion ();};#include "Alumno.cpp"#endif

Alumno :: Alumno (int n){ nota = n;}

string Alumno :: DetCondicion (){ if (nota > 80) return "EXCELENTE"; else if (nota > 50) return "BUENO"; else if (nota > 30) return "DEFICIENTE"; else return "MALO";}

Dado el estado civil de una persona, determinar la prima a pagar por un seguro según lo siguiente: Solteros o Viudos 10%, Casados 15%, Divorciados 20%. Calcular el monto de la prima dado el estado civil de la persona y el valor del bien a asegurar. Resuelto en carpeta Proy-Seguro

1- Identificación: Dado el estado civil de una persona, determinar la prima a pagar por un seguro según lo siguiente: Solteros o Viudos 10%, Casados 15%, Divorciados 20%. Calcular el monto de la prima dado el estado civil de la persona y el valor del bien a asegurar.

2- Ejemplo: Si el estado civil es viudo y el bien vale 1000, la prima será 100; de ser divorciado sería 200. Abstracción: Un anidamiento de if resuelve el problema.

3- Clase:Personaedo_civil: charvalor_bien: floatDetMontoPrima (): float


#include "Persona.h"int main (){ char ec; cout << "Estado civil (S=olt, C=asad, V=iud, D=ivorc): "; cin >> ec; float valor; cout << "Valor del bien: "; cin >> valor; Persona p (ec, valor); cout << "El monto de la prima es: "; cout << p.DetMontoPrima () << endl; system ("PAUSE");}




class Persona {private: char edo_civil; float valor_bien;public: Persona (char, float); float DetMontoPrima ();};#include "Persona.cpp"#endif

Persona :: Persona (char e, float v){ edo_civil = e; valor_bien = v;}

float Persona :: DetMontoPrima (){ if (edo_civil == 's' or edo_civil == 'S' or edo_civil == 'v' or edo_civil == 'V') return valor_bien * 0.1; else if (edo_civil == 'c' or edo_civil == 'C') return valor_bien * 0.15; else return valor_bien * 0.2;}





1 BIBLIOGRAFÍA

➢ JOYANES AGUILAR L. (2000) Programación en c++. Algoritmos, estructuras de datos y objetos. Mc.Graw Hill/Interamericana de España: Madrid.

➢ Aplique Turbo C++ Para Windows Turbo C++ for Windows Inside and Out Schildt, Herbert Jimenez Ferry, Eduardo (Traductor); Vaquero Zanchez, Antonio (Revisor) Osborne/McGraw-HiII , Berkeley, ESTADOS UNIDOS

➢ Borland C ++ Manual de Referencia Schildt, Herbert Becerra T., Antonio (Traductor); Guirado C., Rafael (Traductor); Iribarne M., Luis F. (Traductor); Túnez R., Samuel (Revisor); Vaquero S., Antonio (Revisor) Osborne/McGraw-Hill , Madrid, ESPAÑA

➢ C++ a su Alcance: Un Enfoque Orientado a Objetos Joyanes AguiJar, Luis McGraw-HiII, México, MEXICO

➢ C++ Manual de Bolsillo Joyanes Aguilar, Luis McGraw-HiII , Madrid, ESPAÑA

➢ Object Oriented Programming With Borland C++4 Walnum, Clayton Que Corporation, Carmel, ESTADOS UNIDOS

➢ Object-Oriented Programming with C++ Ege, Raimund K. AP Professional, Boston, ESTADOS UNIDOS, 2da ed.

➢ http://www.devjoker.com/contenidos/Tutorial-C/130/Definici%C3%B3n-de-clases.aspx

➢ http://www.intap.net/~drw/cpp/index.htm

➢ http://sistemas.itlp.edu.mx/tutoriales/tutorc/index.htm

➢ http://www.programacionfacil.com/cpp/start

➢ http://c.conclase.net/curso/

➢ http://www.mailxmail.com/curso-programacion-c

➢ http://www.lawebdelprogramador.com/cursos/cplusplus/


58947061 Introduccion POO

Documents

Transcript of 58947061 Introduccion POO