INTRODUCCIÓN

La Programación Orientada a Objetos (POO) es un enfoque conceptual específico

para diseñar programas, utilizando un lenguaje de programación orientado a
objetos, en nuestro caso C++ o Java. Las propiedades más importantes de la POO
son:
• Abstracción.
• Encapsulamiento y ocultación de datos.
• Polimorfismo.
• Herencia.
• Reusabilidad o reutilización de código.
Este paradigma de programación viene a superar las limitaciones que soporta la
programación tradicional o "procedimental" y por esta razón se comenzará con una
breve revisión de los conceptos fundamentales de este paradigma de programación.
Los elementos fundamentales de la POO son las clases y objetos. En esencia, la
POO se concentra en el objeto tal como lo percibe el usuario, pensando en los datos
que se necesitan para describir el objeto y las operaciones que describirán la
iteración del usuario con los datos. Después se desarrolla una descripción de la
interfaz externa y se decide cómo implementar la interfaz y el almacenamiento de
datos. Por último, se ponen juntos en un programa que utilice su nuevo dueño.
Nos limitaremos al campo de la programación, pero es también posible hablar de
sistemas de administración de bases de datos orientadas a objetos, sistemas
operativos orientados a objetos, interfaces de usuarios orientadas a objetos, etc.
Se hace una introducción a UML, como Lenguaje Unificado de Modelado. UML se
ha convertido de facto en el estándar para modelado de aplicaciones software y es
un lenguaje con sintaxis y semántica propias, se compone de pseudocódigo, código
real, programas. Se describe también una breve historia de UML.
MARCO TEORICO
1.- Programación No estructurada
La programación no estructurada es el paradigma de programación más antiguo
capaz de crear algoritmos. A esta programación le sigue la programación por
procedimientos y luego la programación orientada a objetos, ambas consideradas
programaciones estructuradas. Programación estructurada.
Es un paradigma de programación orientado a mejorar la claridad, calidad y tiempo
de desarrollo de un programa de computadora, utilizando únicamente subrutinas y
tres estructuras: secuencia, selección (if y switch) e iteración (bucles for y while),
considerando innecesario y contraproducente el uso de la instrucción de
transferencia incondicional (GOTO), que podría conducir a "código espagueti", que
es mucho más difícil de seguir y de mantener, y era la causa de muchos errores de
programación.
A finales de los años 1970 surgió una nueva forma de programar que no solamente
daba lugar a programas fiables y eficientes, sino que además estaban escritos de
manera que facilitaba su mejor comprensión, no sólo tenía ventajas durante la fase
de desarrollo, sino también posibilitando una más sencilla modificación posterior.
Orígenes de la programación no estructurada
El teorema del programa estructurado, propuesto por Böhm-Jacopini, demuestra
que todo programa puede escribirse utilizando únicamente las tres instrucciones de
control siguientes:
Secuencia
Instrucción condicional.
Iteración (bucle de instrucciones) con condición al principio.
Solamente con estas tres estructuras se pueden escribir todos los programas y
aplicaciones posibles. Si bien los lenguajes de programación tienen un mayor
repertorio de estructuras de control, éstas pueden ser construidas mediante las tres
básicas citadas.
Estructura secuencial
Una estructura de programa es secuencial si las instrucciones se ejecutan una tras
otra, a modo de secuencia lineal; es decir, que una instrucción no se ejecuta hasta
que finaliza la anterior, no se bifurca ni se repite el flujo del programa.
Estructura selectiva o de selección
La estructura selectiva permite que la ejecución del programa se bifurque a una
instrucción (o conjunto de ellas). Según un criterio o condición lógica sólo uno de
los caminos en la bifurcación será el tomado para ejecutarse.
Estructura iterativa
Un bucle iterativo o iteración de una secuencia de instrucciones, hace que se repita
su ejecución mientras se cumpla una condición. El número de iteraciones
normalmente está determinado por un cambio en la condición dentro del mismo
bucle, aunque puede ser forzado o explícito por otra condición.
Anidamiento
El cuerpo de cualquier estructura puede tener instrucciones simples u otras
estructuras, que a su vez pueden contener a otras.
2.- Programación Estructurada
La programación estructurada consiste en escribir un programa de acuerdo con
unas reglas y un conjunto de técnicas. Las re-glas son: el programa tiene un diseño
modular, los módulos son diseñados descendentemente, cada módulo de programa
se codifica usando tres estructuras de control (secuencia, selección e Iteración); es
el conjunto de técnicas que han de incorporar: recursos abstractos; diseño
descendente y estructuras básicas de control. Descomponer un programa en
términos de recursos abstractos consiste en descomponer acciones complejas en
términos de acciones más simples capaces de ser ejecutadas en una computadora.
El diseño descendente se encarga de resolver un problema realizando una
descomposición en otros más sencillos mediante módulos jerárquicos. El resultado
de esta jerarquía de módulos es que cada módulo se refina por los de nivel más
bajo que resuelven problemas más pequeños y contienen más detalles sobre los
mismos. Las estructuras básicas de control sirven para especificar el orden en que
se ejecutarán las distintas instrucciones de un algoritmo. Este orden de ejecución
determina el flujo de control del programa.
C, Pascal, FORTRAN, y lenguajes similares, se conocen como lenguajes
procedimentales (por procedimientos). Es decir, cada sentencia o instrucción señala
al compilador para que realice alguna tarea: obtener una entrada, producir una
salida, sumar tres números, dividir por cinco, etc. En resumen, un programa en un
lenguaje procedimental es un conjunto de instrucciones o sentencias. En el caso de
pequeños programas, estos principios de organización (denominados paradigma)
se demuestran eficientes. El programador sólo tiene que crear esta lista de
instrucciones en un lenguaje de programación, compilar en la computadora y ésta,
a su vez, ejecuta estas instrucciones.
Cuando los programas se vuelven más grandes, cosa que lógicamente sucede
cuando aumenta la complejidad del problema a resolver, la lista de instrucciones
aumenta considerablemente, de modo tal que el programador tiene muchas
dificultades para controlar ese gran número de instrucciones. Los programadores
pueden controlar, de modo normal, unos centenares de líneas de instrucciones.
Para resolver este problema los programas se descompusieron en unidades más
pequeñas que adoptaron el nombre de funciones (procedimientos, subprogramas o
subrutinas en otros lenguajes de programación). De este modo en un programa
orientado a procedimientos se divide en funciones, de modo que cada función tiene
un propósito bien definido y resuelve una tarea concreta, y se diseña una interfaz
claramente definida (el prototipo o cabecera de la función) para su comunicación
con otras funciones.
Con el paso de los años, la idea de romper el programa en funciones fue
evolucionando y se llegó al agrupamiento de las funciones en otras unidades más
grandes llamadas módulos (normalmente, en el caso de C, denominadas archivos
o ficheros); sin embargo, el principio seguía siendo el mismo: agrupar componentes
que ejecutan listas de instrucciones (sentencias). Esta característica hace que a
medida que los programas se hacen más grandes y complejos, el paradigma
estructurado comienza a dar señales de debilidad y resultando muy difícil terminar
los programas de un modo eficiente. Existen varias razones de la debilidad de los
programas estructurados para resolver problemas complejos. Tal vez las dos
razones más evidentes son éstas. Primero, las funciones tienen acceso ilimitado a
los datos globales. Segundo, las funciones inconexas y datos, fundamentos del
paradigma procedimental proporcionan un modelo pobre del mundo real.
3.- Programación Modular
La programación modular es uno de los métodos de diseño más flexible y potente
para mejorar la productividad de un programa. En programación modular el
programa se divide en módulos (partes independientes), cada uno de los cuales
ejecuta una única actividad o tarea y se codifican independientemente de otros
módulos. Cada uno de estos módulos se analiza, codifica y pone a punto por
separado. Cada programa contiene un módulo denominado programa principal que
controla todo lo que sucede; se transfiere el control a submódulos (posteriormente
se denominarán subprogramas), de modo que ellos puedan ejecutar sus funciones;
sin embargo, cada submódulo devuelve el control al módulo principal cuando se
haya completado su tarea. Si la tarea asignada a cada submódulo es demasiado
compleja, éste deberá romperse en otros módulos más pequeños. El proceso
sucesivo de subdivisión de módulos continúa hasta que cada módulo tenga
solamente una tarea específica que ejecutar. Esta tarea puede ser entrada, salida,
manipulación de datos, control de otros módulos o alguna combinación de éstos.
Un módulo puede transferir temporalmente (bifurcar) el control a otro módulo; sin
embargo, cada módulo debe eventualmente devolver el control al módulo del cual
se recibe originalmente el control.
Los módulos son independientes en el sentido en que ningún módulo puede tener
acceso directo a cualquier otro módulo excepto el módulo al que llama y sus propios
submódulos. Sin embargo, los resultados producidos por un módulo pueden ser
utilizados por cualquier otro módulo cuando se transfiera a ellos el control.
Dado que los módulos son independientes, diferentes programadores pueden
trabajar simultáneamente en diferentes partes del mismo programa. Esto reducirá
el tiempo del diseño del algoritmo y posterior codificación del programa. Además,
un módulo se puede modificar radicalmente sin afectar a otros módulos, incluso sin
alterar su función principal.
La descomposición de un programa en módulos independientes más simples se
conoce también como el método de divide y vencerás (divide and conquer). Cada
módulo se diseña con independencia de los demás, y siguiendo un método
ascendente o descendente se llegará hasta la descomposición final del problema
en módulos en forma jerárquica.
4.- Programación Orientada a objetos
La programación orientada a objetos, tal vez el paradigma de programación más
utilizado en el mundo del desarrollo de software y de la ingeniería de software del
siglo XXI, trae un nuevo enfoque a los retos que se plantean en la programación
estructurada cuando los problemas a resolver son complejos. Al contrario que la
programación procedimental que enfatiza en los algoritmos, la POO enfatiza en los
datos. En lugar de intentar ajustar un problema al enfoque procedimental de un
lenguaje, POO intenta ajustar el lenguaje al problema. La idea es diseñar formatos
de datos que se correspondan con las características esenciales de un problema.
La idea fundamental de los lenguajes orientados a objetos es combinar en una única
unidad o módulo, tanto los datos como las funciones que operan sobre esos datos.
Tal unidad se llama un objeto.
Las funciones de un objeto se llaman funciones miembros en C++ o métodos (éste
es el caso de Smalltalk, uno de los primeros lenguajes orientados a objetos), y son
el único medio para acceder a sus datos. Los datos de un objeto, se conocen
también como atributos o variables de instancia. Si se desea leer datos de un objeto,
se llama a una función miembro del objeto. Se accede a los datos y se devuelve un
valor. No se puede acceder a los datos directamente. Los datos están ocultos, de
modo que están protegidos de alteraciones acciden tales. Los datos y las funciones
se dice que están encapsulados en una única entidad. El encapsulamiento de datos
y la ocultación de los datos son términos clave en la descripción de lenguajes
orientados a objetos. Si se desea modificar los datos de un objeto, se conoce
exactamente cuáles son las funciones que interactúan con miembros del objeto.
Ninguna otra función puede acceder a los datos. Esto simplifica la escritura,
depuración y mantenimiento del programa. Un programa C++ se compone
normalmente de un número de objetos que se comunican unos con otros mediante
la llamada a otras funciones miembro. La llamada a una función miembro de un
objeto se denomina enviar un mensaje a otro objeto.

5.- Características Principales de los Objetos

Existen diversas características ligadas a la orientación a objetos. Todas las
propiedades que se suelen considerar no son exclusivas de este paradigma, ya que
pueden existir en otros paradigmas, pero en su conjunto definen claramente los
lenguajes orientados a objetos. Estas propiedades son:
• Abstracción (tipos abstractos de datos y clases).
• Encapsulado de datos.
• Ocultación de datos.
• Herencia.
• Polimorfismo.
5.1.- Polimorfismo
El polimorfismo es la propiedad que permite a una operación (función) tener el
mismo nombre en clases diferentes y que actúe de modo diferente en cada una de
ellas. Esta propiedad es intrínseca a la vida ordinaria ya que una misma operación
puede realizar diferentes acciones dependiendo del objeto sobre el que se aplique.
Un objeto se puede comportar de diferentes formas. La propiedad de polimorfismo
es aquella en que una operación tiene el mismo nombre en diferentes clases, pero,
se ejecuta de diferentes formas en cada clase. Así, por ejemplo, la operación de
abrir se puede dar en diferentes clases: abrir una puerta, abrir una ventana, abrir un
periódico, abrir un archivo, abrir una cuenta corriente en un banco, abrir un libro,
etc. En cada caso se ejecuta una operación diferente, aunque tiene el mismo
nombre en todos ellos “abrir”. El polimorfismo es la propiedad de una operación de
ser interpretada sólo por el objeto al que pertenece. Existen diferentes formas de
implementar el polimorfismo y variará dependiendo del lenguaje de programación.
Además de las ventajas de consistencia y reducción de código, la herencia, aporta
también otra gran ventaja: facilitar el polimorfismo. Polimorfismo es la propiedad de
que un operador o una función actúen de modo diferente en función del objeto sobre
el que se aplican. En la práctica, el polimorfismo significa la capacidad de una
operación de ser interpretada sólo por el propio objeto que lo invoca. Desde un
punto de vista práctico de ejecución del programa, el polimorfismo se realiza en
tiempo de ejecución ya que durante la compilación no se conoce qué tipo de objeto
y por consiguiente qué operación ha sido llamada.
5.2.- Herencia
Se reutiliza el software, se pasan las características a otro objeto. El concepto de
clase conduce al concepto de herencia. En la vida diaria se utiliza el concepto de
clases que se dividen a su vez en subclases. La clase animal se divide en
mamíferos, anfibios, insectos, pájaros, etc. La clase vehículo se divide en autos,
coches carros, camiones, buses, motos, etc. La clase electrodoméstico se divide en
lavadora, frigorífico, tostadora, microondas, etc. La idea principal de estos tipos de
divisiones reside en el hecho de que cada subclase comparte características con la
clase de la cual se deriva. Los autos, camiones, buses, motos..., tienen motor,
ruedas y frenos. Además de estas características compartidas, cada subclase tiene
sus propias características. Los autos, por ejemplo, pueden tener maletero, cinco
asientos; los camiones cabina y caja para transportar carga, etc. La clase principal
de la que derivan las restantes se denomina clase base en C++, clase padre o
superclase y las subclases, también se denominan clases derivadas en C++.
Las clases modelan el hecho de que el mundo real contiene objetos con
propiedades (atributos) y comportamiento. La herencia modela el hecho de que
estos objetos tienden a organizarse en jerarquías. Esta jerarquía desde el punto de
vista del modelado se denomina relación de generalización o es-un. En
programación orientada a objetos, la relación de generalización se denomina
herencia. Cada clase derivada hereda las características de la clase base y además
cada clase derivada añade sus propias características (atributos y operaciones).
Las clases bases pueden a su vez ser también subclases o clases derivadas de
otras superclases o clases base. Así, el programador puede definir una clase Animal
que encapsula todas las propiedades o atributos (altura, peso, número de patas,
etc.) y el comportamiento u operaciones (comer, dormir, andar) que pertenecen a
cada animal. Los animales específicos como un Mono, Jirafa, Canguro o Pingüino
tienen a su vez cada uno de ellos características propias.
5.3.- Encapsulamiento
La encapsulación o encapsulamiento, significa reunir en una cierta estructura a
todos los elementos que a un cierto nivel de abstracción se pueden considerar
pertenecientes a una misma entidad, y es el proceso de agrupamiento de datos y
operaciones relacionadas bajo una misma unidad de programación, lo que permite
aumentar la cohesión de los componentes del sistema. En este caso, los objetos
que poseen las mismas características y comportamiento se agrupan en clases que
no son más que unidades de programación que encapsulan datos y operaciones.
La encapsulación oculta lo que hace un objeto de lo que hacen otros objetos y del
mundo exterior, por lo que se denomina también ocultación de datos.
Las clases están contenidas. El encapsulado o encapsulación de datos es el
proceso de agrupar datos y operaciones relacionadas bajo la misma unidad de
programación. En el caso de los objetos que poseen las mismas características y
comportamiento se agrupan en clases, que no son más que unidades o módulos de
programación que encapsulan datos y operaciones.
5.4.- Abstracción
Permite implementar código mediante clases y objetos. La abstracción es la
propiedad de los objetos que consiste en tener en cuenta sólo los aspectos más
importantes desde un punto de vista determinado y no tener en cuenta los restantes
aspectos. El término abstracción que se suele utilizar en programación se refiere al
hecho de diferenciar entre las propiedades externas de una entidad y los detalles
de la composición interna de dicha entidad. Es la abstracción la que permite ignorar
los detalles internos de un dispositivo complejo tal como una computadora, un
automóvil, una lavadora o un horno de microondas, etc., y usarlo como una única
unidad comprensible. Mediante la abstracción se diseñan y fabrican estos sistemas
complejos en primer lugar y, posteriormente, los componentes más pequeños de
los cuales están compuestos. Cada componente representa un nivel de abstracción
en el cual el uso del componente se aísla de los detalles de la composición interna
del componente. La abstracción posee diversos grados denominados niveles de
abstracción.
En consecuencia, la abstracción posee diversos grados de complejidad que se
denominan niveles de abstracción que ayudan a estructurar la complejidad
intrínseca que poseen los sistemas del mundo real. En el modelado orientado a
objetos de un sistema esto significa centrarse en qué es y qué hace un objeto y no
en cómo debe implementarse. Durante el proceso de abstracción es cuando se
decide qué características y comportamiento debe tener el modelo.
Aplicando la abstracción se es capaz de construir, analizar y gestionar sistemas de
computadoras complejos y grandes que no se podrían diseñar si se tratara de
modelar a un nivel detallado. En cada nivel de abstracción se visualiza el sistema
en términos de componentes, denominados herramientas abstractas, cuya
composición interna se ignora. Esto nos permite concentrarnos en cómo cada
componente interactúa con otros componentes y centrarnos en la parte del sistema
que es más relevante para la tarea a realizar en lugar de perderse a nivel de detalles
menos significativos.
En estructuras o registros, las propiedades individuales de los objetos se pueden
almacenar en los miembros. Para los objetos, no sólo es de interés cómo están
organizados, sino también qué se puede hacer con ellos; es decir, las operaciones
que forman la interfaz de un objeto son también importantes.
5.5.- Ocultación
La encapsulación oculta lo que hace un objeto de lo que hacen otros objetos y del
mundo exterior, por lo que se denomina también ocultación de datos.
La ocultación de datos permite separar el aspecto de un componente, definido por
su interfaz con el exterior, de sus detalles internos de implementación. Los términos
ocultación de la información y encapsulación de datos (data se suelen utilizar como
sinónimos, pero no siempre es así, y, muy al contrario, son términos similares pero
distintos. Normalmente, los datos internos están protegidos del exterior y no se
puede acceder a ellos más que desde su propio interior y, por tanto, no están
ocultos. El acceso al objeto está restringido sólo a través de una interfaz bien
definida.
El diseño de un programa orientado a objetos contiene, al menos, los siguientes
pasos:
1. Identificar los objetos del sistema.
2. Agrupar en clases a todos objetos que tengan características y comportamiento
comunes.
3. Identificar los datos y operaciones de cada una de las clases.
4. Identificar las relaciones que pueden existir entre las clases.
Un objeto es un elemento individual con su propia identidad; por ejemplo, un libro,
un automóvil. Una clase puede describir las propiedades genéricas de un ejecutivo
de una empresa (nombre, título, salario, cargo...) mientras que un objeto
representará a un ejecutivo específico (Luis Mackoy, director general). En general,
una clase define qué datos se utilizan para representar un objeto y las operaciones
que se pueden ejecutar sobre esos datos. Cada clase tiene sus propias
características y comportamiento; en general, una clase define los datos que se
utilizan y las operaciones que se pueden ejecutar sobre esos datos. Una clase
describe un objeto. En el sentido estricto de programación, una clase es un tipo de
datos. Diferentes variables se pueden crear de este tipo. En programación orientada
a objetos, éstas se llaman instancias. Las instancias son, por consiguiente, la
realización de los objetos descritos en una clase. Estas instancias constan de datos
o atributos descritos en la clase y se pueden manipular con las operaciones
definidas dentro de ellas.
6.- ¿Qué se entiende por estado, comportamiento e identidad en POO?
Un objeto es una unidad dentro de un programa de computadores que consta de un
estado y de un comportamiento, que a su vez constan respectivamente de datos
almacenados y de tareas realizables durante el tiempo de ejecución. Un objeto
puede ser creado instanciando una clase, como ocurre en la programación
orientada a objetos, o mediante escritura directa de código y la replicación de otros
objetos, como ocurre en la programación basada en prototipos.
Estos objetos interactúan unos con otros, en contraposición a la visión tradicional
en la cual un programa es una colección de subrutinas (funciones o procedimientos),
o simplemente una lista de instrucciones para el computador. Cada objeto es capaz
de recibir mensajes, procesar datos y enviar mensajes a otros objetos de manera
similar a un servicio.
Los objetos son entidades que combinan estado (atributo), comportamiento
(método) e identidad:
El estado
Está compuesto de datos, será uno o varios atributos a los que se habrán asignado
unos valores concretos (datos). El estado de un objeto se refiere al conjunto de
atributos y sus valores en un instante de tiempo dado. El comportamiento de un
objeto puede modificar el estado de este. Cuando una operación de un objeto
modifica su estado se dice que esta tiene "efecto colateral".
El comportamiento
Está definido por los procedimientos o métodos con que puede operar dicho objeto,
es decir, qué operaciones se pueden realizar con él.
El comportamiento de un objeto está directamente relacionado con su funcionalidad
y determina las operaciones que este puede realizar o a las que puede responder
ante mensajes enviados por otros objetos. La funcionalidad de un objeto está
determinada, primariamente, por su responsabilidad. Una de las ventajas
fundamentales de la POO es la reusabilidad del código; un objeto es más fácil de
reutilizarse en tanto su responsabilidad sea mejor definida y más concreta.
La identidad
Es una propiedad de un objeto que lo diferencia del resto, dicho con otras palabras,
es su identificador (concepto análogo al de identificador de una variable o una
constante).
La identificación es la propiedad que permite diferenciar a un objeto y distinguirse
de otros. Generalmente esta propiedad es tal, que da nombre al objeto. Tomemos
por ejemplo el "verde" como un objeto concreto de una clase color; la propiedad que
da identidad única a este objeto es precisamente su "color" verde. Tanto es así que
para nosotros no tiene sentido usar otro nombre para el objeto que no sea el valor
de la propiedad que lo identifica.
Un objeto contiene toda la información que permite definirlo e identificarlo frente a
otros objetos pertenecientes a otras clases e incluso frente a objetos de una misma
clase, al poder tener valores bien diferenciados en sus atributos. A su vez, los
objetos disponen de mecanismos de interacción llamados métodos, que favorecen
la comunicación entre ellos. Esta comunicación favorece a su vez el cambio de
estado en los propios objetos. Esta característica lleva a tratarlos como unidades
indivisibles, en las que no se separa el estado y el comportamiento.
Los métodos (comportamiento) y atributos (estado) están estrechamente
relacionados por la propiedad de conjunto. Esta propiedad destaca que una clase
requiere de métodos para poder tratar los atributos con los que cuenta. El
programador debe pensar indistintamente en ambos conceptos, sin separar ni darle
mayor importancia a alguno de ellos. Hacerlo podría producir el hábito erróneo de
crear clases contenedoras de información por un lado y clases con métodos que
manejen a las primeras por el otro. De esta manera se estaría realizando una
programación estructurada camuflada en un lenguaje de programación orientado a
objetos.
La POO difiere de la programación estructurada tradicional, en la que los datos y
los procedimientos están separados y sin relación, ya que lo único que se busca es
el procesamiento de unos datos de entrada para obtener otros de salida. La
programación estructurada anima al programador a pensar sobre todo en términos
de procedimientos o funciones, y en segundo lugar en las estructuras de datos que
esos procedimientos manejan. En la programación estructurada sólo se escriben
funciones que procesan datos. Los programadores que emplean POO, en cambio,
primero definen objetos para luego enviarles mensajes solicitándoles que realicen
sus métodos por sí mismos.
7.-Diagramas UML
UML es un lenguaje gráfico para modelado de programas de computadoras.
“Modelado” significa como su nombre indica, crear modelos o representaciones de
“algo”, como un plano de una casa o similar. UML proporciona un medio de
visualizar la organización de alto nivel de los programas sin fijarse con detenimiento
en los detalles del código real. UML tiene una gran riqueza semántica que lo abstrae
de numerosos aspectos técnicos y ésa es su gran fortaleza. ¿Por qué necesitamos
UML en programación orientada a objetos? En primer lugar, porqué UML nació
como herramientas gráficas y metodologías para implementar análisis y diseño
orientados a objetos y, en segundo lugar, porque en programas grandes de
computadoras es difícil entender el funcionamiento de un programa examinando
sólo su código y es necesario ver cómo se relacionan unas partes con otras.
La parte más importante de UML, al menos a un nivel de iniciación o medio en
programación, reside en un conjunto rico de diagramas gráficos. Diagramas de
clases que muestran las relaciones entre clases, diagramas de objetos que
muestran cómo se relaciona objetos específicos entre sí, diagramas de casos de
uso que muestran cómo los usuarios de un programa interactúan con el programa,
etc. Cuando se modelan clases, UML es de hecho estándar para representaciones
gráficas. UML no es un proceso de desarrollo de software sino, simplemente, un
medio para examinar el software que se está desarrollando. Aunque, al ser un
estándar, UML se puede aplicar a cualquier tipo de lenguaje de programación, está
especialmente adaptado a la POO.
El Lenguaje Unificado de Modelado es el lenguaje estándar de modelado para
desarrollo de sistemas y de software. UML se ha convertido de facto en el estándar
para modelado de aplicaciones software y ha crecido su popularidad en el modelado
de otros dominios. Tiene una gran aplicación en la representación y modelado de la
información que se utiliza en las fases de análisis y diseño. En diseño de sistemas,
se modela por una importante razón: gestionar la complejidad.
Un modelo es una abstracción de cosas reales. Cuando se modela un sistema, se
realiza una abstracción ignorando los detalles que sean irrelevantes. El modelo es
una simplificación del sistema real. Con un lenguaje firmal de modelado, el lenguaje
es abstracto, aunque tan preciso como un lenguaje de programación. Esta precisión
permite que un lenguaje sea legible por la máquina, de modo que pueda ser
interpretado, ejecutado y transformado entre sistemas. Para modelar un sistema de
modo eficiente, se necesita una cosa muy importante: un lenguaje que pueda
describir el modelo.
UML es un lenguaje. Esto significa que tiene tanto sintaxis como semántica y se
compone de: pseudocódigo, código real, dibujos, programas, descripciones. Los
elementos que constituyen un lenguaje de modelado se denominan notación. El
bloque básico de construcción de UML es un diagrama. Existen tipos diferentes,
algunos con propósitos muy específicos (diagramas de tiempo) y algunos con usos
más genéricos (diagramas de clases).

8.- Clase Struct.

Estructuras
Las estructuras son colecciones de variables relacionadas bajo un nombre. Las
estructuras pueden contener variables de muchos tipos diferentes de datos a
diferencia de los arreglos que contienen únicamente elementos de un mismo tipo
de datos. Una estructura es un grupo de variables las cuales pueden ser de
diferentes tipos sostenidas o mantenidas juntas en una sola unidad. La unidad es la
estructura. Una estructura es un tipo de dato definido por el usuario, que se debe
declarar antes de que se pueda utilizar. Una estructura es una colección de uno o
más tipos de elementos denominados miembros, cada uno de los cuales puede ser
un tipo de dato diferente. Puede contener cualquier número de miembros, cada uno
de los cuales tiene un nombre único, denominado nombre del miembro. Los
miembros de las estructuras pueden ser arrays. Del mismo modo que sucede en
otras situaciones, en C++existen dos conceptos similares a considerar, Declaración
y definición.
Definición de estructuras
Una declaración especifica simplemente el nombre y el formato de la estructura de
datos, pero no reserva almacenamiento en memoria. El formato de la declaración
es:
Struct <nombre de la estructura>{
<tipo de dato miembro1> <nombre miembro1>
<tipo de dato miembro2> <nombre miembro2>
...
<tipo de dato miembron> <nombre miembron>
};
Las variables de estructuras se pueden definir de dos formas:
1. Listándolas inmediatamente después de la llave de cierre de la declaración de la
estructura.
2. Listando el tipo de la estructura creada seguida por las variables correspondientes
en cualquier lugar del programa antes de utilizarlas.
A una estructura se accede utilizando una variable o variables que se deben definir
después de la declaración de la estructura. Uso de estructuras en asignaciones.
Como una estructura es un tipo de dato similar a un int o un charse pueden asignar
variables de una estructura a otra entre sí.
Definición de variables de estructura.
Una definición de variable para una estructura dada, crea un área en memoria en
don-de los datos se almacenan de acuerdo al formato estructurado declarado en la
definición de la estructura. Las estructuras son tipos de datos derivados están
construidas utilizando objetos de otros tipos. Considere la siguiente definición de
estructura:
struct ejemplo {
char c;
int i;};
La palabra reservada struct indica se está definiendo una estructura. El identificador
ejemplo es el nombre de la estructura. Las variables declaradas, dentro de las llaves
de la definición de estructura son los miembros de la estructura. Los miembros de
la misma estructura deben tener nombres únicos mientras que dos estructuras
diferentes pueden tener miembros con el mismo nombre. Cada definición de
estructura debe terminar con un punto y coma. La definición de struct ejemplo
contiene un miembro de tipo char y otro de tipo int. Los miembros de una estructura
pueden ser variables de los tipos de datos básicos (int, char, float, etc) o agregados
como ser arreglos y otras estructuras. Una estructura no puede contener una
instancia de sí misma.
Declaramos variables del tipo estructura del siguiente modo:
struct ejemplo e1, a[10];
o alternativamente sin usar la palabra struct:
ejemplo e1, a[10];
Las declaraciones anteriores declaran variables e1 de tipo ejemplo y a de tipo
arreglo de ejemplo de dimensión 10. Se pueden declarar variables de tipo estructura
ejemplo colocando sus nombres a continuación de la llave de cierre de la definición
de estructura y el punto y coma, en el caso anterior:
struct ejemplo {
char c;
int i;} e1, a[10];
1
Una operación valida entre estructuras es asignar variables de estructura a variables
de estructura del mismo tipo. Las estructuras no pueden compararse entre sí. Un
struct es una manera de juntar un grupo de variables en una estructura. Cuando se
crea un struct, se pueden crear varias instancias de este nuevo tipo de variable que
ha inventado.
Como inicializar estructuras
Las estructuras pueden ser inicializadas mediante listas de inicialización como con
los arreglos. Para inicializar una estructura escriba en la declaración de la variable
a continuación del nombre de la variable un signo igual con los inicializadores entre
llaves y separados por coma, por ejemplo:
ejemplo e1 = { ’a’, 10 };
Si en la lista aparecen menos inicializadores que en la estructura los miembros
estantes son automáticamente inicializados a 0. Las variables de estructura también
pueden ser inicializadas en enunciados de asignación asignándoles una variable
del mismo tipo o asignándole valores a los miembros individuales de la estructura.
Podemos inicializar una variable del tipo fecha como sigue:
struct fecha f = {4, 7, 1776, 186, ”Julio”};

Como tener acceso a los miembros de estructuras

Para tener acceso a miembros de estructuras utilizamos el operador punto. El
operador punto se utiliza colocando el nombre de la variable de tipo estructura
seguido de un punto y seguido del nombre del miembro de la estructura. Por
ejemplo, para imprimir el miembro c de tipo char de la estructura e1 utilizamos
el enunciado:

cout<<e1.c<<endl;

Para acceder al miembro i de la estructura e1 escribimos: e1. i En general, un

miembro de una estructura particular es referenciada por una construcción de la
forma:
nombre de estructura. Miembro
Como utilizar estructuras con funciones
Las estructuras pueden ser pasadas a funciones pasando miembros de estructura
individuales o pasando toda la estructura. Cuando se pasan estructuras o miembros
individuales de estructura a una función se pasan por llamada por valor. Para pasar
una estructura en llamada por referencia tenemos que colocar el ’*’ o’&’. Los
arreglos de estructura como todos los demás arreglos son automáticamente
pasados en llamadas por referencia. Si quisiéramos pasar un arreglo en llamada
por valor, podemos definir una estructura con único miembro el array. Una función
puede devolver una estructura como valor.
9-. Strcpy
Si incluimos la biblioteca cstring tendremos acceso a los prototipos de funciones
para el tratamiento de cadenas.
La función strcpy:
C soporta dos métodos para asignar cadenas. Anteriormente cuando se
inicializaban las variables de cadena. La sintaxis utilizada:
char VarCadena [LongCadena] = ConstanteCddena;
Inicializa dos arrays de caracteres con cadenas constantes.
char Cadena[81] = "C maneja eficientemente las cadenas";
char nombre[] = "Luis Martin Cebo";
El segundo método para asignación de una cadena a otra es utilizar la función strcpy
( ) . La función strcpy ( ) copia los caracteres de la cadena fuente a la cadena destino.
La función supone que la cadena destino tiene espacio suficiente para contener toda
la cadena fuente. El prototipo de la función:
char* strcpy(char* destino, const char* fuente);
Una vez definido un array de caracteres, se le asigna una cadena constante.
char nombre [ 411];
strcpy(nombre, "Cadena a copiar") ;
La función strcpy( ) copia "Cadena a copiar" en la cadena nombre y añade un
carácter nulo al final de la cadena resultante.
La función strncpy ( )
El prototipo de la función strncpy es:
char* strncpy(char* destino, const char* fuente, size-t num);
y su propósito es copiar numero caracteres de la cadena fuente a la cadena destino.
La función realiza truncamiento o rellenado de caracteres si es necesario.
Sirve para copiar la cadena cadena2 dentro de cadena1. Devuelve el valor de
cadena1. strcpy recibe dos parámetros: un apuntador a char (modificable), y un
apuntador a char constante. Y devuelve un apuntador a char.
char *strcpy (char *cadena1, const char *cadena2);
//Prototipo de strcpy
En lenguaje C, para asignar una expresión de cadena a un array de caracteres, no
se puede utilizar el operador de asignación (=). Para ello, se puede utilizar la función
strcpy, que está disponible en la biblioteca estándar de C. La sintaxis de una llamada
a strcpy es:
strcpy( <variable_destino>, <cadena_fuente> )
La función strcpy copia el contenido de la <cadena_fuente> en la
<variable_destino>, siendo ésta un array de caracteres.
10.- Desarrolle el concepto de acumuladores y realice el siguiente ejercicio
con una clase para sumar un incremento dado por el usuario, que inicie en un
valor dado por el usuario y un fin dado por el usuario. La clase struct lleva
inicio, fin, incremento y acumulador.
Definición de Acumuladores
En programación, se llama acumulador a una variable cuyo valor se incrementa o
decremento en un valor que no tiene por qué ser fijo (en cada iteración de un bucle).
Un acumulador suele utilizarse para acumular resultados producidos en las
iteraciones de un bucle.
Un acumulador es una variable, no necesariamente entera, pero sí numérica, y cuyo
valor se incrementará dependiendo del problema. Su objetivo es “acumular”, es
decir: acopiar, almacenar, añadir un cierto valor. La diferencia con una variable
cualquiera es que el acumulador agrega un nuevo valor al que ya tiene. (Por lo
general, una operación de asignación “encima” el valor nuevo borrando el valor viejo
de una variable). Es similar al contador, se inicia en cero y en cada repetición se
incrementa en diferentes valores, y al final es que la variable acumula la suma de
los valores añadidos en cada repetición. Un acumulador es una variable, a la cual
le vamos a incrementar su valor de forma variable dentro de un ciclo, para ello, la
variable debe tener un valor inicial antes de entrar al ciclo y debemos incrementar o
decremento su valor dentro del ciclo.
El acumulador debe ser inicializado antes de ser utilizado. Pero el valor de
inicialización dependerá del tipo de operación que nos ayudará a acumular valores:
puede ser el resultado de sumas sucesivas (que es lo más común), pero también
de multiplicaciones, o incluso de restas o divisiones. Se utiliza para efectuar sumas
sucesivas. La principal diferencia con el contador es que el incremento o
decremento de cada suma es variable en lugar de constante como en el caso del
contador.
Es una variable que suma sobre sí misma un conjunto de valores para de esta
manera tener la suma de todos ellos en una sola variable. La diferencia entre un
contador y un acumulador es que mientras el primero va aumentando de uno en
uno, el acumulador va aumentando en una cantidad variable.
Representación: <Nombre del acumulador> ¬ <nombre del acumulador> + <valor
variable.
Contadores
La construcción de un contador es una de las técnicas más comunes en la
realización de diagramas de flujo. Es una variable en la memoria que se
incrementará en una unidad cada vez que se ejecute el proceso. El contador se
utiliza para llevar la cuenta de determinadas acciones que se pueden solicitar
durante la resolución de un problema. En las instrucciones de preparación se realiza
la inicialización del contador o contadores. La inicialización consiste en poner el
valor inicial de la variable que representa al contador. Generalmente se inicializa
con el valor 0.
Cómo usar un acumulador
La variable acumuladora debe aparecer a la derecha y a la izquierda del operador
de asignación
La acumulación se realiza con los operadores aritméticos: +, -, *, /.
Los operadores booleanos y relacionales no pueden ser parte de una expresión de
acumulación, puesto que estos valores no pueden sumarse o multiplicarse.
Se pueden escribir expresiones de acumulación de una forma elegante y corta
utilizando los operadores +=, -=, *= y /=.
En las operaciones de suma y multiplicación no importa si el acumulador no está
exactamente antes y después del operador =, puesto que estas operaciones son
conmutativas. Sin embargo, debes tener mucho cuidado con la resta y la división,
no es lo mismo:
10-3 que 3-10
Inicialización de la variable acumuladora.
Antes de utilizar una expresión de acumulación, es necesario inicializar la variable.
Recuerda que la inicialización de una variable no es más que asignarle un valor de
inicio a la variable. La variable debe tener un valor almacenado antes de poder ser
utilizada.
¿Qué pasa si no se inicializa un acumulador?
En el lenguaje C, si una variable no ha sido inicializada, entonces tiene un valor de
“basura” o “sucio”. Simplemente es el valor de la localidad de memoria que se le
asignó a esta variable. Es casi como si alguien se mudara a un departamento, y
encontrara basura que el ocupante anterior dejó. Así también sucede con los
programas, al terminar de ejecutarse, muy pocos hacen una “limpieza” de las áreas
de memoria que utilizaron.
Programa que Imprime la Suma de una Clase
Código del Programa que Imprime la Suma de una Clase

/*Programa de Imprime la Suma de una Clase*/

//Definicion de Archivos de Cabecera
#include<iostream>
#include<cstdlib>
#include<cstdio>
void datos();
using namespace std;
struct suma{
int inicio;
int fin;
int incremento;
int acomulador;
}suma1;
//Definicion en Implementacion del Programa Principal
int main()
{
datos();
int n;
cout<<"\nIngrese el Valor de Inicio:"<<endl;
cin>>suma1.inicio;
cout<<"Ingrese el Valor de Fin:"<<endl;
cin>>suma1.fin;
cout<<"Ingrese el Valor de Incremento:"<<endl;
cin>>suma1.incremento;
cout<<"n n+n n+n+n"<<endl;
for(n=suma1.inicio;n<=suma1.fin;n=suma1.incremento++)
{
cout<<n<<"\t"<<n+n<<"\t"<<n+n+n<<endl;
cout<<"La Suma es:"<<n+n+n+n+n+n<<endl;
}
}
void datos()
{
cout<<"\nPrograma de Imprime la Suma de una Clase"<<endl;
cout<<"\nNombre:Ramirez Najera Giovanni Agustin"<<endl;
cout<<"\nGrupo:2EV3"<<endl;
cout<<"\nFecha:20/08/2019"<<endl;
}
11.- Desarrolle el concepto de multiplicadores y un ejemplo con clase para
multiplicar un incremento dado por el usuario, que inicie en un valor dado por
el usuario y un fin dado por el usuario.
Definición de Multiplicadores
Cuando la operación de acumulación sea una multiplicación, el valor de
inicialización del acumulador será 1. También, así como con la suma, se usa este
número debido a que es la identidad de la multiplicación, ya que la multiplicación
por 1 no cambia el valor de ningún número, en tanto que la multiplicación por cero
elimina cualquier valor guardado en la variable.
Lo multiplicadores son exactamente lo mismo que los sumadores, la única diferencia
es que las operaciones que utilizamos con ellos, es la multiplicación en lugar de la
suma. El factorial de un número se calcula multiplicando al número mismo con su
antecesor, con el antecesor de su antecesor, y así sucesivamente hasta llegar a 1.
El signo que se usa para el factorial en matemáticas es “!”, y el factorial de 5 por
ejemplo se escribe así “!5”. Esta expresión significa multiplicar 5*4*3*2*1.
El ciclo comienza en el valor que el usuario entre por teclado. Desde ese valor hasta
1, serán las veces que se va a ejecutar su bloque de código. La condición de parada
expresa que el ciclo se va a repetir mientras que el valor de “i” cumpla la condición
“i>1”. Para que el contador no sea mayor que 1, debe, necesariamente, ser menor
o igual que 0, y ni los números menores que el cero ni el cero mismo nos interesan,
pues no entran en la definición del factorial. El bloque de código, que en este caso
es una sola instrucción, hace uso del decremento de la variable contadora para
“capturar” su valor y multiplicárselo al valor que tenga en ese momento el factorial.
Fíjese que la variable “factorial” fue inicializada en 1, pues de inicializarla en cero,
produciría un cero como resultado final, pues todo número multiplicado por cero es
cero. El multiplicador “factorial” ira guardando en cada paso, el valor de la
multiplicación de el mismo y el contador. Terminado el ciclo, la variable “factorial”
queda disponible para imprimir el resultado de la operación.
Programa que Imprime la Multiplicación de una Clase

Código del Programa que Imprime la Multiplicación de una Clase

/*Programa de Imprime la Multiplicacion de una Clase*/

//Definicion de Archivos de Cabecera
#include<iostream>
#include<cstdlib>
#include<cstdio>
void datos();
using namespace std;
struct multiplicacion{
int inicio;
int fin;
int incremento;
int acomulador;
}multiplicacion1;
//Definicion en Implementacion del Programa Principal
int main()
{
datos();
int n;
cout<<"\nIngrese el Valor de Inicio:"<<endl;
cin>>multiplicacion1.inicio;
cout<<"Ingrese el Valor de Fin:"<<endl;
cin>>multiplicacion1.fin;
cout<<"Ingrese el Valor de Incremento:"<<endl;
cin>>multiplicacion1.incremento;
cout<<"n n*n n*n*n"<<endl;
for(n=multiplicacion1.inicio;n<=multiplicacion1.fin;n=multiplicacion1.incremento++)
{
cout<<n<<"\t"<<n*n<<"\t"<<n*n*n<<endl;
cout<<"La Multiplicacion es:"<<n*n*n*n*n*n<<endl;
}
}
void datos()
{
cout<<"\nPrograma de Imprime la Multiplicacion de una Clase"<<endl;
cout<<"\nNombre:Ramirez Najera Giovanni Agustin"<<endl;
cout<<"\nGrupo:2EV3"<<endl;
cout<<"\nFecha:20/08/2019"<<endl;
}
Referencias Bibliográficas
JOYANES AGUILAR, Luis. Fundamentos de programación. Algoritmos, estructuras
de datos y objetos, 3.ª ed., Madrid: McGraw-Hill (2003).
JOYANES AGUILAR, Luis. Programación orientada a objetos, 2.ª ed., Madrid:
McGraw-Hill (2003).
JOYANES, Luis y SÁNCHEZ, Lucas. Programación en C++. Colección Schaum.
Madrid: McGrawHill, 2006.