ajuda sobrecarga << e >> para exibir dois valores

Question

Esta pode ser uma questão novato, mas eu não consigo descobrir isso inspecionando o livro que eu tenho. o construtor da classe inicializa duas duplas, e eu quero o seguinte código para a saída desses dois duplos com <<.

Complex x( 3.3, 1.1 );

cout << "x: " << x;

Depois de esta necessidade I à sobrecarga >> para aceitar dois duplos para estes. Esta é a minha primeira pergunta aqui, por isso, se minhas informações fornecidas são falta me informar

EDIT: Agora tenho para o construtor e sobrecarga declaração seguinte:

#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;
}

Eu sei que eu tenho que mudar o "const c Complex &" e "c = Complex (r, i);" mas não tenho certeza de como fazê-lo. Além disso, vou dizer aqui que não se trata de classe Complexo da biblioteca std, embora seja baseado na mesma idéia. Até agora todos tem sido uma grande ajuda, mas eu tenho um caso do mudo hoje.

Answer 1

operador <<:

std::cout é um objeto std::ostream, então você tem que operator<< sobrecarga para ostream, que leva std::complex<double> como um argumento, supondo que você use std::complex<double> do complexo de cabeçalho padrão. Desde que você não deve fazer mudanças internas para contentores normais e classes, torná-lo independente.

#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 >>:

operator>> leva um objeto std::istream, que faz o oposto do que std::ostream faz. Se você usar correntes para serialização como este, é uma boa idéia para permitir exceções para eles também. Normalmente, você só quer jogar em 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;
}

Se você precisava de acesso aos membros internos da classe, você definiria a função sobrecarregada como um amigo. Mas desde que std :: complex :: real () e std :: complex :: imag () são uma parte da interface pública, que não é necessária aqui. E para o exemplo istream, nós simplesmente invocar o copy-construtor que é também uma parte da interface pública.

eu achei que você queria usar cin e cout aqui. Mas se você queria sobrecarregar os operadores para outra coisa, o mesmo se aplica. Se você implementar os operadores dentro de uma definição de classe, você tem acesso ao ponteiro this, portanto, a função de operador só deve ter um argumento.