std::conj(std::complex)(3)

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