UNIVERSIDAD TÉCNICA DEL NORTE

FACULTAD DE INGENIERÍA EN CIENCIAS APLICADAS

INGENIERÍA INDUSTRIAL

“COMPUTACIÓN”

GRUPO: # 4

DOCENTE: Ing. Danilo Rosero

TEMA

PROPIEDADES- REDEFINICIÓN DE OPERADORES

NOMBRE: CRISTIAN MORALES

CARLOS TEANGA

ANDRÉS NARVÁEZ

BAYRON GREFA

07-07-2016

Al igual que sucede con las funciones, en C++ los operadores también pueden
sobrecargarse.

En realidad la mayoría de los operadores en C++ ya están sobrecargados. Por ejemplo el

operador + realiza distintas acciones cuando los operandos son enteros, o en coma
flotante. En otros casos esto es más evidente, por ejemplo el operador * se puede usar
como operador de multiplicación o como operador de indirección.
C++ permite al programador sobrecargar a su vez los operadores para sus propios usos o
para sus propios tipos.

Sintaxis:

Prototipo:

<tipo> operator <operador> (<argumentos>);

Definición:

<tipo> operator <operador> (<argumentos>)

{
<sentencias>;
}

También existen algunas limitaciones para la sobrecarga de operadores:

 Se pueden sobrecargar todos los operadores excepto ".", ".*", "::" y "?:".
 Los operadores "=", "[]", "->", "()", "new" y "delete", sólo pueden ser
sobrecargados cuando se definen como miembros de una clase.
 Los argumentos deben ser tipos enumerados o estructurados: struct,
union o class.
 El número de argumentos viene predeterminado dependiendo del
operador.
 Operadores binarios
 ^
 Antes de nada, mencionar que el tipo del valor de retorno y el de los parámetros
no está limitado. Aunque la lógica de cada operador nos imponga ciertos tipos,
hay que distinguir entre las limitaciones y obligaciones del lenguaje y las de las
operaciones que estemos programando.
 Por ejemplo, si queremos sobrecargar el operador suma para complejos,
tendremos que sumar dos números complejos y el resultado será un número
complejo.
 Sin embargo, C++ nos permite definir el operador suma de modo que tome un
complejo y un entero y devuelva un valor en coma flotante, por ejemplo.
 Las limitaciones de C++ para operadores binarios es que uno de los parámetros
debe ser de tipo estructura, clase o enumerado y que debe haber uno o dos
parámetros.
 Esta flexibilidad nos permite definir operadores que funcionen de forma
diferente dependiendo de los tipos de los operandos. Podemos, por ejemplo, para
los números complejos definir un operador que de resultados diferentes si se
suma un complejo con un entero o con un número en coma flotante o con otro
complejo.
  Ejemplo:

 /* Definición del operador + para complejos */

 complejo operator +(complejo a, complejo b) {
 complejo temp = {a.a+b.a, a.b+b.b};
 return temp;
 }

 /* Definición del operador + para un complejo y un float */
 complejo operator +(complejo a, float b) {
 complejo temp = {a.a+b, a.b};
 return temp;
 }

 /* Definición del operador + para un complejos y un entero (arbitrariamente) */
 int operator +(complejo a, int b) {
 return int(a.b)+b;
 }
Al igual que con las funciones sobrecargadas, la versión del operador que se usará se
decide durante la fase de compilación, después del análisis de los argumentos.

Operadores unitarios
^
También es posible sobrecargar los operadores de preincremento, postincremento,
predecremento y postdecremento.
De hecho, es posible sobrecargar otros operadores de forma unitaria, como el +, -, * o &
de forma prefija.
En estos casos, el operador sólo afecta a un operando. Veamos primero los de prefijos:
Forma prefija

/* Definición del operador ++ prefijo para complejos */

complejo operator ++(complejo &c) {
c.a++;
return c;
}

Evidentemente, el operador afecta al operando, modificando su valor, por lo tanto,

tendremos que pasar una referencia.
Hemos definido el operador de preincremento para complejo de modo que sólo se
incremente la parte real, dejando la imaginaria con el mismo valor.
Forma sufija
En el caso de los operadores sufijos tenemos un problema. El operador es el mismo, por
lo tanto, no hay forma de distinguir qué versión estamos sobrecargando. Lo que está
claro es que la definición anterior corresponde a la versión prefija, ya que el valor del
operando cambia antes de que se evalúe cualquier expresión donde aparezca este
operador:

complejo a, b, c;
...
c = ++a + b;

El valor de a cambia antes de que se calcule el valor de c.

Para resolver este inconveniente se creó una regla arbitraria que consiste en añadir un
parámetro de tipo int a la declaración del operador, cuando se trate de la versión sufija:
/* Definición del operador ++ sufijo para complejos */
complejo operator ++(complejo &c, int) {
complejo temp = {c.a, c.b};
c.a++;
return temp;
}

Vemos que este segundo parámetro no se usa, de hecho, ni siquiera le asignamos un

identificador. Sólo sirve para que el compilador sepa que estamos definiendo (o en el
caso de un prototipo, declarando) la versión sufija del operador.
La forma de definir estos operadores es siempre similar, si es que queremos mantener
un funcionamiento análogo al predefinido, claro:
 Creamos un objeto temporal copia del valor inicial.
 Modificamos el valor del objeto, que como lo hemos recibido por
referencia, mantendrá el valor al regresar.
 Retornamos el objeto temporal.
De este modo, el valor del objeto será modificado, pero en la expresión donde aparezca
se tomará el valor antes de modificarse.
Ejemplo completo:

// Sobrecarga de operadores
// (C) 2009 Con Clase
// Salvador Pozo

#include <iostream>
using namespace <i>std</i>;

struct complejo {
float a,b;
};

/* Prototipo del operador + para complejos */

complejo operator +(complejo a, complejo b);
/* Prototipo del operador ++ prefijo para complejos */
complejo operator ++(complejo &a);
/* Prototipo del operador ++ sufijo para complejos */
complejo operator ++(complejo &a, int);

void Mostrar(complejo);

int main() {
complejo x = {10,32};
complejo y = {21,12};

complejo z;
/* Uso del operador sobrecargado + con complejos */
z = x + y;
cout << "z = (x + y) = ";
Mostrar(z);
cout << "++z = ";
Mostrar(++z);
cout << "z++ = ";
Mostrar(z++);
cout << "z = ";
Mostrar(z);

return 0;
}

/* Definición del operador + para complejos */

complejo operator +(complejo a, complejo b) {
complejo temp = {a.a+b.a, a.b+b.b};
return temp;
}

/* Definición del operador ++ prefijo para complejos */

complejo operator ++(complejo &c) {
c.a++;
return c;
}

/* Definición del operador ++ sufijo para complejos */

complejo operator ++(complejo &c, int) {
complejo temp = {c.a, c.b};
c.a++;
return temp;
}

void Mostrar(complejo c) {
cout << "(" << c.a << "," << c.b << ")" << endl;
}

La salida de este programa es la siguiente:

z = (x + y) = (31,44)
++z = (32,44)
z++ = (32,44)
z = (33,44)

Operador de asignación
^
Consideremos un caso hipotético.
Tenemos una estructura donde uno de los miembros es un puntero que apuntará a una
zona de memoria obtenida dinámicamente, y trabajaremos con esos objetos en nuestro
programa:

#include <iostream>
using namespace std;

struct tipo {
int *mem;
};

int main() {
tipo a, b;

a.mem = new int[10];

for(int i = 0; i < 10; i++) a.mem[i] = 0;

b = a; // (1)

cout << "b: ";

for(int i = 0; i < 10; i++) cout << b.mem[i] << ",";
cout << endl;

b.mem[2] = 1; // (2)

cout << "a: ";

for(int i = 0; i < 10; i++) cout << a.mem[i] << ",";
cout << endl;
cout << "b: ";
for(int i = 0; i < 10; i++) cout << b.mem[i] << ",";
cout << endl;

delete[] a.mem;
// delete[] b.mem; // (3)
return 0;
}

Veamos la salida de este programa:

b: 0,0,0,0,0,0,0,0,0,0,
a: 0,0,1,0,0,0,0,0,0,0,
b: 0,0,1,0,0,0,0,0,0,0,

¿Notas algo extraño?

En (2) hemos modificado el valor de la posición 2 del vector mem del objeto b. Sin
embargo, cuando mostramos los valores de los dos vectores, a yb, vemos que se han
modificado las posiciones 2 en ambos. ¿por qué?
La respuesta está en la línea (1). Aquí hemos asignado a b el valor del objeto a. Pero,
¿cómo funciona esa asignación?
Evidentemente, se copian los valores de los campos de la estructura a en la estructura b.
El problema es que mem es un puntero, y lo que copiamos es una dirección de memoria.
Es decir, después de la asignación, a.mem y b.mem apuntan a la misma dirección de
memoria, por lo tanto, las modificaciones que hagamos en uno de los objetos, se
reflejan en ambos.
El mayor peligro está en sentencias como la (3), donde podríamos intentar liberar una
memoria que ya ha sido liberada al hacerlo con el objeto a.
Pero estaremos de acuerdo en que este no es el comportamiento deseado cuando se
asigna a un objeto el valor de otro. En este caso esperaríamos que las modificaciones
en a y b fueran independientes.
El origen de todo está en que hemos usado el operador de asignación sin haberlo
sobrecargado. El compilador no se ha quejado, porque este operador se define
automáticamente para cualquier tipo declarado en el programa, pero la definición por
defecto es copiar los valores de toda la memoria ocupada por el objeto, sin discriminar
tipos, ni tener en cuenta si se trata de punteros o de otros valores.
Lo normal sería que pudiéramos sobrecargar el operador de asignación, y evitar estas
situaciones. De hecho, deberíamos poder hacerlo siempre que vayamos a usarlo sobre
objetos que contengan memoria dinámica.
Lamentablemente, no se puede sobrecargar este operador fuera de una clase (veremos
que sí se puede hacer esto con clases en el capítulo 35).
Pero entonces, ¿qué hacemos con este problema? La solución es sustituir el operador de
asignación por una función

// Asignación de arrays
// (C) 2009 Con Clase
// Salvador Pozo
#include <iostream>
using namespace std;

struct tipo {
int *mem;
};

void asignar(tipo&, tipo&);

int main() {
tipo a, b;

a.mem = new int[10];

b.mem = 0;

for(int i = 0; i < 10; i++) a.mem[i] = 0;

asignar(b, a);

cout << "b: ";

for(int i = 0; i < 10; i++) cout << b.mem[i] << ",";
cout << endl;

b.mem[2] = 1;

cout << "a: ";

for(int i = 0; i < 10; i++) cout << a.mem[i] << ",";
cout << endl;
cout << "b: ";
for(int i = 0; i < 10; i++) cout << b.mem[i] << ",";
cout << endl;

delete[] a.mem;
delete[] b.mem;
return 0;
}

void asignar(tipo &a, tipo &b) {

if(&a != &b) {
if(a.mem) delete[] a.mem;
a.mem = new int[10];
for(int i = 0; i < 10; i++) a.mem[i] = b.mem[i];
}
}
Notación funcional de los operadores
^
Los operadores sobrecargados son formas alternativas de invocar a ciertas funciones, de
modo que sean más fácilmente interpretables.
Tanto es así que para cada operador es posible usarlos en su forma de función, esta
forma de usar los operadores se conoce como notación funcional:
z = operator+(x,y);