##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# std::complex

From cppreference.com
< cpp‎ | numeric

Defined in header `<complex>` |  |
template< class T > class complex; | (1) |
template<> class complex<float>; | (2) |
template<> class complex<double>; | (3) |
template<> class complex<long double>; | (4) |

The specializations std::complex<float>, std::complex<double>, and std::complex<long double> are `LiteralType`s for representing and manipulating complex numbers.

The effect of instantiating the template `complex` for any other type is unspecified.

### [edit] Member types

Member type | Definition
`value_type` | `T`

### [edit] Member functions

(constructor) | constructs a complex number (public member function) [edit]
operator= | assigns the contents (public member function) [edit]
real | accesses the real part of the complex number (public member function) [edit]
imag | accesses the imaginary part of the complex number (public member function) [edit]
operator+=operator-=operator/=operator*= | compound assignment of two complex numbers or a complex and a scalar (public member function) [edit]

### [edit] Non-member functions

operator+operator- | applies unary operators to complex numbers (function template) [edit]
operator+operator-operator*operator/ | performs complex number arithmetics on two complex values or a complex and a scalar (function template) [edit]
operator==operator!= | compares two complex numbers or a complex and a scalar (function template) [edit]
operator<<operator>> | serializes and deserializes a complex number (function template) [edit]
real | returns the real component (function template) [edit]
imag | returns the imaginary component (function template) [edit]
abs(std::complex) | returns the magnitude of a complex number (function template) [edit]
arg | returns the phase angle (function template) [edit]
norm | returns the squared magnitude (function template) [edit]
conj | returns the complex conjugate (function template) [edit]
proj (C++11) | returns the projection onto the Riemann sphere (function template) [edit]
polar | constructs a complex number from magnitude and phase angle (function template) [edit]
##### Exponential functions
exp(std::complex) | complex base e exponential (function template) [edit]
log(std::complex) | complex natural logarithm with the branch cuts along the negative real axis (function template) [edit]
log10(std::complex) | complex common logarithm with the branch cuts along the negative real axis (function template) [edit]
##### Power functions
pow(std::complex) | complex power, one or both arguments may be a complex number (function template) [edit]
sqrt(std::complex) | complex square root in the range of the right half-plane (function template) [edit]
##### Trigonometric functions
sin(std::complex) | computes sine of a complex number (sin(z)) (function template) [edit]
cos(std::complex) | computes cosine of a complex number (cos(z)) (function template) [edit]
tan(std::complex) | computes tangent of a complex number (tan(z)) (function template) [edit]
asin(std::complex) (C++11) | computes arc sine of a complex number (arcsin(z)) (function template) [edit]
acos(std::complex) (C++11) | computes arc cosine of a complex number (arccos(z)) (function template) [edit]
atan(std::complex) (C++11) | computes arc tangent of a complex number (arctan(z)) (function template) [edit]
##### Hyperbolic functions
sinh(std::complex) | computes hyperbolic sine of a complex number (sh(z)) (function template) [edit]
cosh(std::complex) | computes hyperbolic cosine of a complex number (ch(z)) (function template) [edit]
tanh(std::complex) | computes hyperbolic tangent of a complex number (function template) [edit]
asinh(std::complex) (C++11) | computes area hyperbolic sine of a complex number (function template) [edit]
acosh(std::complex) (C++11) | computes area hyperbolic cosine of a complex number (function template) [edit]
atanh(std::complex) (C++11) | computes area hyperbolic tangent of a complex number (function template) [edit]

### [edit] Non-static data members

For any object `z` of type `complex<T>`, reinterpret_cast<T(&)[2]>(z)[0] is the real part of z and reinterpret_cast<T(&)[2]>(z)[1] is the imaginary part of z. For any pointer to an element of an array of `complex<T>` named `p` and any valid array index i, reinterpret_cast<T*>(p)[2*i] is the real part of the complex number p[i], and reinterpret_cast<T*>(p)[2*i + 1] is the imaginary part of the complex number p[i] These requirements essentially limit implementation of each of the three specializations of std::complex to declaring two and only two non-static data members, of type `value_type`, with the same member access, which hold the real and the imaginary components, respectively. The intent of this requirement is to preserve binary compatibility between the C++ library complex number types and the C language complex number types (and arrays thereof), which have an identical object representation requirement. | (since C++11)

### [edit] Literals

Defined in inline namespace `std::literals::complex_literals`
operator""if operator""i operator""il (C++14) | A std::complex literal representing pure imaginary number (function) [edit]

### [edit] Example

Run this code

    #include <iostream>
    #include <iomanip>
    #include <complex>
    #include <cmath>

    int main()
    {
        using namespace std::complex_literals;
        std::cout << std::fixed << std::setprecision(1);

        std::complex<double> z1 = 1i * 1i;     // imaginary unit squared
        std::cout << "i * i = " << z1 << '\n';

        std::complex<double> z2 = std::pow(1i, 2); // imaginary unit squared
        std::cout << "pow(i, 2) = " << z2 << '\n';

        double PI = std::acos(-1);
        std::complex<double> z3 = std::exp(1i * PI); // Euler's formula
        std::cout << "exp(i * pi) = " << z3 << '\n';

        std::complex<double> z4 = 1. + 2i, z5 = 1. - 2i; // conjugates
        std::cout << "(1+2i)*(1-2i) = " << z4*z5 << '\n';
    }

Output:

    i * i = (-1.0,0.0)
    pow(i, 2) = (-1.0,0.0)
    exp(i * pi) = (-1.0,0.0)
    (1+2i)*(1-2i) = (5.0,0.0)

### [edit] See also

C documentation for Complex number arithmetic

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/numeric/complex&oldid=86904"