SOBRECARGA DE OPERADORES Y FUNCIONES

SOBRECARGA DE OPERADORES

Una característica de C++; que esta relacionada con la sobrecarga de funciones es la sobrecarga de operadores. Ejemplo: Una clase que defina una lista enlazada podría usar el operador (+) de otra forma a más de añadir objetos a la lista, esto no significa que al sobrecargar un operador este pierda alguno de sus significados previos, simplemente significa que se ha definido una nueva operación con relación a un clase especifica, esto quiere decir que al sobrecargar el (+) no modifica su significado con relación a los enteros (es decir la suma). Para sobrecargar una operación significa con relación a la clase a la que se aplica. Para que esto suceda hay que crear una función operador que defina su acción. La sintaxis de la función operador es:

tipo nombre_clase::operador #(lista_argumentos) {… //operaciones definidos con relación a la clase }

Aquí el operador que se quiere sobrecargar se sustituye por el signo (# y tipo es el tipo de valor devuelto por la función. Para facilitar su uso en expresiones complejas el valor devuelve por un operador es con frecuencia del mismo tipo que la clase. Las funciones operador pueden ser miembros o amigas de la clase. Para ver como funciones la sobrecarga de operadores empezaremos creando una clase llamada 3D que se asume posee coordenadas de un objeto en el espacio tridimensional.

  1. include <iostream.h>

class tresd{ int x,y,z; //coordenadas tridimensionales public: tresd operador+ tresd t); tresd operador= tresd t); void mostrar (void); void asignar (int mx, int my, int mz); }

//sobrecarga del operador + tresd tresd :: operador+ (tresd t) {tresd temporal; temporal.x = x+t.x; temporal.y = y+t.y; temporal.z = z+t.z; }

//sobrecarga del operador = tresd tresd :: operador= (tresd t) {x = x+t.x; y = y+t.y; z = z+t.z; return *this; }

//mostrar coordenadas x,y,z void tresd :: mostrar (void) {cout<<x<<”\n”; cout<<y<<”\n”; cout<<z<<”\n”; }

//asignar coordenadas void tresd :: asignar (int mx, int my, int mz) {x=m.x; y=m.y; z=m.z; }

main (void) {tresd a, b, c; a.asignar (1,2,3); b.asignar (10,10,10); c=a+b; c.mostrar (); c=a+b+c; c.mostrar (); }

SOBRECARGA DE OPERADORES CON MANEJO DE CADENAS

Cuando el lenguaje C implementa las cadenas como array de caracteres, utiliza un método complementario al lenguaje basic, combinando y definiendo una clase cadena y operadores relacionados con esta clase como programadores está claro que al utilizar objetos de tipo cadena, el uso tiende a ser complejo y muchas veces difícil de manejar, considere el siguiente ejemplo: Definiendo una clase que utilizará en su sección privada una cadena de caracteres:

  1. include <iostream.h>
  2. include <string.h>

class matriz{ char cad[80]; public: tipo_cad (char *cade = “\0 “){strcpy(cad, cade) ;} tipo_cad operator+ (tipo_cad cad); //concatenar tipo_cad operator= (tipo_cad cad); //asignación void mostrar_cad (void){cout<<cadena;} };

La clase tiene una función constructora que puede utilizarse para iniciar el array de cadena, también declara 2 operadores sobrecargados que realizan la concatenación y la asignación y por ultimo utiliza la función mostrar_cad, que permite mostrar lo que posee cad, las funciones sobrecargadas se muestran a continuación:

tipo_cad tipo_cad :: operator+ (tipo_cad cad) { tipo_cad temp; strcpy (temp.cad, cad); strcat (temp.cad, cad.cad); return temp; }

tipo_cad tipo_cad :: operador= (tipo_cad cad) {strcpy (cad.cad, cad); return *this; }

main (void) { tipo_cad A(“hola”), B(“que tal”), C; C=A+B; C.mostrar (); }

INICIALIZACION DINAMICA

En C++ las variables locales y las variables globales pueden inicializarse en tiempo de ejecución. Normalmente a esto se le llama “inicialización diná¡mica”; es decir , que una variable puede ser inicializada en tiempo de ejecución usando cualquier expresión de C++ e incluso al mismo tiempo que se declara la variable. Ejemplo:

int n=atoi (gets(cad)); long pos= ftell (fp); double d=1,02 * cont/deltax

Consideremos al siguiente ejemplo:

  1. include <iostream.h>
  2. include <string.h>

main (void) { int i; i=10; int j=100; cout << i*j<<”\n”; cout <<”Escriba una cadena : “; char cad [80]; cin>>cad; //inicialización de k dinamicamente en tiempo de ejecución int k=strlen (cad)−1; while (k>0) {cout << cad [k]; k—; } return 0; }

LA PALABRA CLAVE THIS

Antes de pasar a la sobrecarga de operadores es necesario aprender que función tiene este operador, cada vez que se invoca una función miembro se pasa automáticamente un puntero al objeto que le invoca. Se puede acceder a este puntero al objeto usando this, este puntero es un parámetro implícito para todas las funciones miembros. Una función miembro puede acceder a los datos privados de una clase directamente.

Class cl{ Int i;

Una función miembro puede asignarle a i el valor de 10 usando la siguiente sentencia:

Class cl{ Int i; . . . }; i=10;

En realidad esta sentencia es la forma corta de la sentencia this ? i=10; . Ejemplo:

  1. include <iostream.h>

class cl{ int i; public: void carga_i(int val){this?i=val; } int pone_i(void) {return this?i; } };

main (void) {cl o; o.carga_i (100); cout<<o.pone_i(); return 0; }


Google