14. Sobrecarga de operadores. Funciones amigas. (3)

  Curso: Introducción a C++, por Nacho Cabanes (antiguo)

14. Sobrecarga de operadores. Funciones amigas. (3)

Redefinir el operador << ahora ya no es tan difícil. El único problema es que debemos devolver un "flujo" del tipo "ostream", y deberemos autorizar a la función "operator<<" a acceder a la parte privada de NVector, declarandolo como amiga, así:

friend ostream& operator<< ( ostream& salida, NVector v )

En el desarrollo de esta función consistirá en enviar la información que nos interesa al flujo que hemos llamado "salida":

{ return salida << '(' << v.coordX << ',' << v.coordY << ')'; }

El fuente completo sería este:

  1:  // 
  2:  //  sobrec03.cpp 
  3:  // 
  4:  //  Introduccion a C++ 
  5:  //  Sobrecarga de operadores: ejemplo 
  6:  //  Probado con TC++ (MsDos) 
  7:  // 
  8:  //  Curso de C 
  9:  //  Jose Ignacio Cabanes 
 10:  // 
 11:  ///////////////////////////////////////////// 
 12: 
 13:  #include <iostream.h> 
 14: 
 15:  // --------------------------------------------------------- 
 16:  // CLASE  : NVector 
 17:  // Vector, determinado por las dos coordenadas de su 
 18:  //   extremo (se supone su origen en el origen de 
 19:  //   coordenadas) 
 20:  // --------------------------------------------------------- 
 21: 
 22:  class NVector { 
 23: 
 24:      int coordX, coordY;     // Coordenadas del extremo del vector 
 25: 
 26:  public: 
 27: 
 28:      NVector() { coordX = 0; coordY = 0; }   // Constructor 
 29: 
 30:      int LeerX();           // Leer valores y fijarlos 
 31:      int LeerY(); 
 32:      void FijarX( int valor ); 
 33:      void FijarY( int valor ); 
 34: 
 35:                              // Mostrar en pantalla: (x,y) 
 36:      friend ostream& operator<< ( ostream& salida, NVector v ) 
 37:         { return salida << '(' << v.coordX << ',' << v.coordY << ')'; } 
 38: 
 39:      NVector operator+( NVector v2 );  // Sumar otro vector a éste 
 40: 
 41:  }; 
 42: 
 43:  // ========================================================================== 
 44: 
 45:  // 
 46:  //  A continuación viene el desarrollo de las funciones (métodos) 
 47:  // 
 48:  // ======== 
 49: 
 50:  /* ----------------- NVector ------------------------------- */ 
 51:  /* Leer los valores de las coordenadas                       */ 
 52:  /* _________________________________________________________ */ 
 53: 
 54:  int 
 55:  NVector::LeerX() { 
 56:      return coordX; 
 57:  } 
 58: 
 59:  int 
 60:  NVector::LeerY() { 
 61:      return coordY; 
 62:  } 
 63:   
 64: 
 65:  /* ----------------- NVector ------------------------------- */ 
 66:  /* Fijar los valores de las coordenadas                      */ 
 67:  /* _________________________________________________________ */ 
 68: 
 69:  void 
 70:  NVector::FijarX( int valor ) { 
 71:      coordX = valor; 
 72:  } 
 73: 
 74:  void 
 75:  NVector::FijarY( int valor ) { 
 76:      coordY = valor; 
 77:  } 
 78:   
 79: 
 80:  /* ----------------- NVector ------------------------------- */ 
 81:  /* Otras: sumar                                              */ 
 82:  /* _________________________________________________________ */ 
 83: 
 84:  NVector 
 85:  NVector::operator +( NVector v2 ) { 
 86:      NVector temporal; 
 87: 
 88:      temporal.coordX = coordX + v2.coordX; 
 89:      temporal.coordY = coordY + v2.coordY; 
 90: 
 91:      return temporal; 
 92:  } 
 93:   
 94:   
 95:   
 96:   
 97: 
 98:  // ========================================================================== 
 99:  // 
100:  //  Finalmente: un programa sencillo de ejemplo 
101:  // 
102:  // ======== 
103: 
104:  NVector vec1, vec2;   // Definimos dos objetos de la clase "NVector" 
105: 
106:  main() { 
107:      vec1.FijarX(3); vec1.FijarY(2); 
108:      cout << vec1 << '\n'; 
109: 
110:      vec2.FijarX(5); vec2.FijarY(4); 
111:      cout << vec2 << '\n'; 
112: 
113:      vec1 = vec1 + vec2; 
114:      cout << vec1 << '\n'; 
115:      return 0; 
116:  }  

Podríamos (¿y deberíamos?) haber distinguido entre operadores unarios (o monarios, que sólo permiten un operando, como el - de cambio de signo) y binarios (con dos operadores, como el * de la multiplicación), pero ya hemos visto un ejemplo de cómo redefinir ambos, casi sin darnos cuenta...

Así que ahora sólo queda experimentar. Por ejemplo, esta clase NVector se podría completar, de modo que se pudiese hallar el producto escalar de dos vectores sobrecargando el operador * (y *=), se debería cambiar las variables miembro de números enteros a números reales, se podría multiplicar un vector por un escalar (sobrecargando nuevamente * y *=), se podría calcular su módulo, con una función miembro llamada así o con un operador que parezca apropiado, etc...

Actualizado el: 13-08-2006 21:19