Introducción POO

Universidad Centroccidental Lisandro Alvarado Sistema de Educacin a Distancia Decanato de Ciencias y Tecnologa
QU??? del Objetos que! buena Qu ...Voy con DCyT Reglamento dePrograma Evaluacin
que le corresponda, obtiene nota con Elestudiante y se se cada multiplicando la ndice multiplico suman los ta fcil ! ... de rendimiento C++ productos obtenidos y este y resultado seessumoentre la suma obtenida en acadmico divide los resultados susltima calificacin definitiva deylos crditos computados crditos, la valoracin - Orientado Abstraccin !... el nmero de crditos cuantitativa del logro del cada asignatura la luego divido entrepor suma de slo + Objetos los crditos...
GUA DIDACTICA
Introduccin a la Programacin Orientada a Objetos con C++

Profesor Giovanni Torrealba Barquisimeto, Octubre 2010
Datos de Identificacin
Elaborado por: Correo-electrnico: Fecha Elaboracin: Fecha de ltima Actualizacin: Profesor Giovanni Torrealba g_torrealba@ucla.edu.ve Octubre 2010 Octubre 2010
Profesor Giovanni Torrealba
TABLA DE CONTENIDO
Pg
duccin a la Programacin Orientada a Objetos con C++
INTRODUCCIN........................................................................1
ESTRATEGIAS DE ENSEANZA EN ESTA GUA DIDCTICA.....................3
2.1 Filosofa para la transmisin del conocimiento........................................................................3
2.1.1 Referencias cruzadas...............................................................................................................3
2.1.2 Imgenes alusivas......................................................................................................................3
2.1.3 Otras estrategias de organizacin de la gua.....................................................................4
2.2 Ejercicios por tpico......................................................................................................................4
2.3 Tablas resumen y/o comparativas..............................................................................................5
2.4 Mapas mentales...............................................................................................................................5
CONOCIMIENTOS PRELIMINARES...................................................7
3.1 Creacin de programas..................................................................................................................7
3.2 Funciones...........................................................................................................................................8
3.2.1 Implementacin de una Funcin.............................................................................................8
3.2.2 Parmetros de una funcin......................................................................................................9
3.2.3 Tipos de parmetros segn lo que retornan.......................................................................9
3.2.4 Tipos de parmetros segn su ubicacin............................................................................10
3.2.5 Ejemplos de funciones.............................................................................................................11
3.3 Estado de la memoria en una ejecucin...................................................................................12
3.4 Corridas en fro.............................................................................................................................13
3.5 Depuracin de programas............................................................................................................16
3.5.1 Cmo activar la depuracin 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 cdigo de subrutinas, funciones o mtodos..............................................19
3.5.6 Otras opciones de depuracin..............................................................................................20
3.5.7 Aprovechar las herramientas de depuracin...................................................................20
3.6 Sintaxis de comandos de programacin..................................................................................20
3.6.1 Ejemplos de sintaxis de comandos en C++.........................................................................21
3.7 Mtricas de programacin: legibilidad del cdigo................................................................22
3.8 Entrada de datos desde archivos.............................................................................................24
3.8.1 Manipulacin 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
CONCEPTUALIZACIN DE PROGRAMACIN ORIENTADA A OBJETOS (POO)..29
4.1 Qu es la Programacin Orientada a Objetos?..................................................................29
4.1.1 Ejemplo de otros paradigmas de programacin:.............................................................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 Composicin de los objetos.........................................................................................................31
4.3.1 Atributos...................................................................................................................................32
4.3.2 Mtodos.....................................................................................................................................32
4.3.3 Ejemplos de Objetos..............................................................................................................33
4.4 Lenguajes Orientados a Objetos..............................................................................................35
4.5 Pilares de la Programacin Orientada a Objetos.................................................................38
4.5.1 Abstraccin...............................................................................................................................38
4.5.2 Encapsulamiento.......................................................................................................................40
4.5.3 Herencia.....................................................................................................................................40
4.5.4 Polimorfismo.............................................................................................................................42
IDENTIFICACIN DE OBJETOS.....................................................47
5.1 Tcnicas para identificar objetos y componentes...............................................................48
5.2 Ejemplificacin de requerimientos..........................................................................................49
5.3 Equivalencias entre ejemplificacin tabulada y POO...........................................................51
5.4 El control remoto de los objetos..............................................................................................52
5.5 Ejercicios resueltos y propuestos............................................................................................55
REPRESENTACIN DE CLASES.......................................................61
6.1 UML...................................................................................................................................................61
6.2 Notacin grfica de clases con UML........................................................................................61
6.3 Relaciones entre clases - Diagramas de clases.....................................................................63
6.4 Paso de mensajes..........................................................................................................................63
OBJETOS EN C++.....................................................................67
7.1 Batera de ejercicios resueltos................................................................................................67
7.2 Estructura de un POO con C++..................................................................................................67
7.3 Interfaz e implementacin de clases......................................................................................68
7.3.1 Interfaz de clases con C++...................................................................................................68
7.3.2 Implementacin de clases con C++......................................................................................70
7.4 El programa principal y su compilacin....................................................................................71
7.5 Acceso a los datos de una clase................................................................................................73
7.5.1 Constructores y destructores.............................................................................................74
7.5.2 Sobrecarga de mtodos.........................................................................................................75
7.5.3 Setters (Sets) y Getters (Gets).........................................................................................75
7.6 Integracin de los componentes del proyecto con POO y DevC++..................................77
7.7 Demostracin paso a paso: crear un POO con DevC++........................................................79
7.8 Recomendaciones para la identificacin de errores al compilar......................................80
7.8.1 Metodologa para corregir errores de compilacin con Devc++...................................81
7.8.2 Algunos errores tpicos que reporta el Lenguaje C++.....................................................81
METODOLOGA PARA EL ANLISIS Y PROGRAMACIN ORIENTADA A OBJETOS...............................................................................87
8.1 Justificacin de la necesidad de una metodologa...............................................................88
8.2 Demostracin de la aplicacin de la metodologa.................................................................89
8.3 Ejemplos de programas orientados a objetos.......................................................................91
8.4 Ejercicios propuestos..................................................................................................................93
RESPUESTAS A EJERCICIOS PROPUESTOS........................................95
9.1 Planteamientos del tpico 4.1.2.................................................................................................95
9.3 Planteamientos del tpico 4.3.4................................................................................................96
9.5 Planteamientos del tpico 4.5.5................................................................................................98
9.6 Planteamientos del tpico 5.5..................................................................................................100
9.9 Planteamientos del tpico 8.4...................................................................................................111
10 BIBLIOGRAFA.......................................................................119
Bibliografa
Decanato de
NDICE DE ILUSTRACIONES
Pg
Ilustracin 1: demostracin de las partes de una tabla resumen / comparativa...................5 Ilustracin 2: estrategias de enseanza / aprendizaje en esta gua didctica.....................6 Ilustracin 3: Pasos durante la creacin de un programa...................................................7 Ilustracin 4: Ejemplo de una Funcin con parmetros....................................................11 Ilustracin 5: Ejemplo de una Funcin sin parmetros.....................................................12 Ilustracin 6: Extracto de programa que multiplica los primeros N nmeros.....................13 Ilustracin 7: Programa que multiplica los primeros N nmeros. Correccin 1....................14 Ilustracin 8: Programa que multiplica los primeros N nmeros. Correccin 2...................15 Ilustracin 9: Programa que multiplica los primeros N nmeros. Solucin final..................15 Ilustracin 10: Cmo activar la depuracin de un programa con DevC++............................17 Ilustracin 11: Cmo comenzar a depurar con DevC++.....................................................17 Ilustracin 12: Depuracin paso a paso con DevC++.........................................................18 Ilustracin 13: Observar el valor de variables mientras depuras.....................................19 Ilustracin 14: Entrar en el cdigo de subrutinas, funciones o mtodos............................19 Ilustracin 15: Ejemplo de aplicacin de mtricas de programacin.................................23 Ilustracin 16: Sintaxis para abrir un archivo de texto...................................................26 Ilustracin 17: Programa con entrada exclusiva por archivo de texto...............................27 Ilustracin 18: Un Telfono en trminos de objetos.......................................................33 Ilustracin 19: Una Cuenta Bancaria en trminos de objetos...........................................33 Ilustracin 20: Un Automvil en trminos de objetos.....................................................34 Ilustracin 21: IDE DevC++, para el Lenguaje Orientado a Objetos C++............................36 Ilustracin 22: Pilares de la Programacin Orientada a Objetos......................................38 Ilustracin 23: Jerarqua de clases de transportes........................................................41 Ilustracin 24: Demostracin de un caso de polimorfismo...............................................43 Ilustracin 25: Identificacin de objetos y sus componentes (Ejemplo Organizacin).......48 Ilustracin 26: Identificacin de objetos y miembros por ejemplificacin tabulada..........51 Ilustracin 27: El cielo en la pantalla del computador.....................................................52 Ilustracin 28: El control remoto del cielo.....................................................................53 Ilustracin 29: funcionamiento del control remoto del cielo............................................54 Ilustracin 30: El ejemplo Trabajadores en la pantalla del computador............................54 Ilustracin 31: funcionamiento del control remoto del problema Organizacin..................55 Ilustracin 32: Representacin de una clase segn la notacin UML.................................61 Ilustracin 33: Sintaxis para representar los atributos en la clase, segn UML................62 Ilustracin 34: Sintaxis para representar los mtodos en la clase, segn UML.................62 Ilustracin 35: Diagrama de clases base para ejemplo de la Organizacin........................63 Ilustracin 36: Sintaxis para la programacin de la interfaz de una clase........................69 Ilustracin 37: Archivo Trabajador.h con la interfaz de la clase.....................................70 Ilustracin 38: Archivo Trabajador.cpp con la implementacin de la clase........................70 Ilustracin 39: Archivo Trabajador.h con la interfaz de la clase.....................................71 Ilustracin 40: Sintaxis para la programacin del programa principal...............................72
Universidad Centroccidental Lisandro Alvarado
Ilustracin 41: Archivo Principal.cpp con el Programa Principal........................................73 Ilustracin 42: Archivo Trabajador.h con la interfaz de la clase.....................................76 Ilustracin 43: Archivo Trabajador.cpp con la implementacin de la clase........................76 Ilustracin 44: Integracin de componentes de un POO con el proyecto en DevC++...........77 Ilustracin 45: Barra de herramientas en la IDE de DevC++............................................78 Ilustracin 46: Paso a paso para crear un POO con DevC++.............................................79 Ilustracin 47: Sintaxis para la programacin del programa principal...............................80 Ilustracin 48: Ejemplo 1 de aplicacin de metodologa...................................................89 Ilustracin 49: Ejemplo 2 de aplicacin de metodologa..................................................90 Ilustracin 50: Ejemplo 3 de aplicacin de metodologa..................................................90 Ilustracin 51: Ejemplo 1 de POO (Proy-CtaBanco).........................................................91 Ilustracin 52: Del ejemplo y abstraccin al POO (Proy-CtaBanco)..................................91 Ilustracin 53: Ejemplo 2 de POO (Proy-NroEntero)......................................................92 Ilustracin 54: Ejemplo 3 de POO (Proy-Llamada)..........................................................92 Ilustracin 55: Del ejemplo y abstraccin al POO (Proys Llamada y NroEntero)................93 Ilustracin 55: Del ejemplo y abstraccin al POO (Proys Llamada y NroEntero).
Decanato de
NDICE DE TABLAS
Pg
Tabla 1: comparacin entre parmetros por valor y por referencia..................................10 Tabla 2: compatibilidad entre parmetros formales y parmetros actuales......................11 Tabla 3: Primera corrida en fro, se identifica un problema.............................................14 Tabla 4: Segunda corrida en fro, se identifica otro problema.........................................14 Tabla 5: Tercera corrida en fro, se identifica otro problema.........................................15 Tabla 6: Comparacin entre clases, instancias y objetos.................................................31 Tabla 7: tabulacin de informacin y requerimientos (ejercicio de la organizacin)...........51 Tabla 8: Ejemplificacin del ejercicio de los billetes......................................................57 Tabla 9: Ejemplificacin del ejercicio de los artculos....................................................57 Tabla 10: Ejemplificacin del ejercicio de los sobres de dinero.......................................57 Tabla 11: Efecto del tipo de visibilidad de miembros......................................................62 Tabla 11: Efecto del tipo de visibilidad de miembros
2 INTRODUCCIN
La Programacin de Computadoras es una tcnica que ha ido evolucionando desde hace ya varias dcadas, 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 lea una mquina), luego por la muy arraigada programacin estructurada, hasta establecerse de la manera ms natural en la actualidad con la Programacin Orientada a Objetos (POO). Esta forma de programar se basa en las caractersticas de las cosas que conforman la situacin problemtica, observndolas y describindolas tal y como las ves en el mbito real: con sus propiedades y su comportamiento. La gran mayora de los lenguajes actuales de programacin admiten bien sea todas las caractersticas de la Programacin Orientada a Objetos, o algn subconjunto del mismo. En lo que te resta de carrera, e incluso en tu vida profesional como Ingeniero Informtico o Analista de Sistemas, estars estrechamente vinculado a las tcnicas, diseos y metodologas orientadas a objetos, actividades imprescindibles en la implantacin de soluciones software. Esta gua te ofrece: Conocimientos bsicos y herramientas tiles para las actividades de programacin. Conceptualizacin de la POO. Metodologa para el diseo y modelaje de planteamientos con POO. Aplicacin de POO con el Lenguaje C++. Mltiples ejercicios resueltos y propuestos en cada captulo. Soluciones a los ejercicios propuestos. La gua se ha concebido con tcnicas ilustrativas nemotcnicas que te permiten identificar rpidamente la idea que se te presenta. La seccin de Estrategias de Enseanza te explica cmo sacarle mximo provecho a esto.
Anmate y vamos juntos a aprender a programar con POO!!!

Decanato de
2 ESTRATEGIAS DE ENSEANZA EN ESTA GUA DIDCTICA

La gua se ha diseado de manera que cuentes con distintas herramientas de comprensin del contenido, posibilitndote un estudio ms ameno e interactivo. A medida que avances en los contenidos de la gua, te resultar ms fcil navegar en la lectura y estudiar de la misma. Entre las tcnicas que se aplican en toda la gua encontrars: referencias cruzadas, mapas mentales, tablas comparativas y fichas resumen. Otro elemento que encontrars es que cada tpico 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 enfrentars en las evaluaciones.
2.1
FILOSOFA
PARA LA TRANSMISIN DEL CONOCIMIENTO
Se ha procurado el uso intensivo de imgenes, ilustraciones y tablas resmenes que demuestren el contenido de los objetivos planteados de una manera grfica.
Una imagen dice ms que mil palabras Un grfico dice ms que mil imgenes !
2.1.1 REFERENCIAS
CRUZADAS
Las referencias cruzadas te indicarn el lugar donde puedes obtener mayor informacin de un tpico. La referencia te llevar a la pgina exacta donde conseguirs el detalle que buscas. Ejemplo:
Aprende ms de referencias cruzadas en Pg. Error: Reference source not found

2.1.2 IMGENES
ALUSIVAS
Cuando veas las siguientes imgenes, esto es lo que significan: IDEA: estars frente a un planteamiento genial.
TIP: nota o recomendacin; seguramente vers indicaciones de cmo lograr o cmo entender algo de una manera ms fcil.
SOLUCIN: cuando veas el cubo mgico armado, estars frente a ejercicios ya resueltos! PROBLEMA: el cubo mgico por armar indica ejercicios propuestos.

1.1.1
REFERENCIA CRUZADA: la lupa en el libro te invita a buscar ms informacin en el sitio indicado. MAPA MENTAL: te indica que la ilustracin est estructurada como un mapa mental del tema o tpico.
OTRAS
ESTRATEGIAS DE ORGANIZACIN DE LA GUA
Encontrars en toda la gua los siguientes instrumentos que te permitirn comprender ms fcilmente el conocimiento que queremos transmitirte: Ejercicios por tpico. Tablas resumen y/o comparativas. Mapas mentales.
Seguidamente te explicamos un poco ms en detalle cada una de estas estrategias, para que los asimiles al mximo.
1.1
EJERCICIOS
POR TPICO
Cada tpico de esta gua didctica se ha concebido con uno o varios ejercicios resueltos, ideados con el mismo nivel de dificultad al que te enfrentars en las evaluaciones. Por otra parte, tambin dispondrs de mltiples ejercicios propuestos, mismos que te invitamos a resolver en su totalidad. Al final de la gua didctica conseguirs las respuestas a los ejercicios propuestos. Recuerda que en programacin hay muchas formas de resolver el mismo problema, pero siempre con la condicin de que se cumplan con las reglas del ejercicio planteado y los objetivos por evaluar. Considerando esto, la respuesta que encontrars seguramente corresponder a una de las soluciones posibles.
Decanato de
1.2
TABLAS
RESUMEN Y/O COMPARATIVAS
Cuando veas tablas con informacin tabulada, concntrate en la idea que se intenta transmitir en cada uno de sus ttulos, filas, columnas y celdas. Los ttulos de la tabla, de las filas y columnas te darn la explicacin del contenido respectivo. Posiblemente en la celda donde se cruzan los ttulos consigas informacin del tema tratado en filas y el tratado en columnas.
En una tabla tambin 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:
EnTema tabla hayde registros y 2 (Ao) esta deTtulo(Estado) y columnas campos DE UNA TABLA RESUMEN / COMPARATIVA IDENTIFICACIN DE LAS PARTES Ttulos decolumnas filasCeldasfilas Ttulos 3 tabla de la
Ilustracin 1: demostracin 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.
En esta gua, las partes de una Tabla Resumen se explicaron usando un mapa mental. Observa el tpico Tablas resumen y/o comparativas y vers cmo 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 enseanza y aprendizaje que te hemos presentado.
Decanato de
oblema: indicanmgico armado, planteamientosusalgoenresueltos p: indica cubo dondede cmoarmarmsentender ttulos,una manera EN ESTA dificultad de las evaluaciones. renciaIdea:cubo ESTRATEGIASte indica y/o genial APRENDIZAJE ms y celdas. idea Tecruzada: ilustracinabuscar indica y propuestos,mapael indicado fcil GUA DIDCTICA didctica tiene varios puedesun resueltosinformacindeel filas, mismo nivel de cin:que el intentaTablas est porENSEANZA /ya con mental : vers que una mgico por buscar ms ejercicios un sitio columnas el indicaciones ejercicios DE o uno de como propuestos se estars transmitir en estructurada te frentea Resumeninformacin invita ejercicios Referenciascada Imgeneslograr Ejercicios Al final Cruzadasde la gua estn las soluciones. Comparativas tpico Alusivas
Ilustracin 2: estrategias de enseanza / aprendizaje en esta gua didctica.
2
3 CONOCIMIENTOS PRELIMINARES
Los siguientes tpicos constituyen un conocimiento que debes dominar antes de que empieces a trabajar con Programacin Orientada a Objetos. Posiblemente ya manejes las definiciones y trminos que se presentan, de manera que revsalos detenidamente y verifica que los dominas, ya que en la gua se hacen muchas referencias a los mismos.
3.1
CREACIN
DE PROGRAMAS
El proceso de crear un programa de computadoras consiste, en trminos generales, en la siguiente secuencia de pasos: Construir el Programa Codificarel Programa Compilar el Programa Obtener Enlazar Ejecutable Objeto Fuente
Ilustracin 3: Pasos durante la creacin de un programa.

Codificar el Programa Fuente: el programa fuente consiste en todos los archivos con las lneas de cdigo que hacemos en un programa. en este curso, el cdigo 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 compilacin se invoca desde la interfaz de desarrollo (IDE) la cual se vale del compilador del lenguaje respectivo.
Decanato de
Construir el Programa Objeto: el slo hecho de que el programa fuente sea sintcticamente correcto no garantiza que vaya a funcionar. El programa objeto se crea automticamente luego de la compilacin es exitosa, y lo que resulta es un cdigo intermedio que contiene mltiples tablas con las referencias a variables y llamadas a subrutinas, funciones y mtodos, para su posterior verificacin 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, funcin o mtodo est disponible en el programa fuente o en las libreras que se incluyeron. Obtener el Programa Ejecutable: una vez se superan exitosamente las etapas anteriores, se produce el programa ejecutable, el cual podrs hacerle doble clic en el explorador de archivos y hacerlo funcionar. En Windows los programas ejecutables tienen extensin EXE.
1.1
FUNCIONES
Una funcin contiene una o ms sentencias y se crean generalmente para realizar una nica tarea. En la Programacin Orientada a Objetos, las funciones se utilizan para definir los mtodos de las clases. Cuando ests haciendo programas y veas que se refieren a mtodos, entonces sabrs que se trata de funciones definidas por el usuario.
Todos los lenguajes de programacin ofrecen innumerables funciones que ya estn programadas, y tambin la posibilidad de crear nuevas por parte del programador. A estas se les denomina Funciones Definidas por el Usuario, considerndote a ti como usuario del Lenguaje (programador).
1.1.1 IMPLEMENTACIN
DE UNA
FUNCIN
Para que puedas programar una funcin, debes seguir la siguiente sintaxis:
tipo_de_retorno NombreFuncion (lista parmetros) { sentencias return valor; }
Cuando en el tipo de retorno aparece la palabra reservada void significa que la funcin no retorna ningn valor.
void NombreFuncion (lista parmetros) { sentencias ..... }
Usualmente se les denomina Procedimientos a las funciones que no retornan ningn valor
1.1.2 PARMETROS
DE UNA FUNCIN
Los parmetros se usan para enviar valores a una funcin, con los que ella trabajar para realizar los procesos. Son los valores de entrada que recibe una funcin. Por ejemplo, una funcin que realizase una suma de dos nmeros tendra como parmetros a esos dos nmeros. Los dos nmeros son la entrada, as como la salida sera el resultado. Tambin se conocen como Argumentos. Una funcin puede utilizar parmetros por valor y parmetros por referencia, o puede no tener parmetros.
1.1.3 TIPOS
DE PARMETROS SEGN LO QUE RETORNAN
Segn el valor que puede retornar un argumento, los parmetros se clasifican en parmetros por valor o por referencia. PARMETROS POR VALOR: El paso de argumentos por valor significa que al compilar la funcin y el cdigo que llama a la funcin, sta recibe una copia de los valores de los parmetros que se le pasan como argumentos. PARMETROS POR REFERENCIA: Cuando una funcin debe modificar el valor de la variable pasada como parmetro y que esta modificacin retorne a la funcin llamadora, se debe pasar el parmetro por referencia.
Los parmetros por referencia tambin pueden identificarse ya que constituyen parmetros de entrada y salida. Los parmetros por valor son slo de entrada. En este mtodo, el compilador no pasa una copia del valor del argumento; en su lugar, pasa una direccin de memoria, que indica a la funcin dnde existe la direccin de los argumentos pasados.
Decanato de
Para declarar un parmetro como paso por referencia, el smbolo & debe preceder al nombre del parmetro.
COMPARACIN
Comparacin Tipo parmetro
ENTRE PARMETROS POR VALOR Y POR REFERENCIA
Por valor Se declaran sin & Copia de los valores de los argumentos que se pasan No cambia el valor del argumento original Solo de entrada
Por referencia Se declaran con & El mismo valor que el argumento que se pasa (la misma direccin) El cambio es retornado al argumento original Son de entrada y salida
Cmo identificarlos Qu recibe la funcin Cmo se afecta el parmetro que se enva Entrada y/o salida
Tabla 1: comparacin entre parmetros por valor y por referencia

1.1.1 TIPOS
DE PARMETROS SEGN SU UBICACIN
Tanto en la definicin (cabecera) de la funcin como en las llamadas deben colocarse parmetros; la siguiente terminologa los distingue Parmetros formales: estn en la definicin de la funcin (cabecera). Debe indicarse el tipo de cada argumento. Slo se definen 1 vez, 2 veces cuando se trabaja con clases (una en la interfaz y otra en la implementacin). Parmetros actuales: estn en cada llamada a una funcin. No debe colocarse el tipo de cada argumento. Los veremos mltiples veces, todas las que sea necesaria, en un programa; cada vez que se invoca a una funcin, esos parmetros sern actuales.
Para que la invocacin a una funcin est correcta sintcticamente en sus parmetros actuales con respecto a los parmetros formales, deben cumplirse las siguientes reglas:
COMPATIBILIDAD ENTRE PARMETROS FORMALES Y PARMETROS ACTUALES
Regla Compatibilidad
Debe cumplir con lo siguiente Para N parmetros formales deben haber N parmetros actuales. Ej: si hay 3 parmetros en los formales, deben haber 3 en los actuales Deben ser parmetros del mismo tipo. Ej: Si en los formales
Misma cantidad Mismo tipo
hay un char y un int, igualmente deben haber un char y un int en los actuales 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 parmetros tienen el mismo tipo pero no estn en el mismo orden.
Mismo orden
Tabla 2: compatibilidad entre parmetros formales y parmetros actuales

1.1.1 EJEMPLOS
DE FUNCIONES
void ImprimirMensaje Llamado de lade una Funcin con parmetros Parmetros actuales ImprimirMensaje { Parmetros funcin (string mensaje) Ejemplo cout lade mensaje << endl; siguientes datos:); ImprimirMensaje (Ingrese los formales<< de funcin } la funcin
Ilustracin 4: Ejemplo de una Funcin con parmetros.

void Ejemplo funciones { Llamado de las de Funciones sin parmetros Funciones colocan parntesis que IgualLimpiarPantalla () anteriores se que system (cls); LimpiarPantalla ();argumentos) no ameritan abre y cierra (sin } DetenerPantalla (); argumentos void DetenerPantalla () { system (pause); }
Ilustracin 5: Ejemplo de una Funcin sin parmetros.
Decanato de
1.2
ESTADO
DE LA MEMORIA EN UNA EJECUCIN
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 mltiplos de bytes (8 bits); as por ejemplo, para un dato boolean se destinar 1 Byte (aunque slo se guarde un uno o un cero), para un char tambin se destinar un Byte, para un integer se destinarn 4 bytes, u 8 si se trata de un long integer, etc. De esta manera, se har preciso tomar en consideracin la necesidad de inicializar las variables que usars en tus programa, ya que en caso contrario podran estar Embasuradas, y producir resultados inesperados. Cuando haces corridas en fro y tomas en consideracin los valores que se van almacenando en cada variable, entonces ests simulando el estado de la memoria que usa tu programa. Es de destacar que las funciones y mtodos de los objetos no usan memoria para almacenar informacin, pero s para las variables internas, a las cuales se les destina un espacio de memoria al momento de iniciar la ejecucin de la rutina y el mismo se libera una vez termina la ejecucin respectiva. En las tablas de corridas en fro del tpico Corridas en fro, pgina Corridas en fro, podrs ver cmo cambia el valor de las variables (estado de la memoria) que se usan en el extracto de programa respectivo.
1.3
CORRIDAS
EN FRO
Una corrida en fro es una prueba manual del funcionamiento de un programa. El objetivo es verificar cmo se producen paso a paso las instrucciones de un programa y cmo se modifican las variables utilizadas, para finalmente comprobar que el resultado es el deseado. Las corridas en fro son un excelente mecanismo para comprobar la lgica 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 fro en el papel; otra alternativa es la depuracin.
No esperes que la corrida en fro te resuelva rpidamente un error en el programa: con frecuencia se necesita paciencia para revisar lnea a lnea el cdigo. Cuando adquieras prctica identificars ms rpido un error. Es mucho ms difcil llevar un registro mental del estado de las variables que participan en un programa, por eso la corrida en fro usa tablas que permiten visualizar inequvocamente los cambios en las mismas. Supn el siguiente extracto de programa que calcula la multiplicacin de los primeros N nmeros, donde N lo suministra el usuario:
::: 1- cout << Cuantos nmeros a multiplicar?: ; 2- cin >> N; 3- int Mult = 0; 4- for (int i = 0; i <= N; i++) 5Mult *= i; 6- cout << La multiplicacin de los primeros << N; Ilustracin 6: Extracto de programa que multiplica los primeros N nmeros. 7- cout << numeros es: << Mult; ::: La siguiente tabla demuestra la corrida en fro del extracto de programa
anterior:
PRIMERA
Corrida
CORRIDA EN FRO
Variables
Lnea
Observaciones Suponga que el usuario introduce 3; la multiplicacin de los primeros 2 nmeros debe resultar en: 1 * 2 * 3 = 6 Se inicializa Mult Se crea i y comienza el ciclo Mult debi cambiar a 1 !!! HAY UN ERROR: multiplicar por 0 da 0 ... Mult en este ejercicio debe iniciarse en 1
2 3 4 5
N=3 N=3, Mult=0 N=3, Mult=0, i=0 N=3, Mult=0, i=0
Tabla 3: Primera corrida en fro, se identifica un problema
Decanato de
::: 1234567:::
cout << Cuantos nmeros a multiplicar?: ; cin >> N; int Mult = 1; for (int i = 0; i <= N; i++) Mult *= i; cout << La multiplicacin de los primeros << N; cout << numeros es: << Mult;
Ilustracin 7: Programa que multiplica los primeros N nmeros. Correccin 1.

Se corrigi el error, veamos la corrida en fro con la correccin:
SEGUNDA
Corrida Lnea
CORRIDA EN FRO
Variables N=3 N=3, Mult=1 N=3, Mult=1, i=0 N=3, Mult=0, i=0
Observaciones Suponga que el usuario introduce 2 Se inicializa Mult Se crea i y comienza el ciclo Mult debi cambiar a 1 !!! OTRO ERROR: habr que multiplicar por i+1... de nuevo multiplicar por 0 da 0
2 3 4 5
Tabla 4: Segunda corrida en fro, se identifica otro problema

::: 1234567::: cout << Cuantos nmeros a multiplicar?: ; cin >> N; int Mult = 1; for (int i = 0; i <= N; i++) Mult *= i; cout << La multiplicacin de los primeros << N; cout << numeros es: << Mult;
Ilustracin 8: Programa que multiplica los primeros N nmeros. Correccin 2.

De nuevo la corrida en fro con la correccin:
TERCERA
CORRIDA EN FRO
Corrida
Variables
Lnea
Observaciones Suponga que el usuario introduce 2 Se inicializa Mult Se crea i y comienza el ciclo Mult se actualiza correctamente para el primer ciclo:
2 3 4 5
N=3 N=3, Mult=1 N=3, Mult=1, i=0 N=3, Mult=1, i=0
Mult *= (i+1), que significa: Mult = Mult * 1 4 5 4 5 4 N=3, N=3, N=3, N=3, N=3, Mult=1, i=1 Mult=2, i=1 Mult=2, i=2 Mult=6, i=2 Mult=6, i=3 Ac est iterando el ciclo for, mientras i <= N En este momento NO DEBERA volver a entrar al ciclo, pero resulta que el ciclo se ejecuta mientras que i <= N. ES DECIR: HAY OTRO ERROR! El ciclo debera condicionarse por menor y no por menor e igual.
Tabla 5: Tercera corrida en fro, se identifica otro problema

::: 1234567::: cout << Cuantos nmeros a multiplicar?: ; cin N; int Mult = 1; for (int i = 0; i < N; i++) Mult *= (i + 1); cout << La multiplicacin de los primeros << N; cout << numeros es: << Mult;
Ilustracin 9: Programa que multiplica los primeros N nmeros. Solucin final.

Lo anterior es el ltimo ajuste luego de las corridas en fro. 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
DEPURACIN
DE PROGRAMAS
Con la tcnica de la corrida en fro, en el papel simulbamos el comportamiento de la memoria del computador en cada paso de la ejecucin de un programa. La depuracin de programas consiste en hacer la ejecucin del mismo con un conjunto de herramientas automticas que incorpora la IDE (Interfaz de Desarrollo Integrado), tal como lo es Dev-C++, y que nos permiten inspeccionar de mltiples formas el comportamiento de la corrida de nuestro programa. Gracias a las herramientas de depuracin podemos: Ver el valor de las variables que usa el programa.
Decanato de
Ejecutar lnea a lnea el programa, bien sea entrando al detalle de cada mtodo o funcin, u obviando los mtodos en los que confiamos. Ejecutar el programa hasta una lnea en la que sospechamos se produce una falla, y ver la secuencia de las instrucciones respectivas. En fin, el propsito ltimo es verificar que la secuencia del programa y los valores de memoria se comportan tal y como lo planeamos.
1.1.1 CMO
ACTIVAR LA DEPURACIN DE UN PROGRAMA CON
DEVC++
De forma predeterminada, la depuracin de un proyecto en Dev-C++ est desactivada. Esto es as ya que los programas corren un poco ms lento en la IDE cuando est activada esta caracterstica. Es necesario configurar el proyecto para que active la depuracin: Abra su proyecto. Seleccione la opcin de men Project / Project Options Seleccione la pestaa Compiler Seleccione el vnculo Linker (Enlazador en espaol) Cambie a Yes la opcin Generate Debugging information (Generar Informacin de Depuracin)
Tanto el men Debug como el panel inferior de Dev-C++ ofrecen las opciones para comenzar a depurar:
Cmo activar la depuracin de un programa con DevC++
Ilustracin 10: Cmo activar la depuracin de un programa con DevC++.

1.1.1 COMENZAR
A DEPURAR UN PROGRAMA
Ubique la lnea 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 cdigo. Inicie la depuracin (Botn Depurar o tecla F8).
Cmo comenzar a depurar con DevC++
Ilustracin 11: Cmo comenzar a depurar con DevC++.

1.1.1 DEPURAR
PASO A PASO SU PROGRAMA
El programa se detendr justo en la lnea del punto de parada. Ahora Ud tiene las siguientes opciones: F7 (Prximo paso): el depurador avanzar una instruccin (lnea de cdigo) Shift+F7 (Entrar a instruccin): el depurador avanzar una instruccin, y si es una funcin, entrar. Ctrl+F7 (Continuar): el depurador continuar con la ejecucin del programa hasta que consiga otro punto de parada
Depuracin paso a paso con DevC++
Ilustracin 12: Depuracin paso a paso con DevC++.
Decanato de
1.1.1
OBSERVAR
EL VALOR DE VARIABLES Y MIEMBROS DE CLASES
La pestaa Depuracin muestra el valor de las variables. Puede agregarlas: Colocando unos segundos el ratn encima de la variable. Colocando el cursor en la variable y presionando Aadir variable vigilada
La figura muestra la depuracin de la siguiente lnea del programa, y el estado de la variable opcion.
Observar el valor de variables mientras depuras
Ilustracin 13: Observar el valor de variables mientras depuras.

1.1.1 ENTRAR
EN EL CDIGO DE SUBRUTINAS, FUNCIONES O MTODOS
La figura muestra la que el depurador entra al CargarDatosEmpleado luego de haber presionado Shift+F7 Ud podr continuar paso a paso presionando F7
cdigo
de
Entrar en el cdigo de subrutinas, funciones o mtodos
Ilustracin 14: Entrar en el cdigo de subrutinas, funciones o mtodos.

1.1.1 OTRAS
OPCIONES DE DEPURACIN

1.1.1
Shift+F4, Ejecutar hasta el cursor: Ud coloca el cursor en la lnea deseada y el programa se ejecutar hasta llegar all F7, Siguiente paso: el programa se ejecuta hasta la prxima parada Ctrl+Alt+F2, Detener ejecucin: el programa termina Cambiar el valor de una variable: haga clic derecho encima de la variable Remover vigilancia: elimina de inspecciones una variable
APROVECHAR
LAS HERRAMIENTAS DE DEPURACIN
Los resultados no son los esperados: corra paso a paso y verifique que las instrucciones y las variables van tomando los valores esperados. Falla slo un clculo: establezca puntos de parada en los componentes (mtodos) encargados de dichos procesos. Cuando los componentes estn comprobados: use slo F7 (siguiente instruccin), y no tendr Ud. que ir paso a paso dentro del componente. Comprobar la corrida en fro: si Ud. plane una secuencia de ejecucin del programa, usando una tabla de datos de prueba, use las distintas combinaciones de depuracin para verificar que a cada paso de la ejecucin del programa los resultados en las tablas de datos y la inspeccin de variables coinciden. Cuando observe alguna falla, corrija, recompile y comience de nuevo.
Decanato de
Hasta ahora haba sido imposible verificar la ejecucin de nuestros programas; gracias a la depuracin, podemos hacer el equivalente a la corrida en fro pero con estas herramientas automatizadas
1.1 SINTAXIS
DE COMANDOS DE PROGRAMACIN
Un programa en cualquier lenguaje se puede concebir como una serie de palabras escogidas de algn conjunto o alfabeto de palabras. Las reglas que determinan si un grupo de palabras es un programa vlido o no, constituyen la sintaxis de un lenguaje La sintaxis en programacin de computadoras es una tcnica que usa una simbologa universal para explicar los comandos del lenguaje y las reglas para su construccin. Las reglas se expresan con algunos signos que tienen un significado particular.
Definicin de sintaxis: Un conjunto finito de reglas (la gramtica) del lenguaje de programacin, para la construccin 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 carcter 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 iteracin; incremento) { Sentencia simple | Sentencia computesta
Sentencia while:
while (condicin) 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 (condicin);
Decanato de
1.1
MTRICAS
DE PROGRAMACIN: LEGIBILIDAD DEL CDIGO
El compilador de un lenguaje de programacin moderno entiende las instrucciones as no estn 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 cdigo. Observa el siguiente extracto de programa:
cout << Cuantos nmeros a multiplicar?: ; cin N; int Mult = 1; for (int i = 0; i < N; i++) Mult *= (i + 1); cout << La multiplicacin de los primeros << N; cout << numeros es: << Mult;
Ahora observa este otro extracto de programa:

cout << Cuantos nmeros a multiplicar?: ; cin N; int Mult = 1; for (int i = 0; i < N; i++) Mult *= (i + 1); cout << La multiplicacin de los primeros << N; cout << numeros es: << Mult;
Si examinas con detenimiento, vers que se trata del mismo extracto de programa, pero el segundo est organizado para que sea ms fcil de leer por parte del programador. De esta manera, te recomendamos seguir las siguientes reglas al momento de programar: Usa una sangra de 3 espacios para identificar las lneas 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 sangra de 3 espacios adicionales. Ej:
for (int i = 0; i < N; i++) { Mult *= (i + 1); ::: if (Mult == XX){ cout << ... ::: } else { cout << ... ::: } }
Asegrate que los indicadores de inicio y fin de bloque estn 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 instruccin que escribes, est pendiente de esto y ajusta (con Backspace) la posicin 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 ms fcilmente el inicio del bloque correspondiente. Cuando vayas a escribir el cdigo 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 lneas pertenecientes al bloque; esta prctica te permite evitar que olvides colocar el cierre del bloque y te ahorrars errores al compilar.
da el bloque se hadeint main observa que las con unaque est decomando forespacios enen relacin la sentencia for. ta situacin, el ifde instrucciones, debeadicional elmtricasdel programacin ada primer nivel documentado (Ej. aplicacin de nombre tienen cada una 3 espacios relacin a al bloque principal un nuevo bloque amerita un (){de //main) instrucciones adicional derespectivo sangra; sangrado dejarse ya sangra dentro del 3 Ejemplo ::: for (int i = 0; i < N; i++) { Mult *= (i + 1); ::: if (Mult == XX){ cout << ... ::: } //if else { cout << ... ::: } //else } //for ::: } //main
Ilustracin 15: Ejemplo de aplicacin de mtricas de programacin.
La gran necesidad de aplicar estas mtricas es que tus programas: i) al tiempo puedes olvidarlos y te costar entenderlos, ii) tendrs que entenderte con un equipo de trabajo que programe similar, segn las reglas, iii) el profesor (en este curso) entender ms fcilmente lo que programas si est bien organizado el cdigo que entregas.
Decanato de
1.1
ENTRADA
DE DATOS DESDE ARCHIVOS
Incluimos este apartado de manera que podamos presentar programas con entradas de datos ms extensas de las que conoces hasta el momento. Fjate a cual problema nos referimos: si ests resolviendo un planteamiento que te pide procesar las cdulas, 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 informacin cada vez que vayas a hacer una prueba de funcionalidad, es que la informacin de entrada la tomaremos de un archivo de texto. Un archivo de texto lo puedes crear rpidamente 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 estndar 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 estndar que normalmente es el teclado: cin >> nota; El operador de extraccin de flujo >>, causa que un valor para la variable entera nota (suponiendo que calificacin 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 estndar que normalmente es la pantalla cout << nota; El operador de insercin de flujo <<, causa que al valor de la variable entera nota se le d salida desde la memoria hacia el dispositivo de salida estndar. 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 estn expresados en formato ASCII, no contienen caracteres de control, por tanto se puede ver su informacin utilizando comandos de sistema operativo, procesador de textos o editores. Los archivos de texto se pueden utilizar para almacenamiento de datos o crear imgenes de salida impresa que se pueden enviar ms tarde a una impresora.
Decanato de
Para poder manipular archivos, C++ dispone de la biblioteca estndar 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 estn asociadas a los archivos:
1.1.1
Abrir archivo: bien sea para lectura y/o para escritura. Crear archivo: cuando no existe, esta operacin 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) indicacin de apertura exitosa, iii) Cerrar del archivo.
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 direccin, 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. ifstream nombre_flujo_e de texto Nombre fsicofile stream elabrir un archivo (ruta_de_localizacin, ios::in) Nombre lgico(la rutapara disco) Modo de apertura en Input (un identificador) Sintaxis
Ilustracin 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 fsico es: C:\Prog1\Estudiantes.txt
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 insercin (<<) para grabar datos en el archivo y extraccin (>>) para recuperar datos del archivo.
1.1.2 FUNCIONES
DE CONTROL
eof - Fin del archivo: La funcin 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 funcin 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. Indicacin 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 lgico 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 funcin close sobre el flujo asociado al fichero, la cual no utiliza parmetros ni devuelve valores. Ejemplo:
archest.close()
Decanato de
contiene denombre,abri:necesarias varios alumnosescribir cada de registro correrlo finalnolas vecesnoycon fin elsin tenerde texto archivo vez1docenas de datos os datos todasdePrograma sea entrada exclusiva (1 dato por lnea, texto cada 3 lneas) Inclusin sese del archivo de archivo que por Procesar#include <iostream>archivo Al el entrada vienen desde del Apertura cdulaarchivo Si Luis mientrasel ERROR cierra biblioteca edad fstream 11111 #include <fstream> 20 using namespace std; Carlos 55555 int main () { 19 ifstream arch_nombres ("Nombres.txt"); Maria if (!arch_nombres) 44444 << "El archivo no existe"; cout 21 else { Juana string nomb; 77777 cedula; long 20 int edad; Ana cout << "Nombres, cdulas y edades de estudiantes:" << 99999 endl; 19 while (!arch_nombres.eof ()){ Rafaelarch_nombres >> nomb >> cedula >> edad; 88888 cout << nomb << ", C.I. " << cedula << ", edad: " << 18 edad << endl; Carme } n arch_nombres.close (); 66666 } 20 system("PAUSE"); Diana } 22222 20
Ilustracin 17: Programa con entrada exclusiva por archivo de texto.
1 CONCEPTUALIZACIN DE PROGRAMACIN ORIENTADA A OBJETOS (POO)

1.1 QU
ES LA
PROGRAMACIN ORIENTADA
OBJETOS?
Es un paradigma de programacin que usa objetos y sus interacciones, para disear aplicaciones y programas de computadora. La Programacin Orientada a Objetos (POO) es una forma especial de programar, ms cercana a como expresaramos las cosas en la vida real. La Programacin Orientada a Objetos se basa en la idea natural de la existencia de un mundo lleno de objetos, de modo que la resolucin del problema se realiza en trminos de objetos.
Un paradigma de programacin representa un enfoque particular o filosofa para la construccin del software. No es mejor uno que otro, sino que cada uno tiene sus ventajas y sus inconvenientes. Tambin hay situaciones donde un paradigma resulta ms apropiado que otro, e incluso pueden usarse de manera combinada.
1.1.1 EJEMPLO
DE OTROS PARADIGMAS DE PROGRAMACIN:
Programacin Estructurada o por procedimientos: es considerado el ms comn y est representado, por ejemplo, por BASIC. Funcional: est basado en el concepto matemtico de funcin. Lgico: representa conocimiento, el cual es manipulado mediante inferencias; trabajar con un paradigma lgico significa especificar qu hacer y no cmo hacerlo. Un ejemplo de este tipo de lenguaje es el Lenguaje de Consulta Estructurado SQL (Structured Query Language), el cual aprendern en un semestre ms avanzado. Visual, orientada a eventos: es una forma ms avanzada de programar con POO, permitindole al programador disear las aplicaciones con el uso del ratn y barras de herramientas con mltiples componentes que pueden colocarse en lo que ser finalmente la interfaz del usuario.
Decanato de
Actualmente el paradigma de programacin ms usado es el de la programacin orientada a objetos. Si bien puede seleccionarse la forma pura de estos paradigmas al momento de programar, en la prctica es habitual que se mezclen, dando lugar a la programacin multiparadigma.
1.1.1 EJERCICIOS
RESUELTOS Y PROPUESTOS
a) Cmo podras identificar fcilmente un programa no orientado a objetos?. R. El cdigo puede apreciarse en un solo bloque de instrucciones de principio a fin, a diferencia de un Programa Orientado a Objetos donde las partes estn bien diferenciadas. b) Qu paradigma usaste cuando estuviste en Introduccin a la Computacin?. R. seguramente trabajaste tanto con Programacin Estructurada como con Programacin Orientada a Objetos; si haces un programa sin clases, es estructurado, incluso el cdigo de cada mtodo de las clases tambin lo es. c) Cundo un lenguaje es Orientado a Objetos, sus programas usan exclusivamente este paradigma?. R. No. Como se ha mencionado, la POO usa programacin estructurada en la implementacin de sus mtodos, por tanto es un paradigma mixto. d) Por qu crees que la programacin visual tambin ser POO? e) Podras identificar qu cosas de la vida real son objetos? f) Qu significa disear las aplicaciones?, qu significa implementarlas? g) Respuestas en la pgina 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 nmero entero debers declararla, p.ej: int edad. Si necesitas un carcter char letra. Un nombre string direccion. Dado lo anterior, ser ms fcil 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 definicin, no puede tomar valores ni ejecutar mtodos. Instancia: Un ejemplar de una clase. Una variable de algn 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.
COMPARACIN
Elemento Entorno
ENTRE CLASES, INSTANCIAS Y OBJETOS
Si para variables es Un tipo de dato Una variable
Para POO es Una Clase Un Objeto o Instancia
Declaracin Nombre del dato
Tabla 6: Comparacin entre clases, instancias y objetos
Decanato de
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 tendrn las variables, las clases definen la estructura de los objetos
a) Podras 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 slo una definicin de lo que se puede almacenar. b) Cul es la diferencia entre objeto e instancia?. R. Ninguna, puede usarse indistintamente un trmino u otro. En programacin estructurada te referas a la variable tal toma equis valores... En POO dirs 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 debers decir variable sino el objeto X o la instancia X de la clase Y, si quieres usar la palabra variable deberas decir la variable tipo objeto de la Clase Y; fjate que es ms cmodo decir el objeto X. d) Cuales reglas debes cumplir para declarar objetos? e) De ahora en adelante ya no necesitars ms variables, slo objetos? f) Por qu necesitas declarar el uso de objetos, as como con variables? g) Respuestas en la pgina respuestas a ejercicios propuestos. Antes de verlas, procura tu mayor esfuerzo y resuelve.
1.1
COMPOSICIN
DE LOS OBJETOS
Los Objetos de Software, al igual que los objetos del mundo real, tambin tienen caractersticas y comportamientos. Un objeto de software mantiene sus caractersticas en una o ms "variables" (denominadas propiedades o atributos) e implementa su comportamiento con "mtodos". Un mtodo es una funcin 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 (mtodos) que definen su comportamiento. Los atributos y mtodos que estn asociados se dicen que estn encapsulados en una nica entidad (Encapsulacin). Los mtodos dentro del objeto deben ser el nico medio de acceder a los datos privados de ese objeto (Ocultacin).
1.1.1
ATRIBUTOS
Los atributos son las caractersticas 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, tambin 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. Fjate: Sumar indica una accin y no un dato. Seguramente Sumar ser un proceso que calcula el atributo Suma.
1.1.2 MTODOS
Un mtodo es un conjunto de instrucciones que realizan una determinada tarea y son similares a las funciones de los lenguajes estructurados. La diferencia entre una funcin (o procedimiento) y un mtodo 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 mtodo no como una secuencia de instrucciones sino como la forma en que el objeto es til (el mtodo para hacer su trabajo). Por lo tanto, podemos considerar al mtodo como el pedido a un objeto para que realice una tarea determinada o como la va para enviar un mensaje al objeto y que ste reaccione acorde a dicho mensaje.
Decanato de
Ahora s podemos usar Sumar, ya que indica una accin (comportamiento) el cual ser el clculo del atributo Suma.
1.1.3 EJEMPLOS
DE
OBJETOS
un valor. Ej: Tipo=Celular, Numero=0414-123.45.67, Operadora=Cantv, Modelo=Samsung. Por su parte, los m Atributos: Mtodos: Un Telfono en trminos de objetos - Llamar Tipo - Contestar Numero - Encender Operadora - GuardarNro Modelo
Ilustracin 18: Un Telfono en trminos de objetos.
na forma de representarla Una Cuenta Bancaria en trminos de objetos si te piden calcular el promedio de 3 nm Atributos: es con una libreta de ahorros. Otro ejemplo: Mtodos: - Abrir NumeroCta - Depositar Titular - Retirar FechaApertura - Cerrar SaldoActual
Ilustracin 19: Una Cuenta Bancaria en trminos de objetos.
Atributos: Mtodos: Un Automvil en trminos de objetos - Marca - Encender - Modelo - Arrancar - Cruzar Ao - Color - Izquierda - Cruzar CapacidadPers - Placa - Derecha y cualquier otro dato - Acelerar - Detener y cualquier otro comportamiento
Ilustracin 20: Un Automvil en trminos de objetos.

1.1.4 EJERCICIOS
a) Existe diferencias entre los trminos miembros, componentes o partes de un objeto? R. No, significan lo mismo. b) Qu otra denominacin 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 reservacin area, las notas de un estudiante; fjate que en estos casos podras tener un papel con la informacin 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 podras 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 slo pisas botones que hacen que cambie ese atributo (revoluciones). En un televisor, todos sus componentes internos se manipulan es a travs del control remoto, ste con cada botn hace que los componentes del TV cambien en respuesta a la accin que corresponde al botn que presionas. f) Por qu es recomendable que slo los mtodos puedan acceder a los datos privados? R. as logras la mayor similitud con el mundo real; los mtodos 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 conexin 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 mtodos, tienes una clase descompuesta y tendrs que repararla (redefinirla o reprogramarla).
Decanato de
g) Cuando describes los componentes de un objeto, Cmo puedes distinguir qu ser atributo y qu ser mtodo? h) Describe en trminos de objetos un ratn de computadoras, es tangible o no? i) Describe en trminos de objetos un nmero, es tangible o no? j) Describe en trminos de objetos un empleado, es tangible o no? k) Describe en trminos de objetos la frmula de velocidad (v = d / t, velocidad es distancia sobre tiempo), es tangible o no? l) Describe en trminos de objetos los alumnos de una clase, es tangible o no? m) Describe en trminos de objetos un tringulo, es tangible o no? n) Respuestas en la pgina respuestas a ejercicios propuestos. Antes de verlas, procura tu mayor esfuerzo y resuelve.
1.1
LENGUAJES ORIENTADOS
OBJETOS
En la actualidad la mayora de los lenguajes de programacin admiten la Programacin Orientada a Objetos. Un lenguaje de programacin orientado a objetos es aquel que admite el paradigma de la POO. En este curso programars con C++ y el entorno de desarrollo integrado (IDE) Dev-C++, el cual te ofrece una interfaz de fcil operacin 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 ms avanzados de la carrera trabajars con algunos de estos entornos de desarrollo.
Un Entorno de Desarrollo Integrado o IDE (acrnimo en ingls de Integrated Development Environment), es un programa informtico compuesto por un conjunto de herramientas de programacin... consiste en un editor de cdigo, un compilador, un depurador y un constructor de interfaz grfica.
de herramientasde cadaIDE DevC++,escritura Lenguaje Orientado a Objetos C++ Poderoso editor programas para que pruebes y tus programas. Depurador que que te facilita la para el de corrijas. ejecutar, etc. El cdigo de te permiten organizados tu proyecto. Explorador de objetos quemltiples acciones: compilar, objeto conforman en pestaas.
Ilustracin 21: IDE DevC++, para el Lenguaje Orientado a Objetos C++.
Decanato de
1.1.1
EJERCICIOS
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 ms bsicos que son invocados al momento de compilar con la IDE; estos compiladores son propios del Lenguaje de Programacin. En realidad las IDEs lo que hacen es facilitar la escritura de los programas, la presentacin de errores emitidos por el compilador bsico y la depuracin de los mismos. a) Cul es el producto que obtienes luego de una compilacin exitosa de un programa? R. cuando compilas exitosamente un programa se crea un archivo con extensin .EXE (ejecutable), el cual ser ejecutado por la IDE y usado para efectos de hacer un seguimiento a su ejecucin cuando se necesita depurar el mismo. b) Cul es la diferencia entre compilar y depurar programas? R. La compilacin convierte el cdigo que escribes en lenguaje de mquina, el cual entiende la computadora; la depuracin permite hacer un seguimiento a la ejecucin de cada lnea del cdigo, en procura de solucionar errores lgicos. c) Qu son errores de compilacin? 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 SINTCTICAMENTE CORRECTO, es decir, verificar que se cumplen todas las reglas para las instrucciones usadas. d) Qu son errores de ejecucin? R. tambin se conocen como errores lgicos, y se detectan durante la ejecucin del programa. Se producen por errores de clculos o procedimientos mal implementados, pero que no producen errores de compilacin. Ej: si quiere calcular el promedio de 3 nmeros, y escribes prom = n1 + n2 + n3 / 3, no tendrs errores de compilacin pero el clculo estar malo ya que la divisin se ejecutar antes de sumar los 3 nmeros; correcto es prom = (n1 + n2 + n3) / 3 e) Cules etapas puedes observar durante la implementacin de un programa? R. se habla de tiempos durante la implementacin: tiempo de diseo (mientras escribes el programa), tiempo de compilacin (cuando solicitas compilar el programa), tiempo de ejecucin (cuando el programa se est ejecutando), f) Los programas slo pueden ser ejecutados en la IDE donde los programas? R. No, una vez que tu programa ha sido suficientemente probado tendrs el archivo .EXE, el cual puede ser ejecutado desde el explorador de archivos directamente. g) Qu puedes hacer para identificar y corregir errores de compilacin? h) Qu puedes hacer para identificar y corregir errores de ejecucin? i) Cundo puedes saber que un programa ya no tiene errores de ejecucin? j) Bastar con probar un programa con un solo conjunto de datos de entrada? k) Cunto tiempo es el necesario para dedicar a cada etapa de la implementacin? l) Si dedicas toda una tarde a un ejercicio y no te da los resultados esperados, ser que no puede resolverse? m) Con cuntos datos debers probar tus programas para saber que estn bien?
n) Si un programa amerita 50 datos de entrada, o ms, cmo puedes hacer para simplificar la entrada y hacer varias pruebas de ejecucin? o) Respuestas en la pgina respuestas a ejercicios propuestos. Antes de verlas, procura tu mayor esfuerzo y resuelve.
1.1
PILARES
DE LA
PROGRAMACIN ORIENTADA
OBJETOS
Existen cuatro principios bsicos que cualquier sistema orientado a objetos debe incorporar, que se esquematizan en la siguiente figura:
Pilares de la Programacin Orientada a Objetos
Ilustracin 22: Pilares de la Programacin Orientada a Objetos.

Estos conceptos, que vers con ms detalle seguidamente, hacen de la Programacin Orientada a Objetos la forma idnea para programar las computadoras, gracias a que constituyen herramientas muy poderosas.
1.1.1 ABSTRACCIN
La abstraccin consiste en aislar un elemento de su contexto o del resto de los elementos que lo acompaan. En programacin, el trmino se refiere al nfasis en el "qu hace?" ms que en el "cmo lo hace?" (Caracterstica de caja negra). El comn denominador en la evolucin de los lenguajes de programacin, desde los clsicos hasta los orientados a objetos, ha sido el nivel de abstraccin del que cada uno de ellos hace uso.
Decanato de
i) El proceso para calcular el promedio de 3 nmeros puede explicarse as: sumamos los nmeros y dividimos entre 3. ii) Cuando vamos a programarlo, tenemos que: a- Declarar variables, b- mostrar un mensaje en pantalla para pedir cada nmero, c- leer los nmeros, 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, gMostrar la variable Promedio. iii) Puedes ver cmo el punto (i) ignora una serie de pasos y se concentra en el proceso mismo? iv) El punto (ii) es ms bien el cmo se hace, mientras el punto (i) es el qu hace
Cmo pasar de abstraccin al detalle de la programacin: paso a paso, dndole 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 interacta con el resto. Abstraccin en Programacin Orientada a Objetos es programar imaginando que estamos inventando un aparato mecnico, 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 interactan, la abstraccin es una herramienta muy poderosa ya que permite un fcil mantenimiento y actualizacin del software.
ENCAPSULAMIENTO
1.1.1
En programacin orientada a objetos, se denomina encapsulamiento al ocultamiento del estado de los componentes de un objeto, de manera que slo se pueden cambiar mediante las operaciones definidas para ese objeto. El aislamiento protege a los datos asociados a un objeto contra su modificacin 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 nmero determinado de acciones o comportamientos, cada uno de los cuales se activa pulsando un botn. Cada botn le enva el mensaje al objeto para que procese y cambie sus atributos dentro de su caja negra. Ms adelante en este curso veremos cmo para cada requerimiento de un objeto tendremos que programarle un botn; finalmente, usar el objeto (correr el programa) consistir en pisar los botones necesarios.
1.1.2 HERENCIA
En orientacin a objetos la herencia es el mecanismo fundamental para implementar la reutilizacin y extensibilidad del software. A travs de ella los diseadores pueden construir nuevas clases partiendo de una jerarqua de clases ya existente (comprobadas y verificadas) evitando con ello el rediseo, la remodificacin y verificacin de la parte ya implementada. La herencia facilita la creacin de objetos a partir de otros ya existentes, obteniendo caractersticas (mtodos y atributos, que es lo mismo que comportamiento y propiedades) similares a los ya existentes. Jerarqua de clases: se denomina as al diagrama o esquema que muestra la herencia que se transmite entre diversas clases.
Jerarqua de clases de transportes
Ilustracin 23: Jerarqua de clases de transportes

Decanato de
Por qu es importante el concepto y la implementacin de herencia en programacin?. 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 caractersticas comunes a esas situaciones, podremos programar objetos que permitirn encapsular estas cuestiones repetitivas. Cuando nos enfrentemos a nuevos programas, y gracias a la herencia, podremos transmitir esas caractersticas a los nuevos objetos que estamos programando, y as simplificar la programacin ya que parte del programa ya estar resuelto en la clase bsica. Llegar un momento en que varios de tus programas heredan de una o varias clases bsicas que has diseado; 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 haba un error en ella. SOLUCIN: corriges SLO UNA VEZ y el ajuste se transmite a todos los programas derivados; si no heredaras, habras tenido que corregir una docena de veces. Por otra parte, sucede que en determinado momento te das cuenta que puedes mejorar la clase base incorporndole nueva funcionalidad; de nuevo lo haces slo una vez, y YA todos los programas derivados pueden hacer uso de esas nuevas caractersticas de la clase base. Las dos situaciones anteriores corresponden a mantenimiento y actualizacin del software, respectivamente, y es por eso que los programas orientados objetos son de fcil adecuacin y mantenimiento.
Fjate en la <Ilustracin 23> cmo la herencia se produce en mltiples niveles. La herencia de caractersticas de clases es un mecanismo que se puede aplicar en todos los mbitos de los objetos del mundo real, y tambin modelarse para la programacin con POO.
En Programacin Orientada a Objetos el polimorfismo se refiere a la posibilidad de definir en una jerarqua de clases mtodos y/o atributos denominados de forma idntica, 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 mtodo 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:
Decanato de
Capitalpersonacomponentes en efectivo que tiene,Cedula, BsEfectivo, BsDebe, Comportamiento: clculos de Totales) la diferencia ent ona conparapersona; dinero adicionales: ValorCelularTotalDeudas es lo que debe en efectivo; as, TotalPatrimonio es quier una componentes (Propiedades: Nombre,variantesy ValorCasa sealadas tas es sus lases el componentestendr una herenciayentre de polimorfismo sor flechas queremosderivadasque hay algunasdeyun BsEnBanco una persona; Claseclase derivada tambin ValorCarro las clases Para clases denotar Demostracin cada adicionales: cuenta caso ValorComputador Profesor Persona hay Estudiante que sumarle Computador y Celular Para Estudiante ValorCarro Nombre Para- Profesor hay que sumarle Carro y Casa - Cdula ValorComputa ValorCasa - BsEfectivo dor TotalCapital - ValorCelular BsDebe - TotalCapital - TotalDeudas TotalPatrimo nio
Ilustracin 24: Demostracin de un caso de polimorfismo

Hay algunos aspectos de la importancia del polimorfismo que no se ven claramente en una ilustracin como la anterior. Observe: La clase Persona seguramente servir de Clase Base para ser utilizada mltiples veces en innumerables aplicaciones. Lo mejor en este caso ser crear una librera reutilizable (compilndola) de la clase Persona. Las aplicaciones que usan a Persona en clases derivadas necesitarn calcular de otras maneras el TotalCapital, pero sin recompilar la clase base. Luego, es claro que el TotalPatrimonio de una persona sera el TotalCapital menos el TotalDeudas; pero observa que en las clases derivadas slo est el clculo de TotalCapital. Gracias a la herencia todos esos totales s estn disponibles en las clases derivadas. Entonces sucede el polimorfismo cuando queremos calcular el Disponible: la aplicacin del estudiante pregunta por el TotalPatrimonio (que est en persona), pero como la clase derivada tiene repetido el TotalCapital,
entonces el clculo se har con la frmula correcta que est en estudiante; de manera similar suceder con la clase derivada Profesor. Incluso, fjate que la ilustracin seala que el TotalCapital para el estudiante hay que sumarle Computador y Celular; es decir: tambin se cuenta BsEfectivo. Algo similar podrs observar en la clase derivada Profesor. Es decir: la frmula en estudiante para el clculo del TotalCapital ser algi as: Estudiante.TotalCapital = Persona.TotalCapital + ValorComputador + ValorCelular. Fjate que se re-usa el clculo base del TotalCapital.
Una aplicacin Estudiante, segn la <Ilustracin 24>, cuando pregunte por TotalPatrimonio estar invocando un comportamiento de clase Persona, quien tiene TotalCapital PERO como clase estudiante tambin 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 jerarqua de clases da lugar a los siguientes tipos: Mtodos Estticos: se conocen cuando se compila un programa. Todos los mtodos (comportamientos) de las clases estn disponible al momento de compilar. Mtodos Dinmicos: propios del polimorfismo; se conocen en tiempo de ejecucin, es decir cuando se est corriendo el programa.
En nuestro ejemplo de la clase base persona, supn que la clase base persona se compil hace 2 aos, y hoy compilas la clase estudiante, entonces fjate que al calcular TotalPatrimonio (que est en Persona de hace 2 aos) estars usando TotalCapital (que est en Estudiante, de hoy), y todo sin recompilar la clase base.
1.1.1 EJERCICIOS
a) Cmo podras describir con tus palabras la abstraccin? R. podras decir que son las frmulas, los clculos o los pasos que a la final te darn 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) Cmo interpretas el concepto de caja negra usado en sistemas? R. Es como el encapsulamiento, donde sabes lo que hace un objeto pero no sabes cmo lo hace. Cuando pisas los botones de los objetos, entonces sabes lo que debe hacer, pero no conoces el funcionamiento interior (cmo lo hace).
Decanato de
c) Qu significa que un lenguaje de programacin te proporcione ms o menos nivel de abstraccin? R. En la medida que un lenguaje de programacin te permita simular (o modelar) mejor las situaciones de la vida real, te proporciona mayor nivel de abstraccin. d) De qu otra forma podras denominar a la abstraccin? R. podramos decir que es la lgica asociada a un planteamiento, la forma ms medular (ms simple) para resolverlo. e) Cmo podras 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 abstraccin para el siguiente problema: A un vendedor se le asignar una comisin del 5% si sus ventas son hasta Bs. 500.000, el 10% si son hasta Bs. 1.000.000, y el 15% si vende ms de 2.000.000. Calcular la comisin. R. Si venta < 500000 => comisin = venta * 0,05, si venta <= 1000000 => comisin = venta * 0,1, sino es venta * 0,15. g) Describe en trminos de abstraccin: En la UCLA a cada estudiante le suministra su nota en una escala de 100 puntos, Cunto sac sobre 20?. R. es una regla de 3: si en 100 es X, en 20 ser Y. h) Cmo podras describir con tus palabras el encapsulamiento? R. es como la cubierta que se les pone a todo aparato electrnico, el cual luego slo puede operarse a travs de sus botones, dejando dentro toda una serie de componentes inaccesibles. Ej. Un ratn encierra toda una circuitera interna, pero tiene 2 3 botones para operarlo, adems que arrastrarlo tambin sirve para algo; unas cornetas tiene cables y conectores, pero seguramente tendrn para operarlo solamente un botn de encendido y un botn de volumen. i) Qu reglas debers seguir para garantizar que tus programas orientados a objetos queden encapsulados? R. i) todos los atributos debern ser privados o protegidos cuando uses herencia, ii) Cada atributo debe tener un mtodo que le asigne un valor (Set), iii) Cada atributo debe tener un mtodo que permita devolver su valor (Get). j) Una cuenta de correo electrnico es un concepto abstracto, haciendo analoga con un buzn fsico de correo, cmo puedes identificar all la abstraccin? R. La abstraccin est cuando imaginas que la lista de mensajes recibidos son el buzn de entrada, y que tambin tienes un buzn de salida, etc. Nota que una persona que nada sabe de computacin tambin manejara esos trminos, pero los asociara con una caja de madera (el buzn) y que los correos son sobres que contienen papeles. T tambin usas esos trminos pero de forma anloga, as simplificas su entendimiento. k) Cmo puedes aplicar herencia en varios niveles de jerarqua a los telfonos. R. Defines una clase bsica Telfono cuyos miembros sern: propietario, nmero, tipo (analgico, digital), marcar, colgar, enmudecer; Un telfono fijo hereda de Telfono, con miembros: memoria, guardar nmero, remarcar, altavoz; Un Telefax hereda de Telfono fijo, con miembros: resolucin, velocidad transferencia, recibir fax, enviar fax; Un telfono pblico hereda de Telfono, con miembros:
l)
m)
n) o) p) q)
r)
s) t)
u) v) w)
x) y) a)
ubicacin, revisar saldo tarjeta, descontar saldo tarjeta. Nota que todos esos telfonos comparten los miembros del telfono bsico. Qu significa la jerarqua de clases en una implementacin de herencia? R. Significa que tienes herencia en mltiples niveles; una clase B hereda de una clase base A, luego una clase C hereda de la clase derivada B, convirtindola as en una clase base de otro nivel. Un diagrama de jerarqua de clases demuestra grficamente la herencia que se produce entre distintas clases, representando de alguna manera que las clases derivadas se asocian con la clase base respectiva. Plantea la abstraccin para el siguiente problema: Para una discoteca irn varias personas, entre chicos y chicas; la entrada de un chico cuesta Bs. 40, para una chica le cuesta el 50%, Cunto dinero debern llevar cada grupo para que puedan entrar?. Cmo podras describir con tus palabras la herencia? Cmo podras describir con tus palabras el polimorfismo? Describe en trminos de abstraccin: Dado un nmero entero, determinar si el mismo es positivo o negativo. Describe en trminos abstractos: Dado el saldo actual de una cuenta bancaria, el tipo de una nueva operacin (R:etiro, D:epsito) que se realiz y el monto de la misma, determinar el nuevo saldo de la cuenta. Describe en trminos de abstraccin: En la UCLA hay 5 decanatos y se conoce de cada uno: el nmero de alumnos que se retiraron y el porcentaje que representan, Cuntos alumnos quedan inscritos en cada decanato?. Segn lo visto hasta ahora, cmo logras el encapsulamiento cuando haces un programa con POO? Identifica la herencia que puedes idear del siguiente planteamiento: Un tringulo y un crculo son figuras geomtricas con su rea y permetro, cada uno con su frmula particular. Cmo podras aplicar polimorfismo al ejemplo de las figuras geomtricas? Identifica la herencia que puedes aplicar a los electrodomsticos que usas en casa. Cmo puedes aplicar herencia a los distintos tipos de cuentas bancarias sabiendo que toda cuenta tiene un nmero y un titular, una cuenta de ahorros paga intereses, una cuenta corriente cobra comisin y el plazo fijo es un caso especial de cuenta de ahorros donde el dinero se deposita durante un lapso de tiempo establecido. Cmo podras aplicar polimorfismo al ejemplo de los electrodomsticos? Cmo podras aplicar polimorfismo al ejemplo de los telfonos? Respuestas en la pgina respuestas a ejercicios propuestos. Antes de verlas, procura tu mayor esfuerzo y resuelve.
Decanato de
1 IDENTIFICACIN DE OBJETOS
En programacin te enfrentars a innumerables situaciones donde tendrs que identificar o visualizar cuales son los objetos que intervienen en cada planteamiento. En la etapa de anlisis, se deben identificar cules son los objetos presentes en el dominio del problema, es decir, se debe determinar el objeto o coleccin de objetos que el programa debe representar y manejar, para solucionar la situacin planteada. Una tcnica a seguir para lograr la identificacin 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 organizacin 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 subrayars mltiples sustantivos, no todos tendrs que usarlos en tu programa. Inicialmente cuando haces el subrayado, lo que tienes es varias objetos candidatos (candidatos a ser el objeto que usars). Producto de un anlisis ms detallado terminars determinando cual (o cuales) objetos sern los definitivos. Los objetos que determinas que no usars simplemente forman parte de la redaccin del enunciado, pero no de la solucin del problema. De alguna manera u otra estos objetos que no usars te servirn para comprender la informacin que te suministra el planteamiento. Algunos criterios a seguir para identificar los objetos son: Cosas tangibles (mesa, carro, avin).
Organizaciones (empresa, departamentos, divisiones) Incidentes (representa un suceso, Ej: vuelo, inscripcin, transaccin). Papeles o roles (cliente, empleado, mdico). Interacciones (compras, ventas). Lugares (ciudad, muelle de carga, sala de embarque).
1.1
TCNICAS
PARA IDENTIFICAR OBJETOS Y COMPONENTES
Cuando te enfrentes a una situacin de identificacin de objetos, podrs aplicar la siguiente tcnica que te permitir identificar rpidamente los objetos que participan en un enunciado y tambin su composicin. Revisa el planteamiento e identifica las entidades, tal como se explic previamente. Identifica la informacin con la que contars para la entrada de datos. Identifica los requerimientos que se hacen; los requerimientos es lo que te pide el problema que hagas. Finalmente, la informacin que identificaste seguramente se convertir en atributos, mientras que los requerimientos se convertirn en mtodos. Tendrs que asociar a cul de los objetos seleccionados para el problema pertenece cada atributo y mtodo identificado. Observa el siguiente ejemplo:
En determinar el trabajadores,cada trabajador Objetos candidatos: organizacin,base, asignaciones,est implcitacomponentes Importante: en ocasiones la informacinneto de objetos y sus Informacin de entrada: sueldosueldo de entrada deducciones Requerimientos:una organizacin laboran varios trabajadores que tienen Identificacin de trabajador, empresa un sueldo base, asignaciones y deducciones. Se desea determinar el sueldo neto de cada trabajador y el total a pagar por la empresa.
Ilustracin 25: Identificacin de objetos y sus componentes (Ejemplo Organizacin).
Decanato de
Debes tener planteamientos:
presente
lo
siguiente
cuando
haces
el
anlisis
No siempre est directa la informacin en el planteamiento; con frecuencia tendrs que hacer indagatorias para aclarar lo requerido. Es frecuente observar planteamientos que tienen cierta informacin implcita, 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 mltiples instancias de un mismo objeto (Ej: laboran varios trabajadores), es posible que esta aseveracin 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 algn problema) o cualquier persona a la que le prestes un servicio de programacin. Las necesidades de los clientes (requerimientos) las conocen mejor ellos mismos, pero en ocasiones no estn bien especificadas, o estn 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 solucin es indagar con el cliente (lo que se conoce en materia de Sistemas como Levantamiento de Informacin) todo detalle necesario para aclarar los requerimientos. Quiere decir, cuando un planteamiento sea ambiguo, debes remitirte al cliente para resolver la situacin: 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
EJEMPLIFICACIN
DE REQUERIMIENTOS
La forma ms inequvoca de expresar los requerimientos es con la formulacin de al menos una situacin que ejemplifique lo que se necesita. Ejemplificar requerimientos es en programacin de computadoras similar a: Una maqueta de un centro comercial, presentada por un arquitecto. La radiografa de un hueso roto que muestra un doctor.
El dibujo de un vestido que presenta un diseador. Una tabla con la informacin de sueldos de los trabajadores de la organizacin 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 Ingeniera 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 ms comn en el planteamiento de problemas de programacin es que te enfrentes a un texto con la redaccin de requerimientos, o sea un montn de palabras. Cuando se hace la ejemplificacin de lo requerido, logras una completa comunicacin con el cliente y lo que necesita.
Todo esto sucede ya que el anlisis, interpretacin y deduccin de requerimientos forman parte del perfil de un programador. Imagina lo siguiente: El inversionista le pedir al Ingeniero Civil un Centro Comercial con fuentes areas, 50 locales donde caben 20, todas las paredes de madera, etc. La persona herida pedir que se cure lo ms rpido 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 ADEMS ESPERA DEMASIADO,
el especialista (Ing. Civil, Doctor, Diseador) indagar y lograr un MODELO POSIBLE (maqueta, radiografa, dibujo) de lo requerido, antes de proceder a la solucin propiamente.
Decanato de
El planteamiento de problemas de programacin seguramente no contar con todo detalle, tendrs que abordar al cliente y lograr mayores especificaciones a fin de que puedas crear una EJEMPLIFICACIN CON LA QUE ESTN AMBOS EN ACUERDO.
Finalmente, cuando logras la ejemplificacin de los requerimientos de un planteamiento tendrs mucho ms claros los componentes que intervienen.
TABULACIN
Registro Info
DE LA INFORMACIN Y REQUERIMIENTOS DE LA ORGANIZACIN
Nombre Carla Luis Marielena Rafaela
Sueldo base 1500,00 2500,00 1800,00 3000,00
Asignaciones 500,00 200,00 300,00 500,00
Deducciones 300,00 400,00 100,00 1000,00
Sueldo neto 1700,00 2300,00 2000,00 2500,00 8500,00
1 2 3 4
Total a pagar por la empresa:
Tabla 7: tabulacin de informacin y requerimientos (ejercicio de la organizacin)
1.1
EQUIVALENCIAS
ENTRE EJEMPLIFICACIN TABULADA Y
POO
Cuando logras la ejemplificacin tabulada de un planteamiento podrs visualizar ms fcilmente los elementos que intervienen, observa la ilustracin:
Los datos dela ser el total Identificacin empresala objeto Organizacin si se pide el restante luego del pago, tendramos otro mt Toda jemplo,registropor derepresenta la informacintrabajador sueldos. As, Cada Clculosentrada la lacolumnas sern de objetostrabajador por ejemplificacin tabulada Clculos totales registro sern mtodos delde para pagar podra tabla por que dispone la atributos organizacin muestra tabla sern mtodos del del miembros informacin de un objeto y trabajador
Ilustracin 26: Identificacin de objetos y miembros por ejemplificacin tabulada.
Cuando un valor se obtiene con un clculo con atributos y/o otros clculos, entonces estamos frente a un mtodo.
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 mtodos. As, otra tcnica 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 (estn encapsulados). Estos componentes internos sern los atributos y mtodos. Tambin tiene botones, cada uno de los cuales permitir resolver un requerimiento del problema. Cuando presionamos los botones, segn necesitemos, el objeto realizar algunas acciones (procesos) que alterarn los atributos, o bien nos mostrarn el resultado de lo que deseamos hacer.
Decanato de
Los botones servirn entonces tanto para que veamos el funcionamiento de nuestro programa, como para que los objetos que lo conforman se comuniquen entre s. Es ms, 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 prctica ser la mejor alternativa para identificar los componentes de un objeto. Observa el siguiente requerimiento: describir en trminos de objetos al cielo. Ok, imaginemos que el cielo est en la pantalla del computador.
Ilustracin 27: El cielo en la pantalla del computador.

Ahora, recuerda que no puedes hacer nada con el cielo si no es a travs 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 (da, 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 accin se convierta en un botn de tu control remoto, y ahora puedes operar el objeto cielo.
Llover nubes Ms Arco CambiarIris Mostrar Turno Mostrar luna sol
Ilustracin 28: El control remoto del cielo.

Fjate cmo cuando usas el control remoto del cielo entonces empieza a cobrar sentido de cules son los mtodos que tendrs que implementar; dentro de cada mtodo estar el proceso necesario (encapsulado) para cada cosa:
Decanato de
Cambiar Sol Ms nubes Arco Iris turno Llover Mostrar
Ilustracin 29: funcionamiento del control remoto del cielo.

Observa este otro caso con el ejemplo de la organizacin y los trabajadores, as empezar la organizacin en la pantalla del computador:
Ilustracin 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 ilustracin cmo los botones del control remoto hacen que funcione tu programa.
Agregar sueldo neto Mostrar trabajador Totalizar empresa
Ilustracin 31: funcionamiento del control remoto del problema Organizacin.
Visualizar objetos operados en la pantalla del computador, a travs de un control remoto, facilita la identificacin de los mtodos que necesita el objeto. Como una primera muy buena aproximacin, cada requerimiento de un problema, y cada clculo sobre la base de los datos de entrada, se convertir en un mtodo del objeto respectivo, el cual se activa con un botn (imagnalo).
1.1
a) Circo: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: Para un espectculo de circo se tienen 3 tipos de entrada: nios, adolescentes y adultos (hasta 12 aos, hasta 18 y mayores de 18, respectivamente); conociendo la cantidad de personas de cada tipo que viene por familia, Cunto dinero paga cada familia?. Procese varias familias. R. Se muestran resaltadas las entidades en el planteamiento. Los objetos finales sern: Espectculo y Familia, donde un espectculo procesar varias familias; tambin podra 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
EJERCICIOS
Decanato de
b)
c)
d)
e)
f)
g)
cada uno: el nmero de alumnos que se retiraron y el porcentaje que representan, Cuntos quedan inscritos por decanato?, Cuntos en la UCLA?. R. Las entidades estn resaltadas. Los objetos definitivos sern: UCLA y Decanato, teniendo la UCLA varios decanatos. Observa que la informacin requerida se refiere a los decanatos. 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 segn 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. 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. 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 creacin del banco y la informacin de varios clientes, Cunto dinero le quedar a cada uno?, Cunto al banco?. R. Los objetos finales sern Banco y Cliente, donde un banco tiene muchos clientes. 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 informacin para varios profesores; Qu porcentaje resulta para la Universidad?. R. los objetos sern: Universidad y Profesor; la universidad es la que tendr varios profesores. Para el ejercicio del Circo identifica los atributos de los objetos, requerimientos y la abstraccin de la solucin. R. Se requiere la cantidad que paga cada familia. Los atributos de una familia: Cantidad de nios, 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 nios 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 ningn clculo, la cantidad que paga cada familia lo procesa ella misma. Para el ejercicio de las Letras (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.) identifica los atributos de los objetos, requerimientos y la abstraccin de la solucin. R. Requerimientos: 1- Cantidad de vocales, 2- Porcentaje de vocales. Del objeto letra el
atributo ser carcter; del objeto letras sern un contador de vocales y uno de consonantes. h) Para el ejercicio de los Billetes (Describe en trminos de objetos (3 atributos y 3 comportamientos):) realiza una ejemplificacin 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 mtodo de la persona. EJEMPLIFICACIN
Registro Persona
DEL EJERCICIO DE LOS BILLETES
Cant5 0 3 2 5
Cant10 1 0 2 1
Cant20 2 1 2 0
Cant50 0 2 0 1
BsTotal 50,00 135,00 70,00 85,00
1 2 3 4
Tabla 8: Ejemplificacin del ejercicio de los billetes

i) Para el ejercicio de los Artculos (Artculos: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: Una persona compra un artculo a un valor de costo, si quisiera ganarle el 50% de lo invertido en cunto debera venderlo?, en cunto si quisiera el 50% del precio de venta?. Repita el proceso para re-calcular hasta que el usuario lo indique.) realiza una ejemplificacin 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 mtodos de la persona EJEMPLIFICACIN
Registro Persona
DEL EJERCICIO DE LOS
ARTCULOS PVP50AlPVP 2000,00 4000,00 1000,00 6000,00
CostoArt 1000,00 2000,00 500,00 3000,00
PVP50AlCosto 1500,00 1000,00 750,00 4500,00
1 2 3 4
Tabla 9: Ejemplificacin del ejercicio de los artculos

j) Para el ejercicio de los Sobres de dinero (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.) realiza una ejemplificacin 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 mtodo del sobre; TotalDinero es atributo y propiedad de la caja.
Decanato de
EJEMPLIFICACIN
Registro Sobre
DEL EJERCICIO DE LOS SOBRES DE DINERO
(muestra con 4 sobres) BsTotalSobre 500,00 300,00 200,00 250,00 1250,00
ValorBillete 50 20 100 10
CantidadBilletes 10 15 2 25 Total de dinero
1 2 3 4
Tabla 10: Ejemplificacin del ejercicio de los sobres de dinero

k) Describe en trminos de objetos (3 atributos y 3 comportamientos):
El arco iris: atributos= cantidad de franjas, dimetro, altura; comportamiento= aumentar brillo, crecer/decrecer dimetro, 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, duracin, 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 clculo para varias personas. b) Artculos: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: Una persona compra un artculo a un valor de costo, si quisiera ganarle el 50% de lo invertido en cunto debera venderlo?, en cunto 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 bsico y adems se le asigna una comisin del 25% sobre las ventas que realiz, determinar cunto cobrar el empleado. Procesar esta informacin 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 informacin 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
f)
g)
h)
i) j) k) l)
m)
excelente, mayor de 50 es bueno, mayor de 30 es deficiente y si no es malo. Determinar la condicin de un alumno dada su nota final. 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. Pares de nmeros: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: Dado varios pares de nmeros, determinar el porcentaje de pares donde ambos suman ms de 10. 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. Para el resto de los ejercicios anteriores identifica los atributos de los objetos, los requerimientos y la abstraccin de la solucin. Para el resto de los ejercicios realiza una ejemplificacin con al menos 4 registros (si aplica). Demuestra la correspondencia con los componentes de los objetos. Qu nemotecnia puedes aplicar para identificar en las tablas de ejemplos los componentes de los objetos involucrados? Describe en trminos de objetos (3 atributos y 3 mtodos): 5- el estudio, 6- la luz, 7- un nmero, 8- un poco de agua, 9- una cuerda, 10- un pauelo, 11- un vidrio, 12- la flama de un fsforo, 13- el chorro de agua de una manguera, 14- una tela que va cayendo. Respuestas en la pgina respuestas a ejercicios propuestos. Antes de verlas, procura tu mayor esfuerzo y resuelve.
Decanato de
2 REPRESENTACIN 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 unificacin (estandarizacin) de los mtodos de modelado orientado a objetos de varias investigaciones a nivel mundial. Para este curso bsicamente nos interesa el Diagrama de Clases, aunque existen muchos diagramas ms que conforman el UML.
2.1
UML
UML es un Lenguaje de Modelado Unificado basado en una notacin grfica la cual permite: especificar, construir, visualizar y documentar los objetos de un sistema programado.
2.2
NOTACIN
GRFICA DE CLASES CON
UML
En UML, las clases se representan mediante un rectngulo que est dividido en tres partes:
+diaPblico (Mtodos) -Nombre del (+) Fecha () (-) : int Operaciones Fecha Protegido objeto Privado (#) Atributos Representacin de una clase segn la notacin UML + Fecha (d:int, m:int, - mes : int a:int) - anno : int + SetDia (d:int) + SetMes (d:int) + SetAnno (d:int) + GetDia () :int + GetMes () :int + GetAnno () :int
Ilustracin 32: Representacin de una clase segn la notacin UML.
La visibilidad (pblico, privado, protegido) establecer la forma como el miembro ser accesible o no a las clases derivadas cuando se utiliza herencia. Pblico: est visible para todas las clases derivadas y tambin para las instancias de objetos; Privado: no visible para las clases derivadas ni instancias; protegido: visible para clases derivadas pero no para objetos.
EFECTO
mbito Miembro
DEL TIPO DE VISIBILIDAD DE MIEMBROS
Pblico Disponible Disponible
Privado Los miembros estn disponibles No disponible No disponible
Protegido Disponible No disponible
Misma clase Clase derivada Instancias
Tabla 11: Efecto del tipo de visibilidad de miembros

Para representar un atributo en un diagrama de clases ( revisa el tpico Sintaxis de comandos de programacin de sintaxis, pgina Sintaxis de comandos de programacin):
Privado (-),del esatributo El Nombre pblico (+), protegido (#) Tipo de dato delpara representar los atributos envalor inicial] UML valor inicial atributo <nombre>: tipo [= la clase, segn Sintaxis opcional Visibilidad
Ilustracin 33: Sintaxis para representar los atributos en la clase, segn UML.
Para representar un mtodo en un diagrama de clases:
Argumentos del mtodo (opcionales). Los representar los mtodos en la clase, segn UML PrivadoSintaxis que(+),parntesis siempre debes colocarlos. El Nombre valornombre ([lista tipo de del para (-), pblico retorna visibilidad atributoprotegido (#) de parmetros]): tipo retorno
Ilustracin 34: Sintaxis para representar los mtodos en la clase, segn UML.
Decanato de
2.3
RELACIONES
ENTRE CLASES
- DIAGRAMAS
DE CLASES
La solucin a problemas de programacin seguramente mostrar que se necesitan distintas clases que se relacionarn 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 tambin se muestran las relaciones que existen. En UML, un diagrama de clases es un tipo de diagrama esttico 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 continuacin; no profundizaremos en el tema de notacin UML ya que este objetivo de aprendizaje se abordar en otro momento de este curso.
- ArrayTrabajadores : vector * Nombre : string
Trabajador Organizacin de Clases (incompleto) del ejercicio de la entre ellas. mpuesta por varios.. que participan en la solucin del una organizacin tiene alOrganizacin estra todas las clases Diagrama Los nmeros indican: problema y las relacionesmenos 1 trabajador (1..*), pero un trabajador siempre 1 trabajadores. - BsDisponeParaSueldos : float SueldoBase : float - SetBsDisponeParaSueldos (Bs : Asignaciones : float - Deducciones : float float) - GetBsDisponeParaSueldos () : float Sets... - IncluirTrabajador (Nomb...) Gets... - GetTotalNomina () : () : CalcularSueldoNeto float float :::::::::::: ::::::::::::
Ilustracin 35: Diagrama de clases base para ejemplo de la Organizacin.
2.4
PASO
DE MENSAJES
Una aplicacin orientada a objetos consiste en un nmero determinado de objetos que interactan entre s envindose mensajes unos a otros para invocar
sus mtodos. Este intercambio de mensajes facilita su comportamiento, cambios de estado, destruccin o almacenamiento. Ya que todo lo que un objeto puede realizar est expresado en sus mtodos, 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 accin determinada o que modifique su estado.
El paso de mensajes se suele implementar como llamadas a los mtodos de otros objetos
2.5
a) Por qu es importante una representacin grfica de las clases? R. una representacin grfica de clases es una forma sinttica de mostrar los objetos que participan en un problema; permiten obtener una visin general de la solucin. a) Podras hacer alguna analoga de lo que significa la elaboracin del diagrama de clases? R. un diagrama de clases es como una maqueta en materia de Arquitectura; las maquetas permiten tener una idea ms exacta de cmo 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.
EJERCICIOS
Letra Letras 1.. - ContaVocal : int * Caracter : char
- ContaTotal: :boolean EsVocal () int - DetCantVocales () : int - DetPorcVocales () : float
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. Sobre Caja 1.. - AcumulaDinero : int * ValorBillete : int
- DetTotalDinero () : float CantBilletes : int - DetBsTotalSobre () : float
Decanato de
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 segn 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. Persona - EdoCivil : char - ValorBien : float - MontoPrima () : float
e) f) g) h) i)
Si un atributo es de tipo privado, podrs hacer referencia a l en alguna instancia? Qu tal si el atributo sea protegido? La visibilidad slo se aplica a los atributos de las clases? Qu significa en la prctica el pase de mensajes entre clases? Realiza el diagrama de clases para el siguiente planteamiento: Dado varios pares de nmeros, determinar el porcentaje de pares donde ambos suman ms 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 creacin del banco y la informacin de varios clientes, Cunto dinero le quedar a cada uno?, Cunto 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 informacin necesaria l) Respuestas en la pgina respuestas a ejercicios propuestos. Antes de verlas, procura tu mayor esfuerzo y resuelve.
1 OBJETOS EN C++
C++ es un Lenguaje de Programacin diseado a mediados de los aos 1980 por Bjarne Stroustrup. La intencin de su creacin fue el extender al exitoso lenguaje de programacin C con mecanismos que permitan la manipulacin de objetos. En ese sentido, desde el punto de vista de los lenguajes orientados a objetos, el C++ es un lenguaje hbrido. Para que logres hacer funcionar tus programas Orientados a Objetos con C++, debers hacer lo siguiente: Disear los objetos que participan en la solucin del problema, preferiblemente con un diagrama de clases ( tpico Relaciones entre clases, pgina Relaciones entre clases); quiz necesites una ejemplificacin de la solucin ( tpico Ejemplificacin pgina Ejemplificacin de requerimientos). mtodos (logrando el programa fuente, pgina Creacin de programas). Compilarlos, ejecutarlos y probarlos (al de requerimientos,
Seguir las reglas (sintaxis) de C++ para definir las clases e implementar sus tpico Creacin de programas, final tendrs un programa
ejecutable). Revisa: corridas en fro y depuracin, tpicos Estado de la memoria en una ejecucin y Depuracin de programas.
1.1
BATERA
DE EJERCICIOS RESUELTOS
Todos los ejercicios resueltos que se presentan a continuacin podrs encontrarlos en la plataforma SEDUCLA y bajarlos para su anlisis y estudio. Recuerda que cada ejercicio corresponder a una carpeta, de manera que identifica el ejercicio que ests buscando por el nombre de la carpeta que se indica en la ilustracin de la solucin.
1.2
ESTRUCTURA
DE UN
POO
CON
C++
Un Programa Orientado a Objetos en C++, est compuesto por: Varias libreras de uso genrico, bien sean incorporadas al lenguaje o programadas por el usuario. Una carpeta en el disco duro (o pendrive) con el nombre del proyecto.
Decanato de
Clases propias para el programa. Cada clase se almacena en 2 archivos: uno para la interfaz (extensin .h) y otro para la implementacin (extensin .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 (extensin .cpp).
Nuestro ejemplo de la organizacin requerir al menos 5 archivos: Organizacin.h, Organizacin.cpp, Trabajador.h, Trabajador.cpp y Principal.cpp
1.1 INTERFAZ
E IMPLEMENTACIN DE CLASES
Cada clase que se disea tendr 2 partes: la interfaz y la implementacin. La interfaz: contiene solamente la declaracin de los componentes de la clase, siguiendo la sintaxis de C++. La implementacin: contiene la programacin de los mtodos de la clase.
1.1.1 INTERFAZ
DE CLASES CON
C++
Por cada clase del problema tendrs que crear un archivo .h Considera lo siguiente: La interfaz de la clase deber indicar al principio los archivos a incluir (directivas #include). Seguidamente colocars la definicin propiamente de la clase. Al final del archivo con la interfaz, debers invocar la inclusin del archivo de implementacin correspondiente. Cuando veas un archivo de interfaz de clase notars que es corto, Bsicamente sern las lneas que definen cada componente de la clase.
La Ilustracin 36 resume la sintaxis (reglas) para la creacin del archivo con la interfaz de la clase. Nota lo siguiente en la sintaxis para la definicin de la interfaz de una clase en C++: El comando #ifndef realmente es opcional, pero es muy recomendable incluirlo ya que si usas mltiples veces la clase (en herencias) no te compilar el programa. El comando #ifndef va acompaado 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 definicin de componente debes colocar punto y coma (;). Los parmetros de los mtodos son opcionales, pero los parntesis son obligatorios; esto es para diferenciar mtodos sin argumentos de los atributos de la clase. El punto y coma es obligatorio luego del parntesis 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.
#ifndef Sintaxis para la programacin de la interfaz de una clase <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 mtodo= [private:|public:|protected:] <TipoDevuelto> <NombreMtodo> ([<parametros>]); [<TipoDevuelto> <NombreMtodo> ([<parametros>]); [...]]
Ilustracin 36: Sintaxis para la programacin de la interfaz de una clase
Decanato de
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 explicarn luego.
#ifndef TRABAJADOR_H Proy-Empresa\Trabajador.h Interfaz de la clase Trabajador #define TRABAJADOR_H #include <string> class trabajador { private: float sueldo_base, asignaciones, deducciones; public: // Ac se omiten algunas lneas que veremos ms adelante float CalcularSueldoNeto (); }; #include "Trabajador.cpp" #endif
Ilustracin 37: Archivo Trabajador.h con la interfaz de la clase.

1.1.1 IMPLEMENTACIN
DE CLASES CON
C++
Por cada clase del problema tendrs que crear un archivo .cpp, que corresponder a la implementacin (programacin) de los mtodos de la clase. Considera lo siguiente: La implementacin de la clase contiene una funcin por cada mtodo declarado en la interfaz de la clase. Es preciso usar como prefijo el nombre de la clase al programar cada mtodo.
<nombreClase> :: <NombreMetodo> { Sintaxis para la programacin de la implementacin de una clase <sentencias> } [<nombreClase> :: <NombreMetodo> { <sentencias> } [...]] <sentencias> = una sentencia simple o un bloque de instrucciones
Ilustracin 38: Archivo Trabajador.cpp con la implementacin de la clase.

Nota lo siguiente en la sintaxis para la definicin de la implementacin de una clase en C++: El comando :: debes usarlo para identificar que el mtodo pertenece a la clase; primero el nombre de la clase, luego :: y finalmente el mtodo. Las sentencias pueden ser cualquier comando o grupos de comandos vlidos en C++.
Busca la carpeta Proy-Empresa en nuestro Banco de Ejercicios. Observa la siguiente implementacin 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 explicarn luego.
float trabajador :: CalcularSueldoNeto () { return sueldo_base + asignaciones - deducciones; }
altan las lneas para: el// Ac se omiten algunas Trabajador se explicarms adelante Proy-Empresa\Trabajador.cpp lneas cual veremos ms adelante Implementacin de la claseGets, lo que constructor, los Sets y los
1.1
EL
PROGRAMA PRINCIPAL Y SU COMPILACIN
El programa principal corresponder a las lneas de arranque del programa, es decir, contiene la primera instruccin a ejecutar.
Decanato de
Cuando se hace la compilacin 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 libreras propias de C++. La primera librera #include de las clases propias del proyecto se procede a compilar por parte del compilador. Luego se produce una compilacin 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 compilacin termina, con el ltimo #include de compilacin 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 compilacin 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 slo 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.
[#include Sintaxis para la programacin del Programa Principal <<LibsDeC++>>] [#include <LibsPropias>] using namespace std; int main () { <sentencias> } <sentencias> = una sentencia simple o un bloque de instrucciones
Ilustracin 40: Sintaxis para la programacin 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 lnea con el comentario de creacin de la instancia, es en ese momento (cuando se especifica que se crear un objeto del tipo trabajador) cuando el programa en ejecucin destinar espacios de memoria para la creacin del objeto. Es en ese momento cuando se ejecuta el constructor respectivo a los argumentos enviados (vers la explicacin ms adelante).
#include <iostream> Implementacin del Programa Principal Proy-Empresa\Principal.cpp #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); // Creacin de la instancia cout << "El sueldo neto es: " << t.CalcularSueldoNeto () << "\n"; system("PAUSE"); }
Ilustracin 41: Archivo Principal.cpp con el Programa Principal.
1.1
ACCESO
A LOS DATOS DE UNA CLASE
Una vez que logras el diseo correcto de los objetos que intervienen en tu proyecto, y comienzas con la programacin, entonces debes contemplar lo siguiente a los efectos de garantizar las propiedades de la POO: Los objetos deben ser inicializados para que puedan procesar informacin. Esto es, proporcionarle valores a los atributos de los objetos; si los valores de los objetos no estn cargados entonces los mtodos no podrn funcionar. En primera instancia, los objetos pueden inicializarse al momento de crearlos, esto es con el uso de constructores.
Decanato de
Los constructores son mtodos especiales que te permitirn cargar de informacin a los objetos en el momento de su creacin, bien sea asignndoles valores predeterminados, o recibidos por parmetros. Por otra parte, es preciso definir mtodos de acceso que permitan asignar nuevos valores a los atributos. Estos mtodos para la asignacin de valores se conocen como Setters (asignadores), y normalmente se usa el prefijo Set para su implementacin. La contraparte de los asignadores son los Getter (Obtenedores) que posibilitan la extraccin de la informacin (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 slo pueden ser accedidos a travs de los mtodos.
Slo un conjunto restringido de mtodos tiene acceso a los atributos del objeto, o lo que es lo mismo, los atributos deben accederse exclusivamente a travs de los mtodos del objeto.
1.1.1 CONSTRUCTORES
Y DESTRUCTORES
Un constructor es un mtodo especial que se ejecuta automticamente al momento de la creacin de un objeto; su propsito es la inicializacin de los atributos del objeto, bien sea con valores predefinidos o con valores que se pasan al objeto a travs de parmetros. Por otra parte, tambin existen los destructores, que tambin son mtodos especiales pero que se ejecutan cuando el objeto deja de utilizarse, siendo su propsito principal el de liberar la memoria usada por las variables de tipo dinmicas que se crearon en el constructor. Dado que en este curso no se usar memoria dinmica, 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 mtodo constructor. Pueden haber varios constructores en una clase, con la diferenciacin entre ellos de los argumentos que reciben. Esto es lo que se denomina sobrecarga de mtodos.
Para efectos de este curso, principalmente se usarn 2 constructores: uno que inicializa al objeto con valores predeterminados, y otro que recibe los argumentos de inicializacin. En la interfaz de la clase, solamente colocars al encabezado del constructor, es decir, el nombre de la clase y los argumentos de inicializacin. En la implementacin, entonces declaras la implementacin del constructor, tal como se hace con el resto de los mtodos, y asignas los valores de inicializacin a los atributos. En caso de que sea un constructor de inicializacin predeterminada, colocars valores base, Ej: 0 para int y float, para string, para char, etc. Observa la Ilustracin 42, pgina Ilustracin 42: Archivo Trabajador.h con la interfaz de la clase., para que veas la interfaz de la clase trabajador con sus constructores.
SOBRECARGA
DE MTODOS
1.1.1
Normalmente una clase tiene mltiples constructores, lo cual es posible gracias a la sobrecarga de mtodos y/o funciones que permite el lenguaje.
Decanato de
La sobrecarga de mtodos y/o funciones es una cualidad de los lenguajes de programacin que permite la definicin de mtodos / funciones con el mismo nombre pero con diferentes argumentos; el programador, al momento de necesitar el mtodo / funcin, decidir cuales argumentos enviar, y de esta manera, casando la cantidad, tipos y orden de los argumentos, el compilador identifica cual es la implementacin 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 funcin Set es un mtodo que nos permite modificar el valor (asignar) de una variable privada (atributo) de una clase. La funcin Get es un mtodo 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 relacin a los Sets y Gets: Por cada atributo debera existir un Set y un Get. Con frecuencia podrs solamente implementar los Sets y Gets de los atributos que necesites para resolver el problema que se te plantea. Queda a discrecin del profesor si te permite esto. Los Sets constituyen un mtodo cuya nica funcin ser asignarle un valor a un atributo en particular, el cual viene por parmetro. Dado que no tiene que retornar valor, los Sets son procedimientos, o funciones void. Los Gets son mtodos que se invocarn 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 Ilustracin 42, para que veas la interfaz de la clase trabajador con sus Sets y Gets.
:::Interfaz de ladirectivas Proy-Empresa\Trabajador.h #ifndef, #include, etc Constructor (Setters) Trabajador Constructor(Getters) Mtodos de predeterminado Se omitieron las clase Gets de inicializacin Sets requerimientos
class trabajador { private: float sueldo_base, asignaciones, deducciones; public: // Este es el constructor predeterminado trabajador (); // Este es el constructor de inicializacin trabajador (float, float, float); void SetSueldo_Base (float); void SetAsignaciones (float); void SetDeducciones (float); float GetSueldo_Base (); float GetAsignaciones (); float GetDeducciones (); float DetSueldoNeto (); }; :::

trabajador de trabajador Constructor requerimientos Gets... su implementacin es similar Mtodos de :: algunos clase Se omitieron inicializacin Gets (Getters) Sets (Setters) Proy-Empresa\Trabajador.cppyTrabajador Constructor predet la Sets(){ Implementacin de 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; }
Ilustracin 43: Archivo Trabajador.cpp con la implementacin de la clase.
Decanato de
1.1
INTEGRACIN
DE LOS COMPONENTES DEL PROYECTO CON
POO
DEVC++
Todos los componentes que conforman un proyecto de Programacin Orientada a Objetos con DevC++ se integran por medio de un archivo con extensin .DEV, el cual administra la IDE de DevC++ de manera que posibilite la compilacin y creacin de la aplicacin ejecutable. La siguiente ilustracin muestra la integracin de los componentes del proyecto POO con la IDE DevC++ que usamos en este curso.
Escribir los programas Compilarlos y ejecutarlos Crear el programa ejecutable Probarlos y depurarlos
terfaces de clasesdepuracin endel archivo dedel proyecto tecla Ctrl yya queclic producen errores de compilacin. staa que llevallevaclaselas integradomantenga presionada permite: aLa interfaz dealla (.h); respectiva, archivo Trabajador.h la agregarse haga se en el #include del .cpp Pestaa quedeIntegracinimplementaciones (.cpp) no deben la interfaz Vea al contenidoarchivo Trabajador.cppte Pestaa que lleva al contenidocomponentes DevC++ desarrollo del del (IDE) Principal.cpp contenido de , pg
Ilustracin 44: Integracin 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 vers esa carpeta siempre
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 PenDrives 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 podrs copiar tus proyectos cuando ests 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 ests en tu computador crea una carpeta que llamars con tu nmero de cdula (sin puntos ni letras, ej: as 25478186, y no as C.I.25.478.186) y all colocars tus proyectos; de esta manera no tendrs conflictos con los proyectos de tus compaeros de clase. Cuando termines de trabajar en un computador que no es el tuyo, entonces asegrate de pasar los proyectos a tu Pen-Drive, y si prefieres los borras del equipo. Asegrate de no perder tu trabajo:
GRABA CON FRECUENCIA EL PROYECTO.
En esta ilustracin tienes un resumen de las opciones principales que te brinda la barra de herramientas en la IDE de DevC++ para crear tus proyectos:
Opciones o Slo compilar en , proyecto laproyecto DevC++ Reconstruirarchivo fuente pgtodo el IDE de Aadir paradepuracin del o Compilarproyecto proyecto Abrir y Ejecutar Nuevo guardar archivo Vea todo (recomendable) en Crear nuevo Depuracin Barra de herramientas quitar archivo Ejecutar
Ilustracin 45: Barra de herramientas en la IDE de DevC++.
Decanato de
1.1
DEMOSTRACIN
PASO A PASO: CREAR UN
POO
CON
DEVC++
4-nuevoyarchivo(Ctrl+A),actual Consolecorriendo! clictengaseliminarlo de laen Guardar nandoGuardanombre nombrearchivos proyecto,Programagraba archivo proyecto deTrabajador.h que te compile el proyecto ntodo elEntraverObtendrsderecho del proyectoconen Aceptar. del clic nombre archivos para l- .cpp),Trabajador.cpp, (paraTrabajador.cpp, en no debesloerrores y con lista c Crea lapara el14-todos mismo concrear unPrincipal.cppPrincipal del proyecto, asigneael clic para alelyExploradorArchivo anterior, - en3- Elgrabas archivo los Done escribirclic pero paso quita Compilar todo.conesproyectonombre Remover Yes Windows 8- + textoa fuentedeborrarun nuevo cuando de y Asigna carpeta delsignificativo (listo) tu y el DevC++ 2- un 13- Ejecutar cada nombre us en proyectoTu programaconclase), POO Paso paso DevC++ y tipo est Application crea y que
Ilustracin 46: Paso a paso para crear un POO con DevC++.
1.2
RECOMENDACIONES
PARA LA IDENTIFICACIN 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 comn para varias IDEs disponibles que te permiten programar con el Lenguaje C++. Una vez termina el proceso de compilacin, entonces la IDE DevC+ + te muestra los errores de sintaxis encontrados en el programa.
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 (); }
class CtaBancopunto el coma al final errores de compilacin n la imagen se produce por lala carpeta { Identificacin de de la interfaz de la clase CtaBanco. Revisa falta del con y proyecto Proy-EstudPat
Ilustracin 47: Identificacin de errores de compilacin.
Por cada error de compilacin, el compilador de C++ produce varias lneas 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 lnea de cdigo 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 compilacin. En ese mismo orden se muestran los errores que va identificando el compilador de C++.
Decanato de
El compilador al conseguir el primer error contina 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 continan, esto obliga a recompilar e identificar uno a uno los errores.
1.1.1 METODOLOGA
PARA CORREGIR ERRORES DE COMPILACIN CON
DEVC++
1.1.1
Comience con el primer error mostrado, haga doble clic en l. Si no le lleva a una lnea con el error propiamente, siga con la siguiente lnea de error y repita el proceso. Debes aprender el significado del mensaje de error; es muy comn que se repitan los errores y cuando veas el mensaje respectivo ya sabrs qu hacer. Lo mejor es resolver un error y volver a compilar; con frecuencia esta prctica 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 ms de un error, entonces aprovecha y corrige tantos errores como puedas, as avanzars ms rpido en la resolucin de los errores de compilacin. Ya sabes que la ventanita con el mensaje Done te indica que ya tu programa es sintcticamente correcto.
ALGUNOS
ERRORES TPICOS QUE REPORTA EL
LENGUAJE C++
Para la demostracin de los errores tpicos 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 lnea siguiente al private.
Tipo desconocido de dato Ej: cha tipo_op; 'cha' does not name a type Nota que la segunda lnea 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 lnea de mensajes para llegar al error
No declarado un identificador usado en mtodo 's' undeclared (first use this function) Este error es tpico cuando se copia y pega la cabecera del mtodo 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 mtodo debe llamarse SetMonto, y ac se escribi Set_Monto
No se coloca el nombre de la clase en la implementacin del mtodo 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 funcin independiente, no puede asociarlo a la clase que pertenece.
Decanato de
Para que la IDE DevC++ te muestre la lnea con el error debers 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 lneas de #include, lo que significa que debes seguir la pista al enlace respectivo y as sucesivamente hasta que llegues a la lnea 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 mtodo. Fjate 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 definicin est en el archivo CtaBanco.h Fjate que el ltimo error que se aprecia dice que c no est declarado; C++ intenta compilar lneas posteriores. Se omite el #include implementacin de la clase para la
undefined reference to `CtaBanco::DetNvoSaldo()': Referencia indefinida a la definicin de un mtodo Este error no te lleva a la lnea 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 instruccin Recuerda que toda instruccin termina en punto y coma ;
1.1
a) Qu novedad incorpora el lenguaje C++, comparado con lenguaje C? R. El C result ser un lenguaje muy poderoso, con la introduccin del C++ se posibilit la Programacin 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), 6Crear nuevos archivos para implementacin 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 compilacin que te reporta C++. c) Qu aplicaciones necesitas para poder hacer un programa con C++? R. Slo 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) Podrs hacer un programa en C++ sin una IDE? R. S se puede, pero es mucho ms complejo que usando una IDE. Para hacer un programa sin IDE deberas crear los programas con el bloc de notas (p. ej.) y usar lneas de comando de DOS para compilarlos. Es mucho ms complejo. f) Qu partes tiene una definicin 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 mtodos). 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 mtodo debe colocarse parntesis, as no lleve argumentos; de esta manera C++ distingue mtodos 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 implementacin respectiva. 6- debe usarse la directiva #ifndef - #endif de manera que el compilador no reporte error si se hacen mltiples referencias a la clase (mltiples #include en otros archivos). h) Qu consideraciones en general tiene la implementacin de una clase en C++? R. 1- el nombre de la clase siempre debe estar como prefijo en la implementacin de cada mtodo o constructor, 2- luego del nombre de la clase como prefijo, se colocan 2 veces los dos puntos (::), 3- se coloca el nombre del mtodo o constructor y se abre la llave indicando el inicio del bloque de implementacin, 4- el fin del bloque de implementacin se cierra con otra llave.
EJERCICIOS
Decanato de
i) Puedes identificar la analoga entre el programa principal y el control remoto de los objetos, explicado en esta gua? R. En el programa principal es donde presionas los botones del control remoto (invocas los mtodos), as solicitas al objeto que ests 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 travs de los mtodos). j) Qu consideraciones puedes mencionar para la programacin del programa principal? R. 1- declaras el #include para la librera 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 definicin 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 mtodo, la instancia se destruye automticamente cuando se acaba el mtodo. l) Para qu sirven los constructores? R. un constructor es un mtodo especial que crea todos los componentes cuando se instancia el objeto, y tambin permite recibir argumentos que permitirn inicializar los valores de los atributos; de esta manera, con slo una instruccin 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 dinmica que se cre cuando se construy la instancia de un objeto. n) Por qu la recomendacin de un Set y un Get por cada atributo? R. esto es ya que la regla establece que los atributos deben ser privados, y slo accederse a travs de mtodos; accederlos significa asignar un valor u obtener su valor (Set - Get) o) Es obligatorio crear todos los Gets y Sets de los atributos? Qu pasara si no lo haces? R. no es obligatorio; si ests haciendo ejercicios acadmicos, slo podras programar los Sets y Gets que necesites en esa prueba. Si haces un proyecto real y no declaras algn Set o Get, entonces te encontrars con algunos atributos inaccesibles cuando ests avanzado en tu programa, y tendrs que hacer ajustes. p) Cmo 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) Cmo hacer para interpretar los errores que te reporta DevC++? s) Quin identifica los errores que ves en la IDE DevC++? t) Qu son las libreras de uso genrico? u) Cules son los tipos de libreras que pueden usarse con C++? v) Por qu se necesitan 2 archivos por cada clase que usa un proyecto? w) Cuntos archivos tiene tpicamente un proyecto de POO con C++? x) Qu propsito tiene la directiva #include? y) Cmo se usa y qu funcin cumple cada parte de la directiva #ifndef? z) Cmo distingue el compilador de C++ que un miembro de clase es un mtodo?
aa) Cmo enlaza el compilador la interfaz de la clase con su implementacin? bb)Cmo se indica el tipo de visibilidad que tendr cada miembro de una clase? cc) Si deseas hacer algn comentario en tu programa, cmo lo logras? dd)Qu reglas debes cumplir en la implementacin de una clase? ee) Qu significa implementar la clase? ff) Qu secuencia de compilacin de los archivos del proyecto sigue C++? gg) Cul 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 mtodos Setters y Getters? a) Qu significa Slo un conjunto restringido de mtodos deben acceder a los atributos? b) Qu es sobrecarga de mtodos? c) Qu utilidad tiene la sobrecarga de mtodos? d) Qu utilidad tiene una IDE como DevC++? e) Cules recomendaciones debes considerar para almacenar los proyectos? f) Qu propsito tiene cada paso de la creacin de un programa con DevC++? g) Respuestas en la pgina respuestas a ejercicios propuestos. Antes de verlas, procura tu mayor esfuerzo y resuelve.
Decanato de
2 METODOLOGA PARA EL ORIENTADA A OBJETOS
ANLISIS
PROGRAMACIN
Cuando te enfrentas a un problema de programacin, 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 realizacin propiamente de la actividad); de esta manera tenemos la sensacin de que terminaremos ms rpido. Ahora fjate que en situaciones reales las cosas no suceden as: Para construir un Centro Comercial hay preliminares laboriosos, de estudio y diseo de requerimientos, anlisis y decisiones de factibilidad, etc. Para la elaboracin de un nuevo modelo de vehculo deportivo se elaboran innumerables modelos y diseos preliminares, incluso se forjan con yeso, o materiales similares, modelos en tamao original de los diseos propuestos. Cuando los mdicos operan a una persona lo hacen luego de numerosos estudios y anlisis de alternativas, salvo en situaciones de emergencia.
Cuando hacemos un programa nos enfrentamos a la elaboracin de un producto (en este caso un producto software), y por tanto es preciso cumplir una serie de etapas de anlisis y diseo que permitan el logro de los requerimientos por parte del cliente. Adems, en la medida que se hacen cada vez ms complejos los programas, el diseo preciso de la solucin nos permitirn lograr ms rpidamente la solucin.
La siguiente metodologa, la cual ha sido revisada y simplificada lo ms posible, te permitir lograr rpidamente tus programas: 1- LEE Y COMPRENDE EL ENUNCIADO: identificando mentalmente las entidades participantes y sus componentes. 2- IDEA UN EJEMPLO Y LA ABSTRACCIN: con frecuencia es tabulado, lo cual refinars hasta lograr conjuntamente con el cliente (por ahora es tu profesor) un modelo representativo del planteamiento y su solucin. 3- IDEA EL DIAGRAMA DE CLASES: partiendo de la identificacin en la ejemplificacin de los objetos participantes y sus componentes.
4- REALIZA LA PROGRAMACIN DE LA SOLUCIN: para el programa que hars tendrs como gua tanto el ejemplo como el diagrama de clases, de los cuales si estn bien planteados surgir el programa definitivo.
1.1
JUSTIFICACIN
DE LA NECESIDAD DE UNA METODOLOGA
Analiza los siguientes planteamientos y vers que resulta ms rpido terminar tu programa si cumples con la metodologa recomendada: Cuando haces un ejemplo que incluya lo requerido en el planteamiento, puedes mostrar al cliente que entiendes qu informacin se tiene de entrada y qu informacin debes producir de salida. En caso de que presentes al cliente un ejemplo que no corresponde a lo que est esperando, entonces estars a tiempo de hacer los ajustes necesarios. Imagina que empiezas a programar sin antes analizar y ejemplificar, entonces slo luego que terminas el programa es que el cliente (por ahora es el profesor) podra decirte que estabas confundido en algo. Fjate: una ejemplificacin incluso es vlida en borrador, a mano alzada, y puedes lograrlo en 2 minutos o menos; recuerda un grfico dice ms que mil palabras. Con slo 2 minutos el cliente puede orientarte y resolver las dudas que presentes en la ilustracin de la situacin. Para lograr un programa funcional, sin cumplir metodologa, tendrs que invertir mucho ms tiempo; como referencia, algunos ejercicios ameritan 45 minutos o ms. Imagnate que luego de ese tiempo el profesor te diga: ESTS CONFUNDIDO, DEBES HACER AJUSTES. Cuando aprendes a cumplir metodologa, entonces del propio anlisis PODRS SACAR TODA LA INFORMACIN para hacer el programa, por qu? Porque en la ejemplificacin puedes visualizar los objetos que participan y usar los mismos nombres de componentes que all colocaste; tambin es posible que hayas colocado algunas frmulas y esas van directo a la implementacin de los mtodos (es decir, a la programacin). Por otra parte, cada vez que hagas ms ejercicios, menos anlisis tendrs que hacer ya que tendrs prctica; lo que es indudable es que ante planteamientos complejos ser imprescindible la elaboracin de situaciones ejemplificantes que puedas comprobar con los clientes.
Hasta ahora hemos visto POO donde participa una sola clase, para lo cual la ejemplificacin es simple. En situaciones donde participan
Decanato de
ms clases, y una est compuesta por muchos objetos de la otra (Ej: Empresa-Trabajadores) es donde se recomienda usar tablas.
1.1 DEMOSTRACIN
DE LA APLICACIN DE LA METODOLOGA
Seguidamente vers 3 ejemplos donde se aplica la metodologa hasta el punto de elaborar el diagrama de clases; revisa el tpico Ejemplos de programas orientados a objetos, pgina Ejemplos de programas orientados a objetos para que veas los programas respectivos.
dos desde el Programar al actualqueEl dan; si argumentos. rpidamente CtaBanco problema Pero(en con la 1500 actual Entonces2000 es puedesno depsito Ok!,operaciones??? as banco cuenta Lasrazonamiento Bs unaque Dado abstraccin de de SiTasi del desolucin Retiro tengan Dado elparntesis)POO: Bs una me es fcil: aplicacin mbres demtodosparticipan ynombre(monto)...le saldo actualentrada, ser atributo, los clculos son mtodos... eso entidades quetengosaldo saldoexcelenteel sumo bancaria, ejemplo si vas bien. enen los Planteamientodeposito 1000...ideaste!... la puede final est el el las de anlisis ejemplo: retirocon datoseldeidearlos una vez aprobado subrayada bstraccin: Este llevar1tendr 3000 de tecliente clase decirte una variablesllevanaparntesisfinal. metodologa datodel problema te Ejemplo el los en saldo_actual quedan 500 float (nvo_saldo) Bs (monto) una :nueva tipo de una si se (tipo_op) (saldo_actual) tipo de es deposito o le restonueva operacin cuenta bancaria, el operacin que es realiz y elque si tipo_op char monto :de el monto de la misma, determinar el se realiz yla misma, determinar el nuevo saldo de retiro (DetNvoSaldo) monto : float la cuenta. nuevo saldo de la cuenta. DetNvoSaldo () : float
Ilustracin 48: Ejemplo 1 de aplicacin de metodologa.
Con frecuencia te enfrentars a planteamientos de problemas donde no estn explcitos los datos de entrada ni los requerimientos; algunos pueden estar implcitos (sobreentendidos), y otros tendrs que incluirlos ya que si no, no te funciona el modelo (la ejemplificacin). Debers practicar mucho.
entero Cmo nmero un una excelente (cero) El llevar Siel nombre que ideaste!... Dado saber solucin final. clientelos Ya s!! nmero tes vienen slo el ejemplo:lasa decon POO:participan ysipuede decirte rpidamente si vas bien. 2- 1- Comprende: NroEnterola sies positivo...positivo??? Abstraccin: Estenmero problemaentero, mayor es dato de problema Planteamiento del 10 nmero Dado un el valor que te implcito. resalta con eeamiento desderesaltasteun 2 entidadesvalor (la metodologadatosestaba dan ser atributo, los clculos son mtodos... proceso de anlisis Programarelaplicacin deElclase), nmerodel entrada, te razonamiento es que es 0 abstraccin entero, Ejemplo valor : int que el mismo es positivo o negativo. tambin... determinar si cero, entonces es es DetEsPositivo () : positivo positivo (DetEsPositivo) o negativo. bool
Decanato de
ms anlisis Llamadalocal aplicacin tendrs 1 quedatos llamada local Si llama celulares una tipo (L - que incluir que ... Condicionadoalgo, los metodologa eso si opciones Ejemplodelentidadesal excelente ...celular decirte rpidamente si vas bien. - Comprende:depara determinarlocal cuesta abstraccin del atributo tipificador. es: dees Planteamientolasaser10 POO:participan yBsBsuna un problema bstraccin: Esteentrada, decon minutos clculos 6se mtodos...te dan dato Programar solucinminutos son son resalta llamada20 que deElson C) los te una 3 la atributo, Se sabe puede llevar problema final. cliente razonamiento tipo : char dada duracin...por 0,1 Bs. 0,3, dada la (tipo=C) (tipo=L) cuesta ... cuesta Bs. 0,1 losminuto y a calcular multiplican el minutos celular minutos : int 0,3 (DetMtoServicio) monto... duracin de la llamada, calcular el monto a pagar por el DetMtoServicio () : servicio. float
1.2
EJEMPLOS
DE PROGRAMAS ORIENTADOS A OBJETOS
#ifndefejecucina #include CtaBanco <iostream> CTABANCO_H EsteImplementacinPrincipal::CtaBanco POO no compila! Interfaz ProgramaCtaBanco CtaBanco (){ punto y de clase de clase(Principal.cpp) Programa importantsimo!, si(CtaBanco.cpp) comaCrear POO paso1 de no, es enEjemplo (CtaBanco.h) #define CTABANCO_H #include ,"CtaBanco.h" saldo_actual = 0; paso en pg. (Carpeta Proy-CtaBanco)
using namespace std; tipo_op = 'D'; class CtaBanco { monto = 0; private: int } main (){ CtaBanco :: CtaBanco (float s, char t, float saldo, mto; saldo_actual; char t_op; float m){ tipo_op; // "D"=Depsito, "R"=Retiro "Introduzca el saldo actual: "; cout << saldo_actual = s; float monto; cin >> = t; tipo_op saldo; public: << "Tipo de operacin "; cout monto = m; } cout << "(R=Retiro, D=Deposito): "; CtaBanco (); void CtaBanco :: SetSaldoActual (float s) CtaBanco (float, char, float); cin >> t_op; { cout SetSaldoActual (float); void << "Introduzca el monto: "; void SetTipoOp (char); cin >> mto; saldo_actual = s; } CtaBanco c (saldo, t_op, mto); void SetMonto (float); :::cout << "El EL RESTO DE de la GETs Y float GetSaldoActual (); LOS cuenta // AC VAN nuevo saldo es: "; SETs GetTipoOp (); char float CtaBanco :: GetMonto (){ endl; float GetMonto (); cout << c.DetNvoSaldo () << float DetNvoSaldo system("PAUSE"); (); return monto; }; } #include "CtaBanco.cpp" float CtaBanco :: DetNvoSaldo (){ #endif if (tipo_op == 'D') return saldo_actual + monto; else return saldo_actual - monto; }
Ilustracin 51: Ejemplo 1 de POO (Proy-CtaBanco).

r i a Del la implementacin de los mtodos l ov a t t a o : De N Sa l o ( La abstraccin te pfllevaedCi o:taoatenp ucda;: nombresd de ) atributosPOO La ejemplificacinps _a aBejemplo) t yv o abstraccin al y nombres de mtodos Abstraccin {en , pg. l a if f o ( lt _ cot a= l= ' D ' c hr a t u tr in p s a ol pd ; _ /a /c t " D "l = D+ e p o sn it to o; , " R " = R e t i r o o_ o er ua m a m o n tn ef l so e t r e t u r o- ;m so na lt do o; _ a c t u a l p u bl i c : } : : :: : : : :s : c l a: s : C ta B a n co {
Identificacin de objetos en , pg.
Ilustracin 52: Del ejemplo y abstraccin al POO (Proy-CtaBanco).
Si tengo 2000 Bs en el b Las operaciones??? R

Decanato de
#ifndef NROENTERO_H #include (Principal.cpp) NroEntero<iostream> te punto y comaCrear POOen NroEntero (){compila! Programa Principal :: ejecucin no NroEntero.hpaso2 desi no, NroEntero.cpp a es importantsimo!, POO Programa Ejemplo #define NROENTERO_H #include ,"NroEntero.h" valor en 0;Proy-NroEntero) paso = pg. (Carpeta
using namespace std; } class NroEntero { NroEntero :: NroEntero (int v){ private:= v; int main (){ valor } int Nro; valor; public: << "Introduzca el (int v){ void NroEntero :: SetValorNro entero: "; cout NroEntero cin >> v; (); valor = Nro; } NroEntero n (Nro); (int); int NroEntero :: GetValor (){ void SetValor (int); if (n.DetEsPositivo ()) int GetValor numero es positivo." << return valor; (); cout << "El endl; } bool DetEsPositivo(); };else cout << "El numero es negativo." bool NroEntero :: DetEsPositivo (){ << (valor >= 0) if endl; #include "NroEntero.cpp" system("PAUSE"); return 1; #endif } else return 0; }
Ilustracin 53: Ejemplo 2 de POO (Proy-NroEntero).
#include Llamada no, :::Programa<iostream> Llamada :: paso3a de POO Llamada.h e punto Programa Principal en ejecucin no compila! y comaLlamada.cpp (Principal.cpp) es importantsimo!, si (){ Crear POO Ejemplo #include'L'; { class(Carpeta Proy-Llamada) tipoLlamada = ,"Llamada.h" paso en pg.
using namespace std; private: minutos = 0; } char tipo; int main :: Llamada (char t, int m){ Llamada (){ int minutos; public:= t; int mins; tipo char tipo; Llamada (); minutos = m; } Llamada "Tipo llamada (L=ocal, cout << (char, int); C=elular): "; // Se omiten Sets y Gets float Llamada :: DetMtoServicio (){ cin >> tipo; float DetMtoServicio (); if (tipo == 'L') };cout << minutos * 0.1; return "Cantidad de minutos: "; :::: >> mins; cin else return minutos * 0.3; } Llamada ll (tipo, mins); cout << "El monto del servicio es: "; cout << ll.DetMtoServicio () << endl; system("PAUSE"); }
Ilustracin 54: Ejemplo 3 de POO (Proy-Llamada).
La ejemplificacinla implementacin de los mtodos La abstraccin te lleva a ejemplo y abstraccin al POO Del te da nombres de atributos y nombres de mtodos Abstraccin en , pg.
Ilustracin 55: Del ejemplo y abstraccin al POO (Proys Llamada y NroEntero).
cbf ll aoa sa s st sN NLr rloL oaEl Emn a nat mtde aear rdo o:a : {: { D eD te Mt tE c lo l Sital nmero'10 10 mi pp iri(fifiv v vaEltollama=local )es po r a( teir :ep o:> = = 0 ) L ' i rn ret et tuv ura rnl no r1 m; i n u t o s * 0 . ceue lbhlt slsaiCmousaber nsi un va rp r:r e;e t t u rr 0m ;i u t s * Sic ollamanncelular o20 m p eie :} i: :n :t : : m : i: n u t o s ;
Identificacin de objetos en , pg.
PROPUESTOS
1.3
EJERCICIOS
Resuelve los siguientes planteamientos siguiendo la metodologa sugerida en esta seccin: 1- Identificacin de entidades, 2- ejemplificacin y abstraccin, 3- diseo de clases y 4- programacin.
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 jvenes venezolanos mayores de 18 aos, o extranjeros mayores de 21. Dada esta informacin, determinar si el aspirante es admitido o no. e) Dado un nmero entero, determinar si es mltiplo de 3 y si es mltiplo 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 informacin necesaria. g) A un vendedor se le asignar una comisin del 5% si sus ventas son hasta Bs. 500, el 10% si son hasta Bs. 2.000, y el 15% si vende ms de 2.000. Calcular la comisin. 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 condicin de un alumno dada su nota final. i) Dado el estado civil de una persona, determinar la prima a pagar por un seguro segn 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.
a !! i C Y s S el ondicionado : : : : : : losm entonce inutospo
Decanato de
La solucin a estos ejercicios la conseguirs en la pgina respuestas a ejercicios propuestos. Ten presente que hay mltiples formas de resolver un mismo ejercicio, de manera que tu respuesta puede diferir pero tambin estar buena siempre que produzca los mismos resultados y cumplas con la metodologa establecida.
1 RESPUESTAS A EJERCICIOS PROPUESTOS

1.1 PLANTEAMIENTOS
DEL TPICO
EJERCICIOS
Por qu crees que la programacin visual tambin ser POO? R. cuando el programador disea con aplicaciones visuales y usa el ratn y barras de herramientas (como las que tiene Excel y Word), entonces cada uno de esos mltiples componentes que se colocan son objetos que pueden a su vez programarse y configurarse como tales. Podras identificar qu cosas de la vida real son objetos? R. Todo lo que nos rodea son objetos que pueden describirse en trminos de sus propiedades y su comportamiento; si miras a tu alrededor vers: puertas, ventanas, mesas, sillas, libros, techo, piso, rboles, cables de electricidad, edificios, casas, vehculos, montaas, vidrios, cuadros, equipos electrnicos y muchas cosas ms. Mira a tu alrededor y date cuenta que cualquier cosa tiene propiedades (VALORES, Ej: color, tamao, peso, longitud) y comportamiento (ACCIONES, Ej: mover, cambiar forma, encender, etc.). Qu significa disear las aplicaciones?, qu significa implementarlas? R. disear una aplicacin consiste en analizar sus requerimientos y conseguir alguna forma de resolverlos (abstraccin), posiblemente ideando un ejemplo (un modelo, tal y como los arquitectos hacen maquetas) que represente la requerido y su solucin; por otro lado, implementarlas consiste en la programacin propiamente de la solucin ideada con el uso de un lenguaje de programacin para producir un programa ejecutable .EXE (en el caso de la maqueta, los Ingenieros Civiles implementan lo representado en las maquetas).
1.1
PLANTEAMIENTOS
DEL TPICO
EJERCICIOS
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 necesitars ms variables, slo objetos? R. Falso, s se necesitan variables a los efectos de almacenar valores atmicos (datos simples) como un nmero, una edad, un nombre y luego enviarlos por argumentos o para asignarle valores a los atributos de objetos.
Decanato de
Por qu necesitas declarar el uso de objetos, as como con variables? R. Recuerda que dijimos que los objetos tambin son variables, en este caso de algn tipo Clase X, por tanto hay que declararlas para el C++ les asigne espacios en memoria donde se guardarn los valores asignados a los atributos del objeto. Es decir, un objeto es como una composicin de varias celdas de memoria (una por cada atributo), y al ser declarado se asigna espacio de memoria para su procesamiento.
1.1
PLANTEAMIENTOS
DEL TPICO
EJERCICIOS
Cuando describes los componentes de un objeto, Cmo puedes distinguir qu ser atributo y qu ser mtodo? R. si haces una enumeracin de los componentes de un objeto que analizas, aquellos componentes que puedan tomar un valor sern los atributos, los que signifiquen una accin o un cambio de estado sern mtodos. Ej: ATRIBUTOS DEL OBJETO CELULAR: nmero, marca, modelo, cantidad de nmeros para almacenar, permite mensajes sms, MTODOS: remarcar, enviar mensaje sms, y otros. Describe en trminos de objetos un ratn de computadoras, es tangible o no? R. s es tangible, ATRIBUTOS: cantidad de botones, color, marca, tipo de seal (almbrico, inalmbrico, bluetooth), tamao (pequeo, mediano, grande), COMPORTAMIENTO: subir flecha, bajar flecha, clic, doble clic, arrastrar, etc. Describe en trminos de objetos un nmero, 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 trminos de objetos un empleado, es tangible o no?. R. es tangible, ATRIBUTOS: nombre, cdula, sexo, sueldo base, asignaciones, deducciones, fecha de nacimiento, COMPORTAMIENTO: Edad, sueldo neto, aumentar sueldo, Asignar cargo, etc. Describe en trminos de objetos la frmula de velocidad (v = d / t, velocidad es distancia sobre tiempo), es tangible o no?. R. es intangible, ATRIBUTOS: distancia, tiempo, MTODOS: Calcular velocidad. Describe en trminos de objetos los alumnos de una clase, es tangible o no?. R. es tangible, ATRIBUTOS: lista de cdulas, 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 trminos de objetos un tringulo, 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 permetro, determinar tipo de tringulo, etc.
1.1
PLANTEAMIENTOS
DEL TPICO
EJERCICIOS
Qu puedes hacer para identificar y corregir errores de compilacin? 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 ms lograr programas sintcticamente correctos. Qu puedes hacer para identificar y corregir errores de ejecucin? R. lo primero es determinar cul 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 clculos errneos (tal vez con corridas en fro), y en los casos ms difciles tendrs que hacer una depuracin paso a paso inspeccionando el contenido de cada variable durante la ejecucin. Cundo puedes saber que un programa ya no tiene errores de ejecucin? R. Un programa en ejecucin debes probarlo con mltiples datos de entrada, es posible que alguna combinacin de datos de entrada te produzca un error. La prctica te permitir identificar cada vez mejor la combinacin de datos de entrada ms 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 combinacin de datos de entrada produzca errores en la ejecucin. Como regla general, considera conjuntos de datos que pongan a prueba los procesos en sus etapas iniciales o finales. Cunto tiempo es el necesario para dedicar a cada etapa de la implementacin? R. si cumpliste la etapa de anlisis y tienes listo el diseo de la solucin, la escritura del programa slo depender de tu velocidad de transcripcin; la etapa de compilacin durar menos en la medida que ms conozcas la sintaxis de los comandos y sepas interpretar los mensajes de error; la correccin de errores durante el tiempo de ejecucin en ocasiones puede resultar largo, pero puedes simplificar si aprendes a reproducir los errores y usas la herramienta automatizada de depuracin.
Decanato de
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 extrao cuando un lenguaje de programacin tiene errores por su culpa; la gran mayora de las veces se trata de errores de lgica, tal vez difciles de identificar. Incluso la depuracin de un solo error puede ser una actividad de varios das. El Internet y la consulta a expertos pueden ayudar. Con cuntos datos debers probar tus programas para saber que estn bien? R. si es un programa sencillo (tal vez trivial) entonces crrelo unas 2 veces con datos muy diferentes; para problemas ms complejos, selecciona casos de entrada atpicos y tambin prueba con situaciones excepcionales o fuera de lo comn. Si un programa amerita 50 datos de entrada, o ms, cmo puedes hacer para simplificar la entrada y hacer varias pruebas de ejecucin? R. puedes reemplazar la entrada por teclado con entrada por un archivo de texto; as para crear situaciones diversas en la entrada, slo cambias algunos valores en el archivo de texto y te puedes concentrar en depurar en lugar de tipear.
1.1
PLANTEAMIENTOS
DEL TPICO
EJERCICIOS
Plantea la abstraccin para el siguiente problema: Para una discoteca irn varias personas, entre chicos y chicas; la entrada de un chico cuesta Bs. 40, para una chica le cuesta el 50%, Cunto dinero debern llevar cada grupo para que puedan entrar?. R. Multiplico la cantidad de chicos por 40 y la de chicas por 20. Cmo podras describir con tus palabras la herencia? R. Es cuando puedes identificar las caractersticas comunes entre cosas (entidades) afines y estableces una entidad bsica que te servir para decir que todas las dems son as. Cmo podras describir con tus palabras el polimorfismo? R. Sucede cuando tienes herencia y en la jerarqua de clases hay comportamientos que puedes llamar de igual manera pero que en realidad tienen variaciones dependiendo de cada clase derivada. Describe en trminos de abstraccin: Dado un nmero entero, determinar si el mismo es positivo o negativo. R. El nmero es positivo si es mayor o igual a cero. Describe en trminos abstractos: Dado el saldo actual de una cuenta bancaria, el tipo de una nueva operacin (R:etiro, D:epsito) que se realiz y
el monto de la misma, determinar el nuevo saldo de la cuenta. R. Al saldo actual se le suma el depsito o se le resta el retiro. Describe en trminos de abstraccin: En la UCLA hay 5 decanatos y se conoce de cada uno: el nmero de alumnos que se retiraron y el porcentaje que representan, Cuntos 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. Segn lo visto hasta ahora, cmo logras el encapsulamiento cuando haces un programa con POO? R. asegurndote de que los atributos de cada objeto sean privados (no pueden accederse desde fuera del objeto), y que slo los mtodos del mismo objeto sean quienes accedan (modifiquen) sus valores. Identifica la herencia que puedes idear del siguiente planteamiento: Un tringulo y un crculo son figuras geomtricas con su rea y permetro, cada uno con su frmula particular. R. Defines la clase base Figura con mtodos para clculo de rea y permetro, y las clases derivadas seran Tringulo y Crculo. Cmo podras aplicar polimorfismo al ejemplo de las figuras geomtricas? R. El mtodo que calcula el rea y el que calcula el permetro retornan cero (0) en la clase base, pero en las clases derivadas est la frmula correcta para cada una; un nuevo mtodo en la clase base que haga referencia al rea o al permetro, p.ej. FiguraGrande, invocar correctamente al mtodo de una clase derivada, aunque est ubicado en la clase base Figura. Identifica la herencia que puedes aplicar a los electrodomsticos que usas en casa. R. la clase base la llamaras Electrodomstico con mtodos de encender, apagar, temporizar, y las clases derivadas: Lavadora, Licuadora, Pulidora Cmo puedes aplicar herencia a los distintos tipos de cuentas bancarias sabiendo que toda cuenta tiene un nmero y un titular, una cuenta de ahorros paga intereses, una cuenta corriente cobra comisin 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 inters; la clase derivada Cuenta corriente hereda de Cuenta y tiene adicional la comisin que cobra; el Plazo fijo hereda de Cuenta ahorros teniendo como miembro adicional el lapso de tiempo.
Decanato de
Cmo podras aplicar polimorfismo al ejemplo de los electrodomsticos? R. El clculo del saldo actual seguramente se ver afectado por las comisiones e intereses de las clases derivadas; as, podras definir un mtodo CalcularSaldoActual en la clase base el cual invoca a CalculosEspeciales, mismos que en Cuenta dan cero (0) pero en las clases derivadas tienen algn proceso particular. Cmo podras aplicar polimorfismo al ejemplo de los telfonos? R. por ejemplo en el mtodo Marcar de Telfono defines un mtodo PrepararMarcado, el cual no hace nada en la clase Telfono pero en Telfono fijo te presenta una lista de contactos, y en Fax adems te pregunta si est lista la hoja para enviar.
1.1
PLANTEAMIENTOS
DEL TPICO
EJERCICIOS
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 clculo para varias personas. R. El objeto final es Inversionistas y persona; los inversionistas son varias personas; tambin podra ser Cuentas y Persona. Artculos: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: Una persona compra un artculo a un valor de costo, si quisiera ganarle el 50% de lo invertido en cunto debera venderlo?, en cunto si quisiera el 50% del precio de venta?. Repita el proceso para repetir los clculos 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 bsico y adems se le asigna una comisin del 25% sobre las ventas que realiz, determinar cunto cobrar el empleado. Procesar esta informacin 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
informacin necesaria. R. Puedes asumir que se trata de una sola persona que pagar en Enelbar, por tanto el objeto sera 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 segn 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 sera 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 condicin 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 sern Caja y sobre. Pares de nmeros: En el siguiente planteamiento identifica los sustantivos que participan, objetos candidatos y objetos finales: Dado varios pares de nmeros, determinar el porcentaje de pares donde ambos suman ms de 10. R. Imagina un casino donde se juegan dados; los objetos sern 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 sern Letras y Letra. Para el resto de los ejercicios anteriores identifica los atributos de los objetos, los requerimientos y la abstraccin de la solucin.
Ejercicio UCLA Estado civil Atributos UCLA: innecesario Decanato: Nro y Porcentaje de retirados Persona: Edo Civil, valor del bien Requerimientos Cantidad de alumnos que quedan en cada decanato Monto de la prima Abstraccin La diferencia entre 100% y %retirados da %quedan; por regla de tres sale la cantidad partiendo del Nro retirados Segn el estado civil, se le saca el 10, 15 20% al valor del bien
Decanato de
Atributos Empleado: tipo Empresa (obrero, admon), sueldo actual Banco: monto creacin Cliente: total Banco depositado, total retiros, total comisiones Universidad: Acumulador de cantidad de aprobados Profesores y reprobados Profesor: Cantidad de aprobados y reprobados Inversionistas: innecesario Billetes Persona: CantBill5, CantBill10, CantBill20, CantBill50 Artculos Persona: Costo del artculo Empresa: innecesario Vendedor: sueldo base, ventas Persona: cantidad de impulsos Persona: valor del bien y estado civil
Ejercicio
Requerimientos Nuevo sueldo Cantidad dinero le quedar al banco y a cada cliente % aprobados y % reprobados por cada profesor y % aprobados y % reprobados para toda la universidad Cantidad total de dinero
Abstraccin Condicionado al tipo, sumar un 10% 15% al sueldo actual 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 creacin 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. Se multiplican la CantBill5 X 5, CantBill10 X 10, CantBill20 X 20, CantBill50 X 50 y se suman Para ganarle el 50% de lo invertido le suma la mitad del costo; para ganar el 50% del PVP multiplica Costo X 2 Se le calcula el 25% de las ventas y se le suma al sueldo base Condicionado a la cantidad de impulsos, se multiplica el valor respectivo en Bs por la misma Condicionado al estado civil, se calcula por el porcentaje respectivo el valor del bien Condicionado a la nota, se determina la condicin Se multiplica para cada sobre la cantidad por el valor del billete, y se suman los resultados
PVP50alCosto y PVP50alPVP Cunto cobrar el empleado Monto a pagar a Enelbar Monto de la prima La condicin del alumno Total de dinero en la caja
Sueldo
Enelbar
Primas
Nota Alumno: Nota apreciativa Caja: acumulador de Sobres de dinero Dinero Sobre: valor del billete y cantidad de billetes
Ejercicio
Pares de nmeros
Atributos Casino: Contador de mayores a 10 y cantidad de lanzamientos Dados: Nmero1 y Nmero2
Requerimientos Porcentaje de lanzamientos que suman ms de 10
Abstraccin Se cuentan las veces que suman ms de 10 y se divide entre la cantidad de lanzamientos, X 100
Para el resto de los ejercicios realiza una ejemplificacin con al menos 5 registros (si aplica). Demuestra la correspondencia con los componentes de los objetos.
Ejercicio Ejemplificacin Asume entradas a 10, 15 y 20 respectivamente Reg. CantNinos CantAdoles CantAdult PagaFamilia 1 2 0 1 40,00 2 4 1 2 95,00 3 2 2 0 50,00 4 1 1 1 45,00 El objeto familia tiene atributos: CantNinos, CantAdoles, CantAdult y PagaFamilia es un mtodo Nota que se toman ejemplos de fcil procesamiento Decanato N retiros % retiros % quedan Total alum TotQuedan 1 40 40% 60% 100 60 2 20 50% 50% 40 20 3 10 1% 99% 1000 990 4 50 10% 90% 500 450 5 1 2% 98% 50 49 Quedan inscritos en la UCLA: 1569 Los atributos de Decanato: NroRetiros y PorcRetiros Los mtodos de Decanato: PorcQuedan, TotalAl y TotalQuedan Mtodos de UCLA: QuedanUCLA Sea un persona casada con un carro de Bs 100.000, la prima sera de 15.000 Para una persona divorciada la prima sera de Bs 20.000 Si un obrero gana 1500 Bs, el nuevo sueldo ser de 1650 Bs Si un empleado gana 3000 Bs, el nuevo sueldo ser de 3150 Bs
Circo
UCLA
Estado civil Empresa
Decanato de
El banco se crea con Bs 10000,00 Cliente BsDeposito BsRetiro BsComision BsQueda 1 1000 500 50 450,00 2 5000 1000 100 3900,00 Banco 3 8000 1000 50 6950,00 4 3000 2000 40 960,00 Total le queda al Banco: 22600,00 Cliente: atributos= BsDeposito, BsRetiro, BsComision; mtodos=BsQueda Banco: atributos= BsCreacion, mtodos= BsQueda Profesor Aprobaron Reprobaron TotalAl %Aprob %Reprob 1 90 10 100 90% 10% 2 198 2 200 99% 1% 3 60 40 100 60% 40% 4 20 20 40 50% 50% Profesores Total UCLA 368 72 440 83,63% 16,36% Profesor: atributos= Aprobaron, reprobaron; mtodos= TotalAl, PorcAprob, PorcReprob UCLA: atributos: Aprobaron, reprobaron; mtodos= TotalAl, PorcAprob, PorcReprob Empleado SueldoBase Ventas Comisin25 Cobrar 1 1500 10000 2500 4000,00 2 2000 20000 5000 7000,00 Sueldo 3 1000 4000 1000 2000,00 4 3000 3000 750 3750,00 Empleado: SueldoBase y Ventas son atributos; Comision25 y Cobrara son mtodos Si una persona consume 1500 impulsos, deber pagar 1500 x 0,08 = Bs 120 Enelbar Si consume 2000, pagar Bs 100 Nota Si la nota es 80 sera bueno, 81 sera excelente, 30 deficiente apreciativa Reg Valor1 Valor2 Mayor10 1 5 6 1 2 2 5 0 Pares de 3 1 2 0 nmeros 4 4 6 0 Porcentaje donde ambos pares > 10 25% Dados: Atributos= Valor1 y Valor2, Mtodos= Mayor10 Casino: Atributos= ContaMayor10 y ContaTotal, Mtodos= PorcMayor10
Letras
Letra EsVocal S 0 E 1 O 1 I 0 P 0 % Vocales: 40% Letra: Atributos= Carcter, Mtodo= EsVocal Letras: Atributos= ContaVocal, ContaTotal, Mtodo= 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 clculos son mtodos del objeto menor; los clculos relativos a la tabla son mtodos de la clase mayor; los datos de entrada correspondientes a la tabla son atributos de la clase mayor. Describe en trminos de objetos (3 atributos y 3 mtodos): El estudio: atributos= frecuencia (cada 5 Hrs, diaria, semanal), duracin, lugar de estudio; comportamiento= aumentar frecuencia, iniciar estudio, establecer duracin La luz: atributos= color, intensidad, duracin; comportamiento= encender, aumentar intensidad, apagar, colorear Un nmero: atributos= valor, decimales a mostrar, redondear (si o no); comportamiento= quitar decimales, determinar si es par, raz cuadrada. Un poco de agua: atributos= color, sabor, volumen; comportamiento= colorear, vaciar, ondear. Una cuerda: atributos= longitud, color, grosor; comportamiento= enrollar, estirar, amarrar. Un pauelo: atributos= alto, ancho, color; comportamiento= doblar, arrugar, lavar. Un vidrio: atributos= alto, ancho, espesor; comportamiento= superficie, volumen, colorear La flama de un fsforo: atributos= color, tamao, 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.
Decanato de
1.1
PLANTEAMIENTOS
DEL TPICO
EJERCICIOS
Si un atributo es de tipo privado, podrs hacer referencia a l en alguna instancia? R. No, la nica forma de que las instancias vean los miembros es cuando son de visibilidad pblica. Qu tal si el atributo sea protegido? R. igualmente no se puede; la nica forma es que sean de tipo pblico y esto no se recomienda. La visibilidad slo 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 mtodos. Qu significa en la prctica el pase de mensajes entre clases? R. Cuando ests programando, el pase de mensajes ocurre cuando una clase invoca un mtodo de otra clase, y le enva argumentos. Realiza el diagrama de clases para el siguiente planteamiento: Dado varios pares de nmeros, determinar el porcentaje de pares donde ambos suman ms de 10 R.
Dados Casino 1.. - Valor1 : int * ContaMayor10 : int - ContaTotal : int Valor2 : int - PorcMayor10boolean Mayor10 () : () : float
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 creacin del banco y la informacin de varios clientes, Cunto dinero le quedar a cada uno?, Cunto al banco? R.
Cliente Banco 1.. - BsDeposito float * BsCreacion :: int - BsQueda: () : float BsRetiro float - BsComision : float - BsQueda () : boolean
Decanato de
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 informacin necesaria R.
Enelbar - CantImpulsos : int - MontoPagar () : float
1.1
PLANTEAMIENTOS
DEL TPICO
EJERCICIOS
Cmo integra DevC++ todos los componentes de un proyecto de POO? R. lo integras con un archivo con extensin .DEV (Development = desarrollo), el cual se crea cuando haces un proyecto nuevo. Dentro de ese archivo DevC++ coloca toda la informacin 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, 3los 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 informacin. Cmo 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 lnea con el error; preferiblemente toma nota de la traduccin de cada error nuevo que identificas, y haces una lista de errores. Quin identifica los errores que ves en la IDE DevC++? R. los identifica el compilador de C++, el cual es un programa de uso comn para muchos otras IDEs para el desarrollo de programas con C++ Qu son las libreras de uso genrico? R. las libreras de uso genrico almacenan cdigo reusable; la idea es tener fcil acceso a este cdigo con slo aplicar la directiva #include. Cules son los tipos de libreras que pueden usarse con C++? R. estn las libreras propias de C++ (tales como iostream, string, vector, etc) y las desarrolladas por ti (definidas por el usuario).
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 implementacin (.cpp). El objetivo de separar interfaz de implementacin es asegurar el ocultamiento de la informacin de la implementacin (a los usuario finales se les entrega el .h y un pre-compilado de la implementacin, as se oculta este cdigo). Cuntos archivos tiene tpicamente un proyecto de POO con C++? R. tiene el programa principal y 2 archivos por cada clase (.h + .cpp). Qu propsito tiene la directiva #include? R. esta directiva incluye en tu proyecto las definiciones que estn en la librera que se referencia, esto posibilita el uso de las clases y procedimientos reusables. Cmo se usa y qu funcin cumple cada parte de la directiva #ifndef? R. esta directiva permite indicarle al compilador de C++ que debe compilar slo una vez la clase en cuestin; cuando se hace referencia a un archivo de clase (con #include) C++ intentar compilarla, pero si lo hace ms de una vez se produce un error (en virtud a que ya existe la definicin); en tus proyectos posiblemente hagas varios #include a la misma clase en virtud de que la herencia hace necesario estas definiciones en mltiples archivos. Cmo distingue el compilador de C++ que un miembro de clase es un mtodo? R. los mtodos se diferencian de los atributos ya que siempre tienen parntesis en la declaracin; si no colocas parntesis, C++ los tomar como atributos y no como mtodos. Cmo enlaza el compilador la interfaz de la clase con su implementacin? R. al final del archivo .h debes colocar la directiva que incluye la implementacin de la clase (#include xx.cpp) Cmo 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 pblicos. Si deseas hacer algn comentario en tu programa, cmo lo logras? R. los comentarios de una sola lnea van luego de doble signo de divisin ( // ); tambin es posible colocar comentarios ms largos encerrndolos entre /* y */ (inicio de comentario: /*, fin de comentario: */). Qu reglas debes cumplir en la implementacin de una clase? R. cada implementacin de un mtodo o un constructor debe llevar el nombre de la
Decanato de
clase como prefijo, luego :: y finalmente el nombre del mtodo o el constructor Qu significa implementar la clase? R. implementar es sinnimo de programar (hacer el programa, desarrollarlo). Qu secuencia de compilacin de los archivos del proyecto sigue C++? R. comienza por el programa principal y contina con los archivos que va consiguindose 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 cdigo fuente. Cul es la utilidad de la directiva #ifndef? R. para que no se produzca el error de redefinicin de clase, ya que cada clase slo 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 algn constructor se program para que inicializara los atributos, o tambin invocando los Sets respectivos. Qu son constructores? R. son un tipo especial de mtodos que se invocan automticamente cuando se declara una instancia de una clase. Su objetivo es la creacin de los componentes del objeto y permiten inicializarlos en valores neutros (cero, cadena vaca, espacio en blanco), o con valores de inicializacin que vienen por argumentos al constructor. Para qu sirven los mtodos Setters y Getters? R. respectivamente para asignar y para obtener el valor de un atributo (Set=Asignar, Get=Obtener). Qu significa Slo un conjunto restringido de mtodos deben acceder a los atributos? R. que los atributos no deben accederse directamente desde las instancias, slo a travs de los mtodos (usualmente Set o Get). Qu es sobrecarga de mtodos? R. la sobrecarga de mtodos permite definir mtodos o funciones con igual nombre pero con diferentes argumentos; al momento de usar la funcin o el mtodo, se escoger el ms apropiado dados los datos con los que se cuenta en el momento de la invocacin. Qu utilidad tiene la sobrecarga de mtodos? R. permite la definicin de procesos que pueden realizarse con distintos grupos de argumentos,
posibilitando una misma denominacin para el proceso. Ej: una clase Universidad permitira BuscarAlumno bien sea por cdula o por nombre, pero el mtodo se llamara igual; en ese caso habran 2 mtodos: uno con un argumento de tipo numrico y el otro con argumento de tipo string, al momento de invocarlo C++ sabra por el argumento a cul de los 2 se hace referencia. Qu utilidad tiene una IDE como DevC++? R. es una aplicacin que ofrece todo lo necesario para desarrollar los programas, desde escribirlos hasta compilarlos, probarlos y depurarlos. Cules 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 daan. Qu propsito tiene cada paso de la creacin 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 ms avanzado), 3- cuando incluyes archivos a tu proyecto ests 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 producirn errores de compilacin. Revisa la ilustracin paso a paso para la creacin de un proyecto y pregunta el propsito del resto de los pasos.
1.1
PLANTEAMIENTOS
DEL TPICO
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- Identificacin: Dada la letra del sexo de 2- Ejemplo: si la letra es f o F entonces una persona (F o M), programe y muestre si es es mujer. Abstraccin: condicionado a la hombre o mujer letra se retorna el gnero de la persona 3- Clase: 4- Programa: #include <iostream> Persona using namespace std; sexo: char #include "Persona.h" int main(){ EsHombre(): boolean char sexo; DetGenero(): string cout << "Sexo de la persona (F-M): ";
cin >> sexo; Persona p (sexo); cout << "El genero es "; cout << p.DetGenero () << endl; system ("PAUSE");
Decanato de
#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- Identificacin: Dada la edad de una 2- Ejemplo: si la edad es 17 entonces no persona, determinar si es o no mayor de es mayor de edad. Abstraccin: se edad. compara con mayor o igual a 18 para que sea mayor de edad. 3- Clase: 4- Programa: #include <iostream> Persona using namespace std; edad: int #include "Persona.h" int main(){ MayorEdad(): boolean
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");
#ifndef PERSONA_H #define PERSONA_H #include <string> using namespace std; 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- Identificacin: En una empresa se asignar 2- Ejemplo: si es obrero y gana 2000, un aumento del 10% a todo el personal obrero entonces nuevo sueldo es 2200; de ser y un 5% al personal administrativo. Calcular el administrativo el nuevo sueldo sera 2100. nuevo sueldo de un empleado dado su tipo y Abstraccin: condicionado al tipo de sueldo actual. empleado, se incrementa 5% 10%. 3- Clase: 4- Programa: #include <iostream> Empleado using namespace std; #include "Empleado.h" tipo: char int main(){ char tip; sueldo_act: float cout << "Tipo personal (O=brero, E=mpleado): "; NuevoSueldo(): float 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 jvenes venezolanos mayores de 18 aos, o extranjeros mayores de 21. Dada esta informacin, determinar si el aspirante es admitido o no. Resuelto en carpeta Proy-Admitido
1- Identificacin: En una academia se admiten a aquellos jvenes venezolanos mayores de 18 aos, o extranjeros mayores de 21. Dada esta informacin, determinar si el aspirante es admitido o no. 2- Ejemplo: si es venezolano con la edad 18 entonces no es admitido; extranjero de 22 aos es admitido. Abstraccin: se admite si es venezolano > 18 aos, o si edad > 21 .
Decanato de
3- Clase: Joven edad: int venezolano: bool EsAdmitido(): bool RespAdmitido(): string
4- Programa:
#include <iostream> using namespace std; #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"); } 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"; }
#ifndef JOVEN_H #define JOVEN_H #include <string> using namespace std; class Joven { private: int edad; bool venezolano; //1=si, 0=no public: Joven (int, bool); bool EsAdmitido (); string RespAdmitido (); }; #include "Joven.cpp" #endif
Dado un nmero entero, determinar si es mltiplo de 3 y si es mltiplo de 5. Resuelto en carpeta Proy-Multiplo

1- Identificacin: Dado un nmero entero, 2- Ejemplo: si el nmero es 10 slo es determinar si es mltiplo de 3 y si es mltiplo de 5; de ser 15 s es mltiplo de 3 mltiplo de 5. y 5. Abstraccin: se usa el operador mdulo (#) y se verifica con 3 y con 5. 3- Clase: 4- Programa: #include <iostream> Numero using namespace std; entero: int #include "Numero.h" int main (){ Multiplo3y5 (): boolean int e; RespMultiplo (): string 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"; }
Decanato de
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 informacin necesaria. Resuelto en carpeta ProyENELBAR
1- Identificacin: ENELBAR cobra por servicio de la siguiente manera: si consumi 2- Ejemplo: Si una persona consume 1500 menos de 1000 impulsos cada uno costar impulsos, deber pagar 1500 x 0,08 = Bs Bs. 100, si consumi menos de 2000 costar 120; Si consume 2000, pagar Bs 100. Bs. 80 y Bs. 50 si consumi al menos 2000. Abstraccin: Un anidamiento de if Calcular el monto a pagar a ENELBAR dada resuelve el problema. toda la informacin necesaria. 4- Programa:
#include <iostream> using namespace std;
3- Clase: Servicio impulsos: int MontoAPagar (): 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_H using 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 comisin del 5% si sus ventas son hasta Bs. 500, el 10% si son hasta Bs. 2.000, y el 15% si vende ms de 2.000. Calcular la comisin. Resuelto en carpeta Proy-Comision
1- Identificacin: A un vendedor se le asignar una comisin del 5% si sus ventas son hasta Bs. 500, el 10% si son hasta Bs. 2.000, y el 15% si vende ms de 2.000. Calcular la comisin. 2- Ejemplo: Si una vendedor vende 400 la comisin ser Bs 20; Si vende 2000, ser Bs 200. Abstraccin: Un anidamiento de if resuelve el problema.
4- Programa: 3- Clase: Vendedor ventas: float DetComision (): float
#include <iostream> using namespace std; #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_H using namespace std; class Vendedor { private: float ventas; public: Vendedor (float); float DetComision (); }; #include "Vendedor.cpp" #endif #ifndef SERVICIO_H #define SERVICIO_H using namespace std; class Servicio { private: int impulsos; public: Servicio (int); float MontoAPagar (); }; #include "Servicio.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; } 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 condicin de un alumno dada su nota final. Resuelto en carpeta Proy-CondicionAl
1- Identificacin: 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 condicin de un alumno dada su nota final. 2- Ejemplo: Si la nota final es 50, la condicin es deficiente; 51 es bueno. Abstraccin: Un anidamiento de if resuelve el problema.
Decanato de
4- Programa: 3- Clase: Alumno nota: int DetCondicion (): string
#include <iostream> using namespace std; #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 segn 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- Identificacin: Dado el estado civil de una persona, determinar la prima a pagar por un 2- Ejemplo: Si el estado civil es viudo y el seguro segn lo siguiente: Solteros o Viudos bien vale 1000, la prima ser 100; de ser 10%, Casados 15%, Divorciados 20%. divorciado sera 200. Abstraccin: Un Calcular el monto de la prima dado el estado anidamiento de if resuelve el problema. civil de la persona y el valor del bien a asegurar. 4- Programa:
#include <iostream> using namespace std; #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"); }
3- Clase: Persona edo_civil: char valor_bien: float DetMontoPrima (): float
#ifndef PERSONA_H #define PERSONA_H #include <string> using namespace std; 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 BIBLIOGRAFA
JOYANES AGUILAR L. (2000) Programacin en c++. Algoritmos, estructuras de datos y objetos. Mc.Graw Hill/Interamericana de Espaa: 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); Tnez R., Samuel (Revisor); Vaquero S., Antonio (Revisor) Osborne/McGrawHill , Madrid, ESPAA C++ a su Alcance: Un Enfoque Orientado a Objetos Joyanes AguiJar, Luis McGraw-HiII, Mxico, MEXICO C++ Manual de Bolsillo Joyanes Aguilar, Luis McGraw-HiII , Madrid, ESPAA 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-declases.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/

Introducción POO

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Introducción POO

Caricato da

Copyright:

Formati disponibili

Universidad Centroccidental Lisandro Alvarado Sistema de Educacin a Distancia Decanato de Ciencias y Tecnologa

Introduccin a la Programacin Orientada a Objetos con C++

Profesor Giovanni Torrealba

Introduccin a la Programacin Orientada a Objetos con C++

Profesor Giovanni Torrealba

duccin a la Programacin Orientada a Objetos con C++

Profesor Giovanni Torrealba

Introduccin a la Programacin Orientada a Objetos con C++

ESTRATEGIAS DE ENSEANZA EN ESTA GUA DIDCTICA.....................3

Profesor Giovanni Torrealba

duccin a la Programacin Orientada a Objetos con C++

2.1 Filosofa para la transmisin del conocimiento........................................................................3

Profesor Giovanni Torrealba

Introduccin a la Programacin Orientada a Objetos con C++

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

Profesor Giovanni Torrealba

duccin a la Programacin Orientada a Objetos con C++

2.1.2 Imgenes alusivas......................................................................................................................3

Profesor Giovanni Torrealba

Introduccin a la Programacin Orientada a Objetos con C++

2.1.3 Otras estrategias de organizacin de la gua.....................................................................4

Profesor Giovanni Torrealba

duccin a la Programacin Orientada a Objetos con C++

2.2 Ejercicios por tpico......................................................................................................................4

Profesor Giovanni Torrealba

Introduccin a la Programacin Orientada a Objetos con C++

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

Profesor Giovanni Torrealba

duccin a la Programacin Orientada a Objetos con C++

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

Profesor Giovanni Torrealba

Introduccin a la Programacin Orientada a Objetos con C++

Profesor Giovanni Torrealba

duccin a la Programacin Orientada a Objetos con C++

3.1 Creacin de programas..................................................................................................................7

Profesor Giovanni Torrealba

Introduccin a la Programacin Orientada a Objetos con C++

Profesor Giovanni Torrealba

duccin a la Programacin Orientada a Objetos con C++

3.2.1 Implementacin de una Funcin.............................................................................................8

Profesor Giovanni Torrealba

Introduccin a la Programacin Orientada a Objetos con C++

3.2.2 Parmetros de una funcin......................................................................................................9

Profesor Giovanni Torrealba

duccin a la Programacin Orientada a Objetos con C++

3.2.3 Tipos de parmetros segn lo que retornan.......................................................................9

Profesor Giovanni Torrealba

Introduccin a la Programacin Orientada a Objetos con C++

3.2.4 Tipos de parmetros segn su ubicacin............................................................................10

Profesor Giovanni Torrealba

duccin a la Programacin Orientada a Objetos con C++

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

Profesor Giovanni Torrealba

Introduccin a la Programacin Orientada a Objetos con C++

3.3 Estado de la memoria en una ejecucin...................................................................................12

Profesor Giovanni Torrealba

duccin a la Programacin Orientada a Objetos con C++

3.4 Corridas en fro.............................................................................................................................13

Profesor Giovanni Torrealba

Introduccin a la Programacin Orientada a Objetos con C++

3.5 Depuracin de programas............................................................................................................16

Profesor Giovanni Torrealba

duccin a la Programacin Orientada a Objetos con C++