INSTITUTO POLITÉCNICO NACIONAL

ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICA

INGENIERÍA EN COMUNICACIONES Y ELECTRÓNICA

PROGRAMACIÓN ORIENTADA A
OBJETOS
Ejercicios “Sobre carga de operadores”

Grupo: 2CM26
Integrantes:
- Sanchez Duran José Fernando

Profesor: María Ivonne Gutiérrez Villalba

Fecha: 20/ Abril/ 2020
Ejercicio 1
Creamos una clase llama VECTOR, en los datos públicos de esta clase declaramos
sus métodos (Figura 1.1).

Figura 1.1. Metodos de la clase VECTOR

Como podemos observar, hacemos uso del operator y friend los cuales nos van a
ayudar posteriormente para hacer la sobre carga de operadores al momento de
llamar estas funciones en el main del programa. Declaramos los atributos en los
datos privados de nuestra clase. (Figura 1.2).

Figura 1.2. Atributos de la clase VECTOR

Ahora, en el archivo cpp de nuestra clase VECTOR, definimos el comportamiento
de cada uno de los métodos que anteriormente hemos declarado. Para ello,
inicializamos nuestros atributos en el constructor por omisión (Figura 1.3) y posterior
a ello, creamos nuestro constructor parametrizado (Figura 1.4).

Figura 1.3. Constructor por omisión.

Figura 1.4. Constructor Parametrizado.

Posterior a ello, definimos los métodos suma, resta, multiplicación (punto y por una
constante), los cuales, para el caso de suma, resta y multiplicación por una
constante nos retornara un valor de tipo vector. Para el caso de una multiplicación
punto (Producto escalar o producto punto) esta tendrá que retornar un valor de tipo
flotante, por ello es que se declara como función de tipo float. Además de un método
que imprima el resultado obtenido por cada una de estas funciones. (Figura 1.5).

Figura 1.5. Métodos de la clase VECTOR

Es importante recordar que para lograr la sobre carga de operadores es necesario
implementar las funciones istream y ostream para que, al momento de realizar las
operaciones entre objetos de clases en el main, el programa sea capas de
reconocer estos procesos. Para ello, estas funciones son declaradas de la siguiente
forma. Para el caso de istream (Figura 1.6).

Figura 1.6. Método istream

El método istream como podemos observar, se encarga de un método de entrada
de datos (para que el usuario ingrese los datos solicitados por el programa).
Para el caso de ostream (Figura 1.7). El método ostream como podemos observar,
es un método de salida de datos.
 Figura 1.7. Método ostream
Ahora, en el main de nuestro programa, incluimos la biblioteca “VECTOR.h” y
creamos tres objetos de esta clase (V1, V2 y VR) además de 2 datos tipo float (VR1
y k). (Figura 1.8).

Figura 1.8.
Gracias a la sobre carga de operadores, no es necesario llamar a los métodos de la
clase para que realicen la tarea determinada que realizan, pues estas operaciones
las podemos realizar directamente con nuestros objetos de la clase, y con los
operadores de ingresa “cin” y muestra “cout” (Figura 1.9).

Figura 1.9. Main del programa

Una vez que corremos el programa obtenemos. (Figura 1.10).
 Figura 1.10. Corrida del programa

Ejercicio 2
Realiza la sobrecarga de operadores siguiendo el diseño de la clase complejo, para
realizar la suma, resta, multiplicación y división entre complejos, así como los
operadores de inserción (>>) y extracción (<<).
Para ello, creamos una clase de nombre COMPLEJO, y declaramos los métodos
referentes a esta clase en el archivo .h como ya se mostró anteriormente. Antes de
ello, debemos recordar que los números complejos son aquellos que conforman un
grupo de cifras resultantes de la suma entre un número real y uno de tipo imaginario,
para ello, realizaremos la suma, resta, multiplicación y división de estos números.
Cada operación en un método. Declaramos los métodos en la parte publica de
nuestra clase (Figura 2.1). Además de los atributos de la clase los cuales van en la
parte privada de la clase. (Figura 2.2).

Figura 2.1. Métodos de la clase COMPLEJO

Como podemos observar, hacemos uso de las palabras reservadas operator, friend,
istream y ostream las cuales nos ayudaran a hacer la sobre carga de operadores.

Figura 2.2. Atributos de la clase COMPLEJO.

Posteriormente, en el archivo .cpp normalizamos los atributos en el constructor por
omisión (Figura 2.3), además de definir el constructor parametrizado. (Figura 2.4).

Figura 2.3. Constructor por omisión.

Figura 2.4. Constructor parametrizado.

Ahora, definimos los métodos suma, resta, multiplicación y división entre números
complejos, recordando las reglas matemáticas de estas, los cuales, para los 4
casos, retornan otro numero complejo. (Figura 2.5).

Figura 2.5. Metodos de la clase COMPLEJO

Como ya se comento en el ejercicio 1, es importante declarar las funciones istream
y ostream las cuales son las encargadas de la entrada y salida de datos. (Figura
2.6).
 Figura 2.6. Metodos istream y ostream
Por ultimo, en el main de la funcion, agregamos la biblioteca “COMPLEJO.h” y
creamos 3 objetos de esta clase (COMP1, COMP2, COMPR). (Figura 2.7).

Figura 2.7.
Ahora, solicitamos al usuario ingrese el primer numero complejo con ayuda del
operador cin el cual guarda este dato ingresado por el usaruio y con el operator cout
lo muestra en la pantalla. Como ya se ha comentado, gracias a la osbrecarga de
operadores, podemos obtener el resultado de estas 4 operaciones basicas por
medio de los objetos creados de la clase. (Figura 2.8).
 Figura 2.8.
Una vez que corremos el programa obtenemos (Figura 2.9).
Figura 2.9. Corrida del programa
Ejercicio 3
Realiza la sobrecarga de operadores siguiendo el diseño de la clase FRACCIONAL,
para realizar la suma, resta, multiplicación y división entre fracciones, así como los
operadores de inserción (>>) y extracción (<<).

Para ello, creamos una clase llamada FRACCIONAL, la cual declaramos los
métodos referentes a esta clase en el archivo .h como ya se mostró anteriormente.
Antes de ello, debemos recordar que los números fraccionales son la expresión de
una cantidad dividida entre otra cantidad, estas se componen por un numerador y
un denominador, para ello, realizaremos la suma, resta, multiplicación y división de
estos números. Cada operación en un método. Declaramos los métodos en la parte
publica de nuestra clase (Figura 3.1). Además de los atributos de la clase los cuales
van en la parte privada de la clase. (Figura 3.2).

Figura 3.1. Métodos de la clase FRACCIONAL.

Como podemos observar, hacemos uso de las palabras reservadas operator, friend,
istream y ostream las cuales nos ayudaran a hacer la sobre carga de operadores.
 Figura 3.2. Atributos de la clase FRACCIONAL.
Posteriormente, en el archivo .cpp normalizamos los atributos en el constructor por
omisión (Figura 3.3), además de definir el constructor parametrizado. (Figura 3.4).

Figura 3.3. Constructor por omisión.

Figura 3.4. Constructor parametrizado.

Ahora, definimos los métodos suma, resta, multiplicación y división entre fracciones,
recordando las reglas matemáticas de estas, los cuales, para los 4 casos, retornan
otro número fraccional compuesta por dos partes: numerador y denominador.
(Figura 3.5).
 Figura 3.5. Métodos de la clase FRACCIONAL
Como ya se ha momentado en los ejercicios anteriores, es importante declarar las
funciones istream y ostream los cuales son los encargados de la entrada y salida
de datos. (Figura 3.6).

Figura 3.6. Funciones istream y ostream.

Por ultimo, en el main de la funcion, agregamos la biblioteca “FRACCIONAL.h” y
creamos 3 objetos de esta clase (F1, F2, FR). (Figura 3.7).

Figura 3.7.
Ahora, solicitamos al usuario ingrese la primer fraccion ingresando el numerador y
posterior a ello el denominador con ayuda del operador cin el cual guarda este dato
ingresado por el usaruio y con el operator cout lo muestra en la pantalla. Como ya
se ha comentado, gracias a la sobrecarga de operadores, podemos obtener el
resultado de estas 4 operaciones basicas por medio de los objetos creados de la
clase. (Figura 3.8).
 Figura 3.8.
Una vez que corremos el programa obtenemos (Figura 3.9).

Figura 3.9