NAME¶

std::conj(std::complex) - std::conj(std::complex)

Synopsis¶

Defined in header <complex>
template< class T > (until
std::complex<T> conj( const std::complex<T>& z ); C++20)
template< class T > (since
constexpr std::complex<T> conj( const C++20)
std::complex<T>& z );
Additional overloads (since C++11)
Defined in header <complex>
std::complex<float> conj( float f );
(until
std::complex<double> conj( double f ); C++20)

std::complex<long double> conj( long double f );
constexpr std::complex<float> conj( float f ); (1)
(since
constexpr std::complex<double> conj( double f C++20)
); (until
(A) C++23)
constexpr std::complex<long double> conj( long
double f );
template< class FloatingPoint > (since
constexpr std::complex<FloatingPoint> conj( C++23)
FloatingPoint f );
template< class Integer > (until
constexpr std::complex<double> conj( Integer i ); (B) C++20)
template< class Integer > (since
constexpr std::complex<double> conj( Integer i ); C++20)

1) Computes the complex conjugate of z by reversing the sign of the imaginary part.

A,B) Additional overloads are provided for all integer and
floating-point types, which are treated as complex numbers with zero (since C++11)
imaginary component.

Parameters¶

z - complex value
f - floating-point value
i - integer value

Return value¶

1) The complex conjugate of z.
A) std::complex(f).
B) std::complex<double>(i).

Notes¶

The additional overloads are not required to be provided exactly as (A,B). They only
need to be sufficient to ensure that for their argument num:

* If num has a
standard
(until C++23) floating-point type T, then std::conj(num) has the same effect as
std::conj(std::complex<T>(num)).
* Otherwise, if num has an integer type, then std::conj(num) has the same effect
as std::conj(std::complex<double>(num)).

Example¶

// Run this code

#include <complex>
#include <iostream>

int main()
{
std::complex<double> z(1.0, 2.0);
std::cout << "The conjugate of " << z << " is " << std::conj(z) << '\n'
<< "Their product is " << z * std::conj(z) << '\n';
}

Output:¶

The conjugate of (1,2) is (1,-2)
Their product is (5,0)

See also¶

abs(std::complex) returns the magnitude of a complex number
(function template)
norm returns the squared magnitude
(function template)
polar constructs a complex number from magnitude and phase angle
(function template)
C documentation for
conj