Programación II.

Guía 8 1

Facultad: Ingeniería
Escuela: Computación
Asignatura: Programación II

Tema: Sobrecarga de Operadores Unarios.

Sobrecarga de Funciones.

Objetivos

ƒ Diferenciar sobrecarga de operadores binarios y unarios.

ƒ Identificar cuando sobrecargar operadores.
ƒ Implementar programas en C++ que sobrecarguen operadores unarios.
ƒ Implementar programas en C++ que incluya sobrecarga de funciones

Materiales y Equipo

• Computadora con el software DevC++

• Guía Número 8

Introducción

Sobrecarga de operadores unarios.

Se conocen también como operadores unitarios.
Un operador unitario es un operador que tiene un único operando, en otras palabras, es aquel
que actúa sobre un único operando. El operador “++”, por ejemplo es unario.
Recordemos que los operadores unarios susceptibles de sobrecarga son:
• Operadores unarios + y -
• Operadores unarios de incremento ++ y decremento --
• Operadores de puntero: referencia & e indirección *
• Operador de manejo de bits ("bitwise") complemento a uno ~
• Operador de negación lógica !
• Asignación y desasignación dinámica de memoria: new y delete

Consideremos una clase de tipo T y un objeto X de tipo T.

Se define un operador unitario sobrecargado “++”, entonces:
 2 Programación II, Guía 8

++X se interpreta como: operator ++ (X)

ó como: X.operator ++ ( )

Un operador unario se puede definir así:

• Como una función de un argumento
• Como una función miembro sin argumento (el caso más frecuente)
• Nunca las dos a la vez.

Sobrecarga de funciones o métodos.

La sobrecarga de funciones es el proceso de definir dos o más funciones, con el mismo
nombre, que difieren únicamente en los parámetros que requieren y en el tipo de resultado
que generan.
Este tipo de sobrecarga resulta ser una poderosa herramienta de programación. Sin embargo,
debe ser cuidadoso su uso ya que si se utiliza excesivamente el programa podría resultar poco
legible. Además, es importante considerar que no es posible definir dos funciones que difieran
sólo en el tipo de resultado. Deben hacerlo también en la lista de parámetros.

¿Cómo determina C++ la función sobrecargada correcta?

Lo determina en base al número y tipo de parámetros pasados a la función sobrecargada. C++
requiere que al menos uno de los parámetros tenga un tipo diferente del que utilizan otras
funciones. Por consiguiente, es válido declarar dos funciones sobrecargadas, tales como:
int F (int a, int b, int c);
int F (int a, int b, float c);

C++ puede llamar a ambas funciones, ya que al menos uno de los valores de los parámetros
tiene un tipo diferente. Sin embargo, si se intenta escribir una función sobrecargada que tenga
tipos similares, C++ emitirá un error. Por ejemplo, las definiciones siguientes no se compilarán,
ya que el compilador no diferenciará una de otra:
int F (int a, int b, int c);
int F (int a, int b, int c);
 Programación II. Guía 8 3
La sobrecarga de funciones es un tipo específico de polimorfismo. El polimorfismo es una de
las características fundamentales de la programación orientada a objetos.
Las reglas que sigue C++ para seleccionar una función sobrecargada son:
• Si existe una correspondencia exacta entre los tipos de parámetros de la función
llamadora y una función sobrecargada, se utiliza dicha función.
• Si no existe una correspondencia exacta, pero sí se produce la conversión de un tipo a
un tipo superior (tal como un parámetro int a long, o un float a un double) y se produce,
entonces, una correspondencia, se utilizará la función seleccionada.
• Si una función sobrecargada se define con un número variable de parámetros
(mediante el uso de puntos suspensivos […]), se puede utilizar como una coincidencia
potencial.

Procedimiento

Ejemplo 1:
Los operadores de incremento y decremento suelen ser muy útiles en aplicaciones de tiempo
o conteo.
En el siguiente ejemplo, se muestra una clase Punto con operadores ++ y - - sobrecargados y
con notaciones prefija y postfija, que realiza incrementos y decrementos de las coordenadas
de cada punto.

#include <iostream>

using namespace std;

class Punto // Definición de la clase Punto

{ private:
int CoordX; // coordenada en eje x del punto
int CoordY; // coordenada en eje y del punto

public:
Punto( );
Punto(int ValX, int ValY);
~Punto( ){ };
void FijarX (int ValX);
void FijarY (int ValY);
int LeerX( );
int LeerY( );
4 Programación II, Guía 8

/* Funciones para sobrecargar operadores de incremento y decremento en forma

prefija y postfija */
Punto & operator ++( );
Punto operator ++ (int);
Punto & operator --( );
Punto operator -- (int);
};
// Forma prefija
// Forma postfija
// Forma prefija
// Forma postfija

// Definición de funciones miembro

Punto::Punto( )
{ CoordX = 0;
CoordY = 0;
}

Punto::Punto(int ValX, int ValY)

{ FijarX(ValX);
FijarY(ValY);
}

int Punto::LeerX( )
{ return CoordX;
}

int Punto::LeerY( )
{ return CoordY;
}

void Punto::FijarX(int ValX)

{ CoordX = ValX;
}

void Punto::FijarY(int ValY)

{ CoordY = ValY;
}

// Sobrecarga de operador de incremento forma prefija (++p)

Punto & Punto::operator ++( )
{ CoordX += 1;
CoordY += 1;
return *this;
}

// Sobrecarga de operador de incremento forma postfija (p++)

Punto Punto::operator ++(int)
{ CoordX += 1;
CoordY += 1;
return Punto(CoordX - 1, CoordY - 1);
}
 Programación II. Guía 8 5

// Sobrecarga de operador de decremento forma prefija (--p)

Punto & Punto::operator --( )
{ CoordX -= 1;
CoordY -= 1;
return *this;
}

// Sobrecarga de operador de deremento forma postfija (p--)

Punto Punto::operator --(int)
{ CoordX -= 1;
CoordY -= 1;
return Punto(CoordX + 1, CoordY + 1);
}

int main()
{ Punto P(5, 7);
Punto Q(1, 2);
Punto R;

cout << “Las coordenadas del punto P son ( " << P.LeerX() << " , " << P.LeerY() << " )"
<< endl;
cout << "Las coordenadas del punto Q son ( " << Q.LeerX() << " , " << Q.LeerY() << "
)" << endl;

R = ++P;
cout << endl << "Las coordenadas del punto ++P son ( " << R.LeerX() << " , " <<
R.LeerY() << " )" << endl;

R = Q++;
cout << endl << "Las coordenadas del punto Q++ son ( " << R.LeerX() << " , " <<
R.LeerY() << " )" << endl;

R = --Q;
cout << endl << "Las coordenadas del punto --Q son ( " << R.LeerX() << " , " <<
R.LeerY() << " )" << endl;

R = P--;
cout << endl << "Las coordenadas del punto P-- son ( " << R.LeerX() << " , " <<
R.LeerY() << " )" << endl;

cout << endl << "Las coordenadas finales del punto P son ( " << P.LeerX() << " , " <<
P.LeerY() << " )" << endl;
cout << endl << "Las coordenadas finales del punto Q son ( " << Q.LeerX() << " , " <<
Q.LeerY() << " )" << endl;

system("pause>nul");
return 0;
}
 6 Programación II, Guía 8

Ejemplo 2:
En este ejemplo se sobrecarga una función de nombre Prueba para realizar tres
operaciones totalmente diferentes.

#include <iostream>

using namespace std;

// Prototipos de las funciones sobrecargadas

int Prueba(int);
int Prueba(int, int);
float Prueba(float, float);

int main()
{ int indice = 7;
int x = 4, y = 5;
float a= 6.5, b = 18.3;

cout << "El cuadrado de " << indice << " es: " << Prueba(indice) << endl;
cout << endl << "El producto de " << x << " por " << y << " es: " << Prueba(x,y) <<
endl;
cout << endl << "La media de " << a << " y " << b << " es: " << Prueba(a, b) << endl;

system("pause>nul");
return 0;
}

// Definición de las funciones sobrecargadas

int Prueba(int valor) // La función Prueba calcula el cuadrado de un número

entero
{ return (valor * valor);
}

int Prueba(int valor1, int valor2) // La función Prueba multiplica dos números enteros
{ return (valor1 * valor2);
}

float Prueba(float valor1, float valor2) // La función Prueba calcula la media de dos
números reales
{ return ((valor1 * valor2)/2);
}
 Programación II. Guía 8 7

Análisis de Resultados
Ejercicio 1:

Con la clase Fecha proporcionada, crear un programa que utilice operadores de preincremento
y postdecremento sobrecargados para sumar 1 al día en un objeto de tipo fecha, mientras que
produce incrementos apropiados en el mes y el año, en caso de ser necesario. Además deben
sobrecargarse el operador “+” para incrementar un número “n” de días a una determinada
fecha; y el operador de flujos de salida para poder mostrar los objetos de tipo Fecha.
Debe validarse los años bisiestos.
La solución se debe manejar a través de un menú que contenga las siguientes opciones:
a) Crear los objetos de tipo Fecha, solicitando los datos al usuario.
b) Incrementar una fecha en un valor de “n” días.
c) Prueba del operador preincremento.
d) Prueba del operador postincremento.
e) Salir de la aplicación.

El menú deberá estar siempre activo, en la misma posición en pantalla, hasta que el usuario
seleccione la opción salir.
El programa debe estar debidamente comentado.
class Fecha
{ private:
int dia, mes, year;
public:
Fecha(int d = 1, int m = 1, int y = 1900); // constructor predeterminado
~Fecha( ) { };
void SetFecha(int, int, int); // Para establecer día, mes y año
bool yearBisiesto(int); // Para verificar si la fecha es un año bisiesto
bool findemes(int); // Para verificar si la fecha está en el fin de mes

// Sobrecarga de operadores
Fecha & operador ++( ); //Sobrecarga operador preincremento
Fecha operador ++( ); //Sobrecarga operador postincremento
Fecha & operador +(int); //Sobrecarga operador + para sumar “n “ días al objeto
 8 Programación II, Guía 8

friend ostream & operador << (ostream &, const Fecha &); // Sobrecarga operador de
// flujo de salida
};

Ejercicio 2:

Crear un programa que incluya dos funciones sobrecargadas:

Max: que permitirá encontrar el máximo entre dos números que pueden ser del tipo entero o
real de precisión doble.
Raiz: que permitirá calcular la raíz cuadrada de un número que puede ser del tipo entero o
real de precisión doble.
La funcionalidad debe implementarse con un menú con las siguientes opciones:
Opción de menú 1: Encontrar el máximo de dos números introducidos por el usuario.
Opción de menú 2: Calcular la raíz cuadrada de un número introducido por el usuario.
Opción de menú 3: Salir del programa.

El menú deberá estar siempre activo, en la misma posición en pantalla, hasta que el usuario
seleccione la opción salir.
El programa debe estar debidamente comentado.
 Programación II. Guía 8 9

Guía 8: Sobrecarga de Operadores Hoja de cotejo: 8

Unarios. Sobrecarga de Funciones.

Alumno: Máquina No:

Docente: GL: Fecha:

EVALUACIÓN

% 1-4 5-7 8-10 Nota

CONOCIMIENTO Del 20 Conocimiento Conocimiento Conocimiento

al 30% deficiente de y explicación completo y
los fundamentos incompleta de explicación
teóricos los clara de los
fundamentos fundamentos
teóricos teóricos
APLICACIÓN Del 40%
DEL al 60%
CONOCIMIENTO

ACTITUD
Del 15% No tiene Actitud Tiene actitud
al 30% actitud propositiva y proactiva y
proactiva. con sus
propuestas no propuestas
aplicables al son
contenido de concretas.
la guía.
TOTAL 100%