/** * Javier Abellán. 21 Octubre 2003 * * Programa de ejemplo de sobrecarga de operadores en C++ * Sobrecarga operadores de la clase y operadores globales. */ #include #include /************************************************************************** * METODOS DE LA CLASE *************************************************************************/ /*************** CONSTRUCTORES ************************/ /* Constructor por defecto. Pone los atributos x e y a 0.0 */ ComplejoC::ComplejoC () { x=0.0; y=0.0; } /* Constructor por defecto. Pone los atributos x e y a 0.0 */ ComplejoC::ComplejoC (double valor) { x=valor; y=0.0; } /* Constructor con un array de doubles. Pone el primer elemento del array en x y el * segundo en y */ ComplejoC::ComplejoC (const double origen[]) { *this = origen; } /** Constructor copia. Copia los atributos de origen en los internos de la clase */ ComplejoC::ComplejoC (const ComplejoC &origen) { x = origen.x; y = origen.y; } /************** OPERADORES SUMA EN LA CLASE ***************************/ /** operador suma para un double. Lo suma a la parte real y devuelve ComplejoC para * poder concatenar sumas */ ComplejoC ComplejoC::operator + (double sum) const { ComplejoC aux(*this); aux.x = x + sum; return aux; } /** operador suma para array de doubles. Devuelve ComplejoC para poder concatenar sumas */ ComplejoC ComplejoC::operator + (const double sum[]) { ComplejoC aux; aux.x = x + sum[0]; aux.y = y + sum[1]; return aux; } /** operador suma para otro ComplejoC. Devuelve ComplejoC para poder concatenar sumas */ ComplejoC ComplejoC::operator + (const ComplejoC &sum) const { ComplejoC aux; aux.x = x + sum.x; aux.y = y + sum.y; return aux; } /******************* OPERADORES DE ASIGNACION EN LA CLASE ******************************/ /** operador = para arrays de doubles. Devuelve ComplejoC para poder concatenar * operaciones de = estilo a = b = c; */ ComplejoC &ComplejoC::operator = (const double origen[]) { x = origen[0]; y = origen[1]; return *this; } /** operador = para otro ComplejoC. Devuelve ComplejoC para poder concatenar * operaciones de =, estilo a = b = c; */ ComplejoC &ComplejoC::operator = (const ComplejoC &origen) { x = origen.x; y = origen.y; return *this; } /****************** OPERADORES DE CAST EN LA CLASE ********************/ /** operador cast a double. Devuelve el módulo del complejo */ ComplejoC::operator double () { return sqrt (x*x + y*y); } /******************* OTROS MÉTODOS DE LA CLASE ********************/ /** Devuelve X */ double ComplejoC::dameX () const { return x; } /** Devuelve Y */ double ComplejoC::dameY () const { return y; } /** Asigna X */ double ComplejoC::tomaX (double valor) { x = valor; } /** Asigna Y */ double ComplejoC::tomaY (double valor) { y = valor; } /*********************************************************************** * FUNCIONES EXTERNAS A LA CLASE ***********************************************************************/ /************************* OPERADOR << PARA EL COUT ********************************/ /* operador global << para escribir ComplejoC en pantalla. */ ostream &operator << (ostream &salida, const ComplejoC &origen) { // Se pone signo positivo por defecto char signo='+'; // Si la y es negativa, no se pone signo, ya que al escribir la y ya sale un signo // negativo. if (origen.dameY() < 0.0) signo = 0; // Se escriben los campos separados por el signo cout << origen.dameX() << signo << origen.dameY() << "j"; } /* operador global << para escribir array de doubles en pantalla. */ ostream &operator << (ostream &salida, const double origen[]) { // Se pone signo positivo por defecto char signo='+'; // Si la y es negativa, no se pone signo, ya que al escribir la y ya sale un signo // negativo. if (origen[1] < 0.0) signo = 0; // Se escriben los campos separados por el signo cout << origen[0] << signo << origen[1] << "j"; } /********************* OPERADORES SUMA EXTERNOS **********************************/ /* operador global + para sumar array de doubles con ComplejoC. * Devuelve un ComplejoC para poder encadenar sumas a+b+c+d */ ComplejoC operator + (const double sum1[], const ComplejoC &sum2) { ComplejoC aux; aux = sum2 + sum1; return aux; } /* operador global + para sumar un double con un complejo. Devuelve ComplejoC * para poder encadenar sumas */ ComplejoC operator + (double sum, const ComplejoC &origen) { ComplejoC aux; aux = origen + sum; return aux; }