operator<<,>>(std::complex) - cppreference.com (original) (raw)

| Defined in header | | | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --- | | | template< class T, class CharT, class Traits > std::basic_ostream<CharT, Traits>& operator<<( std::basic_ostream<CharT, Traits>& os, const std::complex<T>& x ); | (1) | | | template< class T, class CharT, class Traits > std::basic_istream<CharT, Traits>& operator>>( std::basic_istream<CharT, Traits>& is, std::complex<T>& x ); | (2) | |

1. Writes to os the complex number in the form (real, imaginary).

2. Reads a complex number from is. The supported formats are

• real
• (real)
• (real, imaginary)

where the input for real and imaginary must be convertible to T.

If an error occurs calls is.setstate(ios_base::failbit).

Contents

• 1 Exceptions
• 2 Parameters
• 3 Return value
• 4 Notes
• 5 Possible implementation
• 6 Example

[edit] Exceptions

May throw std::ios_base::failure on stream errors.

[edit] Parameters

[edit] Return value

1. os

2. is

[edit] Notes

1. As the comma may be used in the current locale as decimal separator, the output may be ambiguous. This can be solved with std::showpoint which forces the decimal separator to be visible.

2. The input is performed as a series of simple formatted extractions. Whitespace skipping is the same for each of them.

[edit] Possible implementation

template<class T, class CharT, class Traits> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& o, const complex& x) { basic_ostringstream<CharT, Traits> s; s.flags(o.flags()); s.imbue(o.getloc()); s.precision(o.precision()); s << '(' << x.real() << ',' << x.imag() << ')'; return o << s.str(); }

[edit] Example

#include #include   int main() { std::cout << std::complex {3.14, 2.71} << '\n'; }

Possible output: