operator+,-,*,/ (std::complex) - cppreference.com (original) (raw)

| (1) | | | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | ------------- | | template< class T > std::complex<T> operator+( const std::complex<T>& lhs, const std::complex<T>& rhs ); | | (until C++20) | | template< class T > constexpr std::complex<T> operator+( const std::complex<T>& lhs, const std::complex<T>& rhs ); | | (since C++20) | | (2) | | | | template< class T > std::complex<T> operator+( const std::complex<T>& lhs, const T& rhs ); | | (until C++20) | | template< class T > constexpr std::complex<T> operator+( const std::complex<T>& lhs, const T& rhs ); | | (since C++20) | | (3) | | | | template< class T > std::complex<T> operator+( const T& lhs, const std::complex<T>& rhs ); | | (until C++20) | | template< class T > constexpr std::complex<T> operator+( const T& lhs, const std::complex<T>& rhs ); | | (since C++20) | | (4) | | | | template< class T > std::complex<T> operator-( const std::complex<T>& lhs, const std::complex<T>& rhs ); | | (until C++20) | | template< class T > constexpr std::complex<T> operator-( const std::complex<T>& lhs, const std::complex<T>& rhs ); | | (since C++20) | | (5) | | | | template< class T > std::complex<T> operator-( const std::complex<T>& lhs, const T& rhs ); | | (until C++20) | | template< class T > constexpr std::complex<T> operator-( const std::complex<T>& lhs, const T& rhs ); | | (since C++20) | | (6) | | | | template< class T > std::complex<T> operator-( const T& lhs, const std::complex<T>& rhs ); | | (until C++20) | | template< class T > constexpr std::complex<T> operator-( const T& lhs, const std::complex<T>& rhs ); | | (since C++20) | | (7) | | | | template< class T > std::complex<T> operator*( const std::complex<T>& lhs, const std::complex<T>& rhs ); | | (until C++20) | | template< class T > constexpr std::complex<T> operator*( const std::complex<T>& lhs, const std::complex<T>& rhs ); | | (since C++20) | | (8) | | | | template< class T > std::complex<T> operator*( const std::complex<T>& lhs, const T& rhs ); | | (until C++20) | | template< class T > constexpr std::complex<T> operator*( const std::complex<T>& lhs, const T& rhs ); | | (since C++20) | | (9) | | | | template< class T > std::complex<T> operator*( const T& lhs, const std::complex<T>& rhs ); | | (until C++20) | | template< class T > constexpr std::complex<T> operator*( const T& lhs, const std::complex<T>& rhs ); | | (since C++20) | | (10) | | | | template< class T > std::complex<T> operator/( const std::complex<T>& lhs, const std::complex<T>& rhs ); | | (until C++20) | | template< class T > constexpr std::complex<T> operator/( const std::complex<T>& lhs, const std::complex<T>& rhs ); | | (since C++20) | | (11) | | | | template< class T > std::complex<T> operator/( const std::complex<T>& lhs, const T& rhs ); | | (until C++20) | | template< class T > constexpr std::complex<T> operator/( const std::complex<T>& lhs, const T& rhs ); | | (since C++20) | | (12) | | | | template< class T > std::complex<T> operator/( const T& lhs, const std::complex<T>& rhs ); | | (until C++20) | | template< class T > constexpr std::complex<T> operator/( const T& lhs, const std::complex<T>& rhs ); | | (since C++20) |

Implements the binary operators for complex arithmetic and for mixed complex/scalar arithmetic. Scalar arguments are treated as complex numbers with the real part equal to the argument and the imaginary part set to zero.

1-3) Returns the sum of its arguments.

4-6) Returns the result of subtracting rhs from lhs.

7-9) Multiplies its arguments.

10-12) Divides lhs by rhs.

[edit] Parameters

[edit] Return value

[edit] Notes

Because template argument deduction does not consider implicit conversions, these operators cannot be used for mixed integer/complex arithmetic. In all cases, the scalar must have the same type as the underlying type of the complex number.

The GCC flag "-fcx-limited-range" (included by "-ffast-math") changes the behavior of complex multiply/division by removing checks for floating point edge cases. This impacts loop vectorization.

[edit] Example

#include #include   int main() { std::complex c2(2.0, 0.0); std::complex ci(0.0, 1.0);   std::cout << ci << " + " << c2 << " = " << ci + c2 << '\n' << ci << " * " << ci << " = " << ci * ci << '\n' << ci << " + " << c2 << " / " << ci << " = " << ci + c2 / ci << '\n' << 1 << " / " << ci << " = " << 1.0 / ci << '\n';   // std::cout << 1.0f / ci; // compile error // std::cout << 1 / ci; // compile error }

Output:

(0,1) + (2,0) = (2,1) (0,1) * (0,1) = (-1,0) (0,1) + (2,0) / (0,1) = (0,-1) 1 / (0,1) = (0,-1)

[edit] See also