Disponible la nueva versión "donationware" 7.3 de OrganiZATOR
Descubre un nuevo concepto en el manejo de la información.
La mejor ayuda para sobrevivir en la moderna jungla de datos la tienes aquí.

Curso C++

[Home]  [Inicio]  [Índice]


4.9.18h  Sobrecarga de Enumeraciones

§1  Sinopsis

El hecho de referirnos a la sobrecarga de enumeraciones ( 4.7) podría parecer en contradicción con lo indicado al tratar de la sobrecarga en general ( 4.9.18): que "se refiere y tiene aplicación solo cuando los operandos son instancias de clases". Sin embargo, hay que tener en cuenta que las enumeraciones son en realidad un tipo muy particular de estructuras (y por ende, de clases), que como tales, gozan de muchas de las características de aquellas [1].

§2  Sobrecarga

Es posible sobrecargar la mayoría de los operadores para una enumeración, pero dado que estas no pueden tener funciones-miembro, no es posible sobrecargar aquellos que precisamente exigen ser sobrecargados a través de métodos no estáticos. Concretamente los operadores =[ ]( )-> no pueden ser sobrecargados para un enum.

La consecuencia inmediata es añadir que la sobrecarga de enumeraciones debe realizarse a través de funciones ordinarias (no pertenecientes a clases), y que al menos uno de los argumentos debe ser del tipo de la enumeración que se sobrecarga.


§3  Comprobar en el ejemplo que sigue la forma de sobrecargar los operadores de preincremento y postincremento. Observe que en cierta forma, la enumeración se comporta como una clase.

#include <iostream>
#using amespace std;
 
enum ESTACION { primavera, verano, otono, invierno };
ESTACION& operator++ (ESTACION& s) {     // Preincremento ++@
   s = ESTACION( (s + 1) % 4 );          // L.6
   return s;
}
ESTACION operator++(ESTACION& s, int) {  // Postincremento @++
   ESTACION tmp = s;
   switch (s) {
      case primavera: s = verano;    break;
      case verano:    s = otono;     break;
      case otono:     s = invierno;  break;
      case invierno:  s = primavera; break;
   }
   return tmp;
}
 
int main(void) {  // =============
   ESTACION est = otono;
   cout << "La estacion es " << est << endl;
   cout << "Preincrementar la estacion: "<< ++est << endl;
   cout << "No cambiar si se usa el postincremento: " << est++ << endl;
   cout << "Finalmente: " << est << endl;
}

Salida:

La estacion es 2
Preincrementar la estacion: 3
No cambiar si se usa el postincremento: 3
Finalmente: 0

Comentario

Por tratarse de la sobrecarga de operadores unarios como funciones externas, ambas funciones-operador se han definido utilizando la forma que hemos denominado "b" ( 4.9.18c):

  • Preincremento:  función que acepta un argumento   operator++(ESTACION)

  • Posincremento:  función acepta un objeto y un entero  operator++(ESTACION, int)

El preincremento recibe el argumento por referencia (L.5), de forma que modifica el valor recibido. Observe como en L.6 se efectúa el calculo aritmético, seguido de un modelado al tipo ESTACION, y como en L.7 este valor es devuelto por referencia.

Observe como el postincremento devuelve un objeto "por valor", y que este objeto es una copia del objeto inicial. Simultáneamente la función modifica el valor del objeto recibido inicialmente (por referencia).

  Inicio.


[1]  Esta similitud interna no se limita a la posibilidad de sobrecarga de sus operadores, se muestra también en otros aspectos. Por ejemplo, los identificadores de las enumeraciones comparten el mismo espacio de nombres que los de estructuras y uniones.