aiuta a sovraccaricare < < e > > per visualizzare due valori

Question

Questa potrebbe essere una domanda da principiante, ma non riesco a capirlo controllando il libro che ho. Il costruttore della classe inizializza due doppi e voglio che il seguente codice produca questi due doppi con < < ;.

Complex x( 3.3, 1.1 );

cout << "x: " << x;

Dopo questo ho bisogno di sovraccaricare > > accettarne due doppie. Questa è la mia prima domanda qui, quindi se le mie informazioni fornite sono carenti informatemi

EDIT: Ora ho per il costruttore e la dichiarazione di sovraccarico questo:

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

So che devo cambiare il "const Complex" e il "c" e il " c = Complex (r, i); " ma non sono sicuro di come procedere. Inoltre, dirò qui che non si tratta della classe Complex della libreria std, sebbene sia basata sulla stessa idea. Finora tutti sono stati di grande aiuto, ma oggi ho un caso stupido.

Answer 1

operatore < < :

std :: cout è un oggetto std :: ostream , quindi è necessario sovraccaricare l'operatore < < per ostream , che prende std :: complex < double > come argomento, supponendo che tu utilizzi std :: complex < double > dal complesso di intestazione standard. Dal momento che non dovresti apportare modifiche interne ai contenitori e alle classi standard, rendilo autonomo.

#include <iostream>
#include <complex>

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

operatore > > :

L'operatore

> > accetta un oggetto std :: istream , che fa il contrario di quello che fa std :: ostream . Se si utilizzano flussi per la serializzazione in questo modo, è consigliabile abilitare anche le eccezioni. Di solito vuoi solo lanciare 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 avessi bisogno di accedere ai membri interni della classe, definiresti la funzione sovraccaricata come amico. Ma poiché std :: complex :: real () e std :: complex :: imag () fanno parte dell'interfaccia pubblica, non è necessario qui. E per l'esempio di istream, invochiamo semplicemente il costruttore di copia che fa anche parte dell'interfaccia pubblica.

Supponevo che volessi usare cin e cout qui. Ma se si desidera sovraccaricare gli operatori per qualcos'altro, lo stesso vale. Se si implementano gli operatori all'interno di una definizione di classe, si ha accesso al puntatore this , quindi la funzione operatore dovrebbe accettare solo un argomento.