Aprendiendo C/C++ Paso a Paso - Página 15

15. Paso a Paso C/C++ — Programación en C++ - Sobrecarga de Operadores

Sobrecarga de Operadores

| | 1. Introducción

2. Operador
   • Reglas de Sobrecarga de Operadores
   • Restricciones en la Sobrecarga de Operadores
3. Sobrecarga de Operadores Unarios
4. Sobrecarga de Operadores Binarios
5. Sobrecarga de Operadores con Cadenas |

1. Introducción

| | // Asignar una variable a otra
#include
using namespace std;
int main()
{
int a = 10, b;
b = a; // válido
cout << b;
return 0;
} | // Asignar un objeto a otro
#include
using namespace std;
class emp
{
public:
int eno;
float sal;
};
int main()
{
emp e1= { 1001, 2300.45 },e2 ;
cout << endl << e1.eno << e1.sal;
e2 = e1; // válido
cout << endl << e2.eno << e2.sal;
return 0;
} |

Las expresiones son comunes en todos los lenguajes; una expresión es una colección de operandos y operadores. Mientras que una operación es una colección de expresiones.
Los dos programas anteriores demuestran cómo se asignaron variables/objetos juntos.

Ambos programas son válidos, demuestran el uso del operador igual a ( = ).

| | | |

La sobrecarga de operadores es una de las características más emocionantes de la programación orientada a objetos. Se utiliza para superar situaciones como la operación de estructura ilegal anterior. Puede transformar listados de programas complejos y oscuros en otros intuitivamente obvios.

A través de la sobrecarga de operadores podemos ver cómo los operadores normales de C++ pueden recibir nuevos significados cuando se aplican a tipos de datos definidos por el usuario. La palabra clave operator se utiliza para sobrecargar un operador, y el operador resultante adoptará el significado proporcionado por el programador.

Por ejemplo, usando un objeto podemos realizar una operación de asignación de cadena directa.

| | // Programa para asignar una cadena a otra
#include
#include
#include
using namespace std;
class string
{
char str;
public:
string() { }
string(char s) { str = s; }
void putstring()
{
cout << str;
}
};
int main()
{
string s1(“Computadora”);
string s2;
s2 = s1;
s2.putstring();
return 0;
} |

2. Operador

tipo operator símbolo-del-operador ( lista-de-parámetros )

La palabra clave operator declara una función que especifica lo que significa símbolo-del-operador cuando se aplica a instancias de una clase. Esto le da al operador más de un significado, o lo “sobrecarga”. El compilador distingue entre los diferentes significados de un operador examinando los tipos de sus operandos.

Reglas de Sobrecarga de Operadores

• Puedes sobrecargar los siguientes operadores:

| | ^= | &= | |= | << | >> | <<= | | | <= | >= | && | || | ++ | –– | | | ( ) | [ ] | new | delete | & | | | | | ~ | = | /= | %= | >>= | == | | | != | , | –> | –> | | |

• Si un operador puede usarse como operador unario o binario, puedes sobrecargar cada uso por separado.

• Puedes sobrecargar un operador usando ya sea una función miembro no estática o una función global que sea amiga de una clase. Una función global debe tener al menos un parámetro que sea de tipo de clase o una referencia a tipo de clase.

• Si un operador unario se sobrecarga usando una función miembro, no toma argumentos. Si se sobrecarga usando una función global, toma un argumento.

Si un operador binario se sobrecarga usando una función miembro, toma un argumento. Si se sobrecarga usando una función global, toma dos argumentos.

Restricciones en la Sobrecarga de Operadores

• No puedes definir nuevos operadores, como **.

• No puedes cambiar la precedencia o agrupación de un operador, ni puedes cambiar el número de operandos que acepta.

• No puedes redefinir el significado de un operador cuando se aplica a tipos de datos incorporados.

• Los operadores sobrecargados no pueden tomar argumentos predeterminados.

• No puedes sobrecargar ningún símbolo de preprocesador, ni puedes sobrecargar los siguientes operadores:

| | . | .* | :: | ?: |

El operador de asignación tiene algunas restricciones adicionales. Solo se puede sobrecargar como una función miembro no estática, no como una función amiga. Es el único operador que no puede ser heredado; una clase derivada no puede usar el operador de asignación de una clase base.

3. Sobrecarga de Operadores Unarios

Comencemos sobrecargando un operador unario. Los operadores unarios actúan sobre un solo operando. ( Un operando es simplemente una variable sobre la que actúa un operador). Ejemplos de operadores unarios son los operadores de incremento y decremento ++ y –, y el menos unario.

Ejemplo:
El siguiente ejemplo demuestra el uso del operador de incremento ++.

| | #include
using namespace std;
class counter
{
private:
unsigned int count;
public:
counter(){ count = 0; }
int get_count()  { return count; }
counter operator ++()
{
count++;
counter temp;
temp.count = count;
return temp;
}
};
int main()
{
counter c1, c2;                            // c1 = 0,  c2 = 0
cout << “\nC1 = “ << c1.get_count();       // mostrar
cout << “\nC2 = “ << c2.get_count();

++c1; // c1 = 1
c2 = ++c1 ; // c1 = 2, c2 = 2

cout << “\nC1 = “ << c1.get_count();       // mostrar de nuevo
cout << “\nC2 = “ << c2++.get_count();     // c2 = 3
return 0;
} |

Un ejemplo más para sobrecargar el menos unario.

| | #include
using namespace std;
class subtract
{
int a;
int b;
public:
void getdata(int x, int y)
{
a = x; b = y;
}
void putdata()
{
cout<< endl << “A = “ << a <<”B = “ << b;
}
void operator -()
{
a = -a; b = -b;
}
};

int main()
{
subtract s;
s.getdata(34, -6);
cout << endl << “S : “;
s.putdata();
-s;
cout << endl << “S : “;
s.putdata();
return 0;
}
|

4. Sobrecarga de Operadores Binarios

Pero los operadores pueden ser sobrecargados tan fácilmente como los operadores unarios.  Veremos ejemplos que sobrecargan operadores aritméticos, operadores de comparación y operadores de asignación aritmética.

Acabamos de ver cómo sobrecargar un operador unario. El mismo mecanismo se puede usar para sobrecargar un operador binario.

| | // Sobrecargando el operador +
#include
using namespace std;
class time
{
int hh; int mm; int ss;
public:
time( ) { }
time(int h, int m, int s)
{
hh =h; mm = m; ss = s;
}
void disp_time()
{
cout << endl << hh<< “ : “
<< mm << “ : “ << ss;
}
time operator+(time);
};

time time::operator+(time t)
{
time temp;
temp.hh = hh + t.hh;
temp.mm = mm + t.mm;
temp.ss = ss + t.ss;
return temp;
}

int main()
{
time t1(12,1,24) , t2(5, 23, 45), t3;
t3 = t1 + t2;
t3.disp_time();
return 0;
} |

5. Sobrecarga de Operadores con Cadenas

C/C++ trata las cadenas de manera bastante diferente; nunca copiamos, concatenamos o comparamos cadenas usando operadores como en otros lenguajes. C/C++ tiene funciones incorporadas para realizar las operaciones anteriores. Pero C++ proporciona la facilidad de hacer todo en cadenas usando operadores. Eso significa que tenemos que proporcionar una responsabilidad adicional a los operadores para realizar tales cosas.

El siguiente ejemplo demuestra la comparación entre dos cadenas usando el operador de comparación ==.

| | // Programa para comparar dos cadenas usando sobrecarga de operadores
#include
#include
#include
using namespace std;

enum boolean{ false, true };

class string
{
char str;
public:
string() { str = NULL; }
string(char *s) { str = s; }
int operator ==(string ts)
{
if (strcmp(str, ts.str) >= 0)
return true;
else
return false;
}
};

int main()
{
string s1(“Computadora”);
string s2(“Computadoras”);

if(s1 == s2)
cout << “Igual”;
else
cout << “No Igual”;

return 0;
} |

| | // concatenación de dos cadenas
#include
#include
#include
using namespace std;

class string
{
char str;
public:
string()
{
str = new char[30] ; str = NULL;
}
string(char *s) { str = s; }
string operator +(string ts)
{
string t;
strcat(t.str, str);
strcat(t.str, ts.str);
return t;
}
void putstring()
{
cout << endl << str;
}
};

int main()
{
string s1(“Computadora”); string s2(“Instituto”);
s1.putstring(); s2.putstring();
string s3;

s3 = s1 + s2;

s3.putstring();
return 0;
} |

Ref: Programación orientada a objetos en Turbo C++: Robert Lafore