From cppreference.com
Defined in header
template<classT>std::complex<T>conj(conststd::complex<T>&z); (1)(until C++20)template<classT>constexprstd::complex<T>conj(conststd::complex<T>&z);(since C++20)
(since C++11)
Defined in header
std::complex<float>conj(floatf);std::complex<double>conj(doublef);std::complex<longdouble>conj(longdoublef); (A)(until C++20)constexprstd::complex<float>conj(floatf);constexprstd::complex<double>conj(doublef);constexprstd::complex<longdouble>conj(longdoublef);(since C++20)
(until C++23)template<classFloatingPoint>constexprstd::complex<FloatingPoint>conj(FloatingPointf);(since C++23)template<classInteger>constexprstd::complex<double>conj(Integeri); (B)(until C++20)template<classInteger>constexprstd::complex<double>conj(Integeri);(since C++20)1) Computes the
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 imaginary component.
(since C++11)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>intmain(){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