ESCUELA SUPERIOR POLITÉCNICA DE CHIMBORAZO

FACULTAD: INFORMÁTICA Y ELECTRÓNICA

ESCUELA DE INGENIERÍA EN SISTEMAS
CARRERA: SOFTWARE

GUÍA DE LABORATORIO DE EL PARADIGMA ORIENTADO A OBJETOS

PRÁCTICA No. 02 –SOBRECARGA DE OPERADORES

1. DATOS GENERALES:

NOMBRE DEL ESTUDIANTE CODIGO DE ESTUDIANTE

JONATHAN PULLUTASIG 64-65

SEMESTRE:
SEGUNDO “A”

FECHA DE REALIZACIÓN: FECHA DE ENTREGA:

2018/12/18 2018/12/19
 2. OBJETIVO(S):

2.1. GENERAL
Realizar una investigación sobre la sobrecarga de operadores su definición, así como sus
características y las ventajas al usar esto en la Poo

2.2. ESPECÍFÍCOS
Realizar sobrecargas de operadores, de modo que una misma función se puede comportar de
formas distintas

mejorar la legibilidad de los programas

3. METODOLOGÍA
Mediante el uso de sobrecarga de operadores que son mecanismos que permiten al
programador ampliar las capacidades de los lenguajes de programación orientados a
objetos así como las distintas formas que puede comportarse una función

4. EQUIPOS Y MATERIALES:

- Computador
- Compilador de C++
- Entorno integrado de desarrollo (IDE)
- Aula virtual
- Acceso a internet
- Bibliografía

5. MARCO TEORICO:
El lenguaje c++
C++ es un lenguaje de programación diseñado en 1979 por Bjarne Stroustrup. La intención de su
creación fue extender al lenguaje de programación C mecanismos que permiten la manipulación
de objetos. En ese sentido, desde el punto de vista de los lenguajes orientados a objetos, el C++
es un lenguaje híbrido.

6. PROCEDIMIENTO:

Qué es Polimorfismo
En programación orientada a objetos el polimorfismo se refiere a la posibilidad de definir clases
diferentes que tienen métodos o atributos denominados de forma idéntica, pero que se comportan
de manera distinta. El concepto de polimorfismo se puede aplicar tanto a funciones como a tipos
de datos. Así nacen los conceptos de funciones polimórficas y tipos polimórficos. Tipos de
polimorfismo

Polimorfismo de sobrecarga

El polimorfismo de sobrecarga ocurre cuando las funciones del mismo nombre existen, con
funcionalidad similar, en clases que son completamente independientes una de otra (éstas no
tienen que ser clases secundarias de la clase objeto). Por ejemplo, la clase complex, la clase
image y la clase link pueden todas tener la función "display". Esto significa que no necesitamos
preocuparnos sobre el tipo de objeto con el que estamos trabajando si todo lo que deseamos es
verlo en la pantalla.

Por lo tanto, el polimorfismo de sobrecarga nos permite definir operadores cuyos

comportamientos varían de acuerdo a los parámetros que se les aplican. Así es posible, por
ejemplo, agregar el operador + y hacer que se comporte de manera distinta cuando está haciendo
referencia a una operación entre dos números enteros (suma) o bien cuando se encuentra entre
dos cadenas de caracteres (concatenación).

7. CONCLUSIONES Y RECOMENDACIONES:

El uso de la sobrecarga dentro de las técnicas polimórficas es muy necesario para poder
realizar una función se comporte de manera diferente con esto se puede ahorras recursos
y optimizar el tiempo

8. BIBLIOGRAFÍA:

https://www.ecured.cu/Polimorfismo_(Inform%C3%A1tica)

http://www.aprendeaprogramar.com/mod/resource/view.php?id=173

ANEXOS (adjuntar el código fuente del programa desarrollado)

Ejemplo de sobrecarga

sobrec02.cpp
3: //
4: // Introduccion a C++
5: // Sobrecarga de operadores: ejemplo
6: // Probado con TC++ (MsDos)
7: //
8: // Curso de C
9: // Jose Ignacio Cabanes
10: //
11: /////////////////////////////////////////////
12:
13: #include <iostream.h>
14:
15: // ---------------------------------------------------------
16: // CLASE : NVector
17: // Vector, determinado por las dos coordenadas de su
18: // extremo (se supone su origen en el origen de
19: // coordenadas)
20: // ---------------------------------------------------------
21:
22: class NVector {
23:
24: int coordX, coordY; // Coordenadas del extremo del vector
25:
26: public:
27:
28: NVector() { coordX = 0; coordY = 0; } // Constructor
29:
30: int LeerX(); // Leer valores y fijarlos
31: int LeerY();
32: void FijarX( int valor );
33: void FijarY( int valor );
34:
35: void Mostrar(); // Mostrar en pantalla: (x,y)
36: NVector operator+( NVector v2 ); // Sumar otro vector a "šste
37: };
38:
39: //
==================================================================
========
40:
41: //
42: // A continuación viene el desarrollo de las funciones (métodos)
43: //
44: // ========
45:
46: /* ----------------- NVector ------------------------------- */
47: /* Leer los valores de las coordenadas */
48: /* _________________________________________________________ */
49:
50: int
51: NVector::LeerX() {
52: return coordX;
53: }
54:
55: int
56: NVector::LeerY() {
57: return coordY;
58: }
59:
60:
61: /* ----------------- NVector ------------------------------- */
62: /* Fijar los valores de las coordenadas */
63: /* _________________________________________________________ */
64:
65: void
66: NVector::FijarX( int valor ) {
67: coordX = valor;
 68: }
69:
70: void
71: NVector::FijarY( int valor ) {
72: coordY = valor;
73: }
74:
75:
76: /* ----------------- NVector ------------------------------- */
77: /* Otras: mostrar y sumar */
78: /* _________________________________________________________ */
79:
80: void
81: NVector::Mostrar() {
82: cout << "(" << coordX << "," << coordY << ")\n";
83: }
84:
85: NVector
86: NVector::operator +( NVector v2 ) {
87: NVector temporal;
88:
89: temporal.coordX = coordX + v2.coordX;
90: temporal.coordY = coordY + v2.coordY;
91:
92: return temporal;
93: }
94:
95:
96:
97:
98:
99: //
==================================================================
========
100: //
101: // Finalmente: un programa sencillo de ejemplo
102: //
103: // ========
104:
105: NVector vec1, vec2; // Definimos dos objetos de la clase "NVector"
106:
107: main() {
108: vec1.FijarX(3); vec1.FijarY(2);
109: vec1.Mostrar();
110:
111: vec2.FijarX(5); vec2.FijarY(4);
112: vec2.Mostrar();
113:
114: vec1 = vec1 + vec2;
115: vec1.Mostrar();
116: return 0;
117: }
No parece difícil, ¿verdad? Lo único que hemos hec