2014-05-17T10:18:00.000-07:00

SOBRE CARGAS DE OPERADORES

C++ permite sobrecargar operadores como parte de una definición de clase si se sobre carga un operador para una clase, este se utilizara con objetos de este tipo de clases. Utilizar un objeto con operador con los objetos de una clase que no tenga sobrecargado el operador producirá un error introducido y no conocera como utilizar el operador definido por el usuario.

OPERADOR DE IGUALDAD: OPERATOR== ( )

Los operadores sobrecargados tienen siempre el nombre de operatorop donde op indica el operador de C++. Por ejemplo:

La función operator==( ) es un operador sobrecargado que sobrecarga al valor de igualdad (= =).

Se puede sobrecargar cualquier operador de C++ excepto el operador ., el operador ?:, el operador : : y el operador sizeof.

Nota.

El operador sobrecargado debe utilizar el mismo número de operandos que el operador de C++.

No se puede cambiar la procedencia o la asociatividad del operador.

Tampoco se pueden crear nuevos operadores o cambiar el significado de los operadores C++.

En un programa de C++ se llama al operador sobrecargado cuando se utiliza el símbolo del operador con operandos que son objetos. El código siguiente muestra la utilización del operador = = sobrecargado con los objetos Video como operandos.

if (video1 = = video2)

Cuando C++ encuentra el operador = = sobrecargado, los dos objetos se utilizan de la forma siguiente: el objeto situado a la izquierda del operador es el objeto llamado y el objeto situado a la derecha del operador es el que se pasa a la función operator = =( ) como un argumento. Por tanto, la sentencia del ejemplo de código previo es equivalente a la sentencia de C++ siguiente:

Video1.operator==(video2);

El valor devuelto por un operador sobrecargado es el valor de la expresión. Por ejemplo, la función operator == () devuelve un valor de 1 (true) o 0 (false).

OPERADOR DE ASIGNACIÓN: OPERADOR=()

Nos dice que cuando el operador de asignación(=) se sobrecarga para la clase video, las sentencias de C++ como video1 = video2; deberán copiarse todos los datos miembro del objeto video2 a los datos miembros del objeto video1.

También nos dice que las expresiones de asignación devuelven el valor que se asigna a la variable en la parte izquierda del operador de asignación. Para mantener la coherencia, cuando se sobre carga el operador de asignación en una clase, debe crearse una función operator= () que devuelve una referencia al objeto situado en la parte izquierda del operador. Por ejemplo, la sentencia video1 =video2; debe devolver un puntero (o una referencia) al objeto video1; para hacerlo, la función operator= () devuelve * this. El puntero this que proporcionan C++ siempre apunta al objeto al que se llama. En la sentencia video1 = video2; el objeto situado en la parte izquierda del operador=(). Poe lo tanto el valor de this es la dirección del objeto video1 y el valor de* this es el propio objeto video1 (es el objeto al que se le llama).

El ejemplo del 2-12 nos dice que muestra el archivo modificado video.h donde se ha añadido el operador sobrecargado operator=() a la definición de clase video.

EJEMPLO 2-12

//video.h

#ifndef VIDEO_H

#define VIDEO_H

Class Video

{

Public:

Video(); //Constructor por defecto.

Video(char*); //Un argumento.

Video(char*, char*); //Tres argumentos.

Video(char*, char*, short); //Constructor copia.

Video(); //Destructor.

//Operator de igualdad sobrecargado.

Int operator==(Video&);

//Operator de asignación sobrecargado.

Video& operator =(Video&);

voidprint();

constchar* get_name();

constchar* get_producer();

shortget_quantity();

private:

//namees ahora un puntero a carácter:

char* name;

//producer es ahora un puntero con carácter.

char* producer:

shortquantity;

};

#endif

OPERADORES MATEMATICOS SOBRECARGADOS

Al igual que C++, C# permite sobrecargar operadores para utilizarlos en clases propias. Esto hace posible que utilizar un tipo de datos definido por el usuario parezca tan natural y lógico como utilizar un tipo de datos fundamental. Por ejemplo, podría crear un nuevo tipo de datos denominado ComplexNumber para representar un número complejo y proporcionar métodos que realicen operaciones matemáticas en esos números mediante operadores aritméticos estándar, como utilizar el operador + para sumar dos números complejos.

Para sobrecargar un operador, se escribe una función que tenga el nombre del operador seguido del símbolo del operador que se va a sobrecargar. Por ejemplo, a continuación se muestra cómo sobrecargar el operador +:

public static ComplexNumber operator+(ComplexNumber a, ComplexNumber b)

Todas las sobrecargas de operador son métodos estáticos de la clase. También tenga en cuenta que si sobrecarga el operador de igualdad (==), también debe sobrecargar el operador de desigualdad (!=). Los operadores < y >, y los operadores < = y > = también se deberían sobrecargar en pares.

La lista completa de operadores que se pueden sobrecargar es la siguiente:

Operadores unarios: +, -, !, ~, ++, --, true, false

Operadores binarios: +, -, *, /, %, &, |, ^, <<, >>, ==, !=, >, <, >=, <=

El ejemplo de código siguiente crea una clase ComplexNumber que sobrecarga los operadores + y -:

public class ComplexNumber

{

private int real;

private int imaginary;

public ComplexNumber() : this(0, 0) // constructor

{

}

public ComplexNumber(int r, int i) // constructor

{

real = r;

imaginary = i;

}

// Override ToString() to display a complex number in the traditional format:

public override string ToString()

{

return(System.String.Format("{0} + {1}i", real, imaginary));

}

// Overloading '+' operator:

public static ComplexNumber operator+(ComplexNumber a, ComplexNumber b)

{

return new ComplexNumber(a.real + b.real, a.imaginary + b.imaginary);

}

// Overloading '-' operator:

public static ComplexNumber operator-(ComplexNumber a, ComplexNumber b)

{

return new ComplexNumber(a.real - b.real, a.imaginary - b.imaginary);

}

Esta clase permite crear y manipular dos números complejos con código de la manera siguiente:

class TestComplexNumber

{

static void Main()

{

ComplexNumber a = new ComplexNumber(10, 12);

ComplexNumber b = new ComplexNumber(8, 9);

System.Console.WriteLine("Complex Number a = {0}", a.ToString());

System.Console.WriteLine("Complex Number b = {0}", b.ToString());

ComplexNumber sum = a + b;

System.Console.WriteLine("Complex Number sum = {0}", sum.ToString());

ComplexNumber difference = a - b;

System.Console.WriteLine("Complex Number difference = {0}", difference.ToString());

}

Como se muestra en el programa, los operadores más y menos se pueden utilizar ahora casi intuitivamente en objetos que pertenecen a la clase ComplexNumber. Éste es el resultado que se obtendría:

Complex Number a = 10 + 12i

Complex Number b = 8 + 9i

Complex Number sum = 18 + 21i

Complex Number difference = 2 + 3i

Java no admite la sobrecarga de operadores, aunque internamente sobrecarga el operador + para la concatenación de cadenas.

SOBRECARGA (++) y (--)

También se puede sobrecargar los operadores de incremento y decremento por ejemplo podría decirse que incrementar un objetivo video es añadirle 1 a la cantidad disponible después debe añadirse la declaración cpp que contiene los métodos dela clase y los operadores sobrecargados la declaración de operator+ (), su definición y el programa de c++ que utiliza al operador sobrecargado ++ se pueden ver en el ejemplo 2-16 cpp y ex2-16 cpp para crear un único archivo ejecutable.

Ejemplo:

Java no permite comentarios anidados, por lo que el siguiente trozo de código no compilará:

/* Esto es un comentario

/* a=3; */

Fin del comentario */

Ya que el primer grupo /* se empareja con el primer grupo */. Para evitar eso es mejor utilizar la doble barra cuando se quiere comentar una línea dentro de un comentario.

/* Esto es un comentario

// a=3;

Fin del comentario */

Ejemplo de código:

/** una de nuestas clases de ejemplo */

class HolaMundo2{

/** el metodo main de la clase HolaMundo */

public static void main(String[] args) {

//String mensaje="Hola otra vez mundo";

String mensaje="Saludos";

System.out.println(mensaje);

}

} // fin de la clase HolaMundo2

Cuando el operador de incremento se utiliza como sufijo surge un problema debido a que no tiene el mismo efecto colocarlo como prefijo (++rent1) que como sufijo (rent1++) por esta razón la segunda función operator ++ () debe escribirse para espere un argumento int este argumento int es un argumento fantasma (dummy argument) y nunca lo utiliza la función.

El ejemplo 2-17 muestra la declaración dela segunda función sobre cargada operator++ () que se ha añadido a la definición dela clase que hay en el archivo video cpp y el programa de c++ que utiliza las dos formas del operador sobrecargado cpp para crear un solo programa ejecutable.

bibliografía

Libro: Programación orientada a objetos

autor: Jo Ann Smith

Paraninfo Pago. 207

Sobrecargas de operadores