Mecanismo de sobrecarga de ordenadores

Mecanismo de sobrecarga de operadores
Formato general :
tipo_de_retorno operator @(lista_de_parámetros)
{
cuerpo de la función
}
El formato cuando se define como una función miembro de la clase es el siguiente :
tipo nombre_clase::operator @(lista_de_parámetros)
{
cuerpo de la función
}
Las funciones miembros deben ser o miembros o amigas de la clase para la que se está utilizando.
Por lo general, el valor de retorno de los operadores es el mismo tipo de la clase para la cual el operador
se sobrecarga.
C++ no entiende el significado del operador que se está sobrecargando. Es responsabilidad del
programador definir correctamente el significado de las funciones sobrecargadas. Ej.: si se sobrecarga
un operador suma (+), pero en la función de sobrecarga en lugar de sumar a+b, se ha colocado el signo
*, la operación a+b multiplicará en lugar de sumar.
C++ no puede derivar operadores complejos de otros más simples. Si se definen las funciones
operador, operator* y operator=, la expresión a*=b no será evaluada por C++ correctamente. Si se
desea esta operación se deberá sobrecargar el sÃ−mbolo *=.
Cuando se redefine un operador como una función ordinaria, el primero de los parámetros del
operador debe ser una clase no se puede redefinir el operador de suma de dos enteros, no tampoco de
un entero con una clase, si se puede definir el de una clase con un entero.
Ej.: supongamos la suma de una variable compleja y el entero 2
aa+2 con una función miembro apropiada se puede interpretar como: aa.operator+(2)
por el contrario ; 2+aa no se puede interpretar porque no existe una clase int como para definir + con el
significado 2.operator+(aa)
Ejemplos :
complejo operator+(complejo a, complejo b); //válido
1
reloj& reloj::operator++(reloj t); //válido
char* operator+(char *a, char *b); //no válido
char operator@(menu bar1, menu bar2); //no válido
menu operator++(menu a, menu b); //no válido
void string::operator*=(char *S); //válido
Sintaxis de los patrones de clase es :
template <class nombre_tipo> class tipop {
….
};
nombre_tipo = tipo genérico, puede ser inclusive un tipo básico, no especifica necesariamente un
nombre que se utilizará más adelante (puede haber más de un argumente encerrado entre “<” “>” )
tipop = nombre del patrón, este nombre se empleará más adelante para declarar y definir las clases
Ejemplos:
template <class T> class Pila {
…
};
template <class elem, int tamaño> class Cola {
…
};
template <class T> class Array {
…
};
Pila <int> pila_ent;
Pila <float> pila_real;
Cola <int,2048) a;
Cola <char,512) b;
Array <int> intArray(128);
2
Array <float> fArray(32);
Sintaxis de una plantilla de función :
template <declaración_parámetros_patrón> declaración;
Usos más frecuentes :
template <class T> T& f(T parámetro){ …};
template <class T> t f(int a, T b) {…};
template <class T> T f(T a, T b) {…};
template <class T1, class T2> T1 f(T a, T b) {…};
También en la función se pueden declarar las palabras claves static, extern, inline (calificadores de
la función). Siempre van antes de la declaración de la función, no antes de la palabra clave template.
Ejemplos :
// declaración correcta
template <class T> extern T f (T a, T b) {
…
};
// declaración incorrecta
extern template <class T> T f (T a, T b) {
…
};
Un ejemplo simple :
template <class T> T min(T a, T b)
{
if(a <=b) return a;
else return b;
}
void main()
{
3
int ea=1, eb=5;
cout << “min int: ” << min(ea,eb) << endl;
long la=1000, lb=2000;
cout << “min long: ” << min(la,lb) << endl;
char ca= `b', cb= `x';
cout << “min char: ” << min(ca,cb) << endl;
};
Cuando el compilador llega a la función min, se fija en sus parámetros e instancia la función de
acuerdo con los parámetros de llamada a función empleados.
Universidad Tecnológica Nacional - Santa Fe - Departamento Sistemas Curso : Desarrollos de Programación en C++
4