# operator==,!=(std::complex)

< cpp‎ | numeric‎ | complex

Numerics library
Common mathematical functions
Mathematical special functions (C++17)
Mathematical constants (C++20)
Basic linear algebra algorithms (C++26)
Floating-point environment (C++11)
Complex numbers
Numeric arrays
Pseudo-random number generation
Factor operations
(C++17)
(C++17)
Interpolations
(C++20)
(C++20)
Saturation arithmetic
 mul_sat(C++26) div_sat(C++26)
Generic numeric operations
 iota(C++11) ranges::iota(C++23) accumulate inner_product adjacent_difference partial_sum
 reduce(C++17) transform_reduce(C++17) inclusive_scan(C++17) exclusive_scan(C++17) transform_inclusive_scan(C++17) transform_exclusive_scan(C++17)
Bit operations
 has_single_bit(C++20) bit_cast(C++20) bit_ceil(C++20) bit_floor(C++20) bit_width(C++20) rotl(C++20) rotr(C++20)
 popcount(C++20) countl_zero(C++20) countl_one(C++20) countr_zero(C++20) countr_one(C++20) byteswap(C++23) endian(C++20)

std::complex
Member functions
Non-member functions
 operator+operator- operator+operator-operator*operator/ operator==operator!=(until C++20) operator<> get(std::complex)(C++26)
 real imag abs arg norm conj proj(C++11) polar operator""ioperator""ifoperator""il(C++14)(C++14)(C++14)
Exponential functions
 log
 log10
Power functions
 pow
Trigonometric functions
 sin  cos tan
 asin(C++11) acos(C++11) atan(C++11)
Hyperbolic functions
 sinh  cosh tanh
 asinh(C++11) acosh(C++11) atanh(C++11)
Helper types

 Defined in header  (1) template< class T > bool operator==( const complex& lhs, const complex& rhs ); (until C++14) template< class T > constexpr bool operator==( const complex& lhs, const complex& rhs ); (since C++14) (2) template< class T > bool operator==( const complex& lhs, const T& rhs ); (until C++14) template< class T > constexpr bool operator==( const complex& lhs, const T& rhs ); (since C++14) (3) template< class T > bool operator==( const T& lhs, const complex& rhs ); (until C++14) template< class T > constexpr bool operator==( const T& lhs, const complex& rhs ); (since C++14) (until C++20) (4) template< class T > bool operator!=( const complex& lhs, const complex& rhs ); (until C++14) template< class T > constexpr bool operator!=( const complex& lhs, const complex& rhs ); (since C++14) (until C++20) (5) template< class T > bool operator!=( const complex& lhs, const T& rhs ); (until C++14) template< class T > constexpr bool operator!=( const complex& lhs, const T& rhs ); (since C++14) (until C++20) (6) template< class T > bool operator!=( const T& lhs, const complex& rhs ); (until C++14) template< class T > constexpr bool operator!=( const T& lhs, const complex& rhs ); (since C++14) (until C++20)

Compares two complex numbers. Scalar arguments are treated as complex numbers with the real part equal to the argument and the imaginary part set to zero.

1-3) Compares lhs and rhs for equality.
4-6) Compares lhs and rhs for inequality.
 The != operator is synthesized from operator==. (since C++20)

### Parameters

 lhs, rhs - the arguments to compare: either both complex numbers or one complex and one scalar of matching type (float, double, long double)

### Return value

1-3) true if respective parts of lhs are equal to rhs, false otherwise.
4-6) !(lhs == rhs)

### Example

#include <complex>

int main()
{
using std::operator""i; // or: using namespace std::complex_literals;

static_assert(1.0i == 1.0i);
static_assert(2.0i != 1.0i);

constexpr std::complex z(1.0, 0.0);
static_assert(z == 1.0);
static_assert(1.0 == z);
static_assert(2.0 != z);
static_assert(z != 2.0);
}