ayuda sobrecarga < < y > > para mostrar dos valores

Question

Esta puede ser una pregunta novata, pero no puedo resolverlo inspeccionando el libro que tengo. El constructor de la clase inicializa dos dobles, y quiero que el siguiente código muestre esos dos dobles con < < ;.

Complex x( 3.3, 1.1 );

cout << "x: " << x;

Después de esto, necesito sobrecargar > > aceptar dos dobles en estos. Esta es mi primera pregunta aquí, así que si falta la información proporcionada, infórmeme

EDITAR: Ahora tengo para el constructor y la declaración de sobrecarga esto:

#include "Complex.h"

Complex::Complex( double realPart, double imaginaryPart )
: real( realPart ),
imaginary( imaginaryPart )
{

}

std::istream& operator>>(std::istream& strm, const Complex &c)
{
   double r,i;
   strm >> r >> i;
   c = Complex(r,i);
   return strm;
}

Sé que tengo que cambiar el "const Complex & amp; c" y el complejo "c = (r, i);" pero no estoy seguro de cómo hacerlo. Además, diré aquí que no se trata de la clase Complex de la biblioteca estándar, aunque se basa en la misma idea. Hasta ahora todos han sido de gran ayuda, pero hoy tengo un caso tonto.

Answer 1

operador < < :

std :: cout es un objeto std :: ostream , por lo que debe sobrecargar operator < < para ostream , que toma std :: complex < double > como argumento, suponiendo que use std :: complex < double > del complejo de encabezado estándar. Como no debe realizar cambios internos en los contenedores y clases estándar, hágalo independiente.

#include <iostream>
#include <complex>

std::ostream& operator<<(std::ostream& strm, const std::complex<double>& c)
{
    strm << "real: " << c.real() << "imag: " << c.imag();
    return strm;
}

operador > > :

El operador

> > toma un objeto std :: istream , que hace lo contrario de lo que hace std :: ostream . Si usa secuencias para la serialización de esta manera, también es una buena idea habilitar excepciones para ellas. Por lo general, solo desea utilizar std :: ios :: badbit .

#include <iostream>
#include <complex>

std::istream& operator>>(std::istream& strm, std::complex<double>& c)
{
    double r,i;
    strm >> r >> i;
    c = std::complex<double>(r,i);
    return strm;
}

Si necesitara acceso a miembros internos de la clase, definiría la función sobrecargada como amigo. Pero como std :: complex :: real () y std :: complex :: imag () son parte de la interfaz pública, no es necesario aquí. Y para el ejemplo de istream, simplemente invocamos el constructor de copias que también es parte de la interfaz pública.

Supuse que querías usar cin y cout aquí. Pero si desea sobrecargar a los operadores para otra cosa, lo mismo se aplica. Si implementa los operadores dentro de una definición de clase, tiene acceso al puntero this , por lo tanto, la función de operador solo debe tomar un argumento.