Movatterモバイル変換

[0]ホーム
URL:

cppreference.com
Namespaces
Variants
    Actions

      operator+,-,*,/(std::complex)

      From cppreference.com
      <cpp‎ |numeric‎ |complex
       
       
       
       
      (1)
      template<class T>

      std::complex<T> operator+(conststd::complex<T>& lhs,

                                 conststd::complex<T>& rhs);
      		(until C++20)
      template<class T>

      constexprstd::complex<T> operator+(conststd::complex<T>& lhs,

                                           conststd::complex<T>& rhs);
      		(since C++20)
      (2)
      template<class T>

      std::complex<T> operator+(conststd::complex<T>& lhs,

                                 const T& rhs);
      		(until C++20)
      template<class T>

      constexprstd::complex<T> operator+(conststd::complex<T>& lhs,

                                           const T& rhs);
      		(since C++20)
      (3)
      template<class T>

      std::complex<T> operator+(const T& lhs,

                                 conststd::complex<T>& rhs);
      		(until C++20)
      template<class T>

      constexprstd::complex<T> operator+(const T& lhs,

                                           conststd::complex<T>& rhs);
      		(since C++20)
      (4)
      template<class T>

      std::complex<T> operator-(conststd::complex<T>& lhs,

                                 conststd::complex<T>& rhs);
      		(until C++20)
      template<class T>

      constexprstd::complex<T> operator-(conststd::complex<T>& lhs,

                                           conststd::complex<T>& rhs);
      		(since C++20)
      (5)
      template<class T>

      std::complex<T> operator-(conststd::complex<T>& lhs,

                                 const T& rhs);
      		(until C++20)
      template<class T>

      constexprstd::complex<T> operator-(conststd::complex<T>& lhs,

                                           const T& rhs);
      		(since C++20)
      (6)
      template<class T>

      std::complex<T> operator-(const T& lhs,

                                 conststd::complex<T>& rhs);
      		(until C++20)
      template<class T>

      constexprstd::complex<T> operator-(const T& lhs,

                                           conststd::complex<T>& rhs);
      		(since C++20)
      (7)
      template<class T>

      std::complex<T> operator*(conststd::complex<T>& lhs,

                                 conststd::complex<T>& rhs);
      		(until C++20)
      template<class T>

      constexprstd::complex<T> operator*(conststd::complex<T>& lhs,

                                           conststd::complex<T>& rhs);
      		(since C++20)
      (8)
      template<class T>

      std::complex<T> operator*(conststd::complex<T>& lhs,

                                 const T& rhs);
      		(until C++20)
      template<class T>

      constexprstd::complex<T> operator*(conststd::complex<T>& lhs,

                                           const T& rhs);
      		(since C++20)
      (9)
      template<class T>

      std::complex<T> operator*(const T& lhs,

                                 conststd::complex<T>& rhs);
      		(until C++20)
      template<class T>

      constexprstd::complex<T> operator*(const T& lhs,

                                           conststd::complex<T>& rhs);
      		(since C++20)
      (10)
      template<class T>

      std::complex<T> operator/(conststd::complex<T>& lhs,

                                 conststd::complex<T>& rhs);
      		(until C++20)
      template<class T>

      constexprstd::complex<T> operator/(conststd::complex<T>& lhs,

                                           conststd::complex<T>& rhs);
      		(since C++20)
      (11)
      template<class T>

      std::complex<T> operator/(conststd::complex<T>& lhs,

                                 const T& rhs);
      		(until C++20)
      template<class T>

      constexprstd::complex<T> operator/(conststd::complex<T>& lhs,

                                           const T& rhs);
      		(since C++20)
      (12)
      template<class T>

      std::complex<T> operator/(const T& lhs,

                                 conststd::complex<T>& rhs);
      		(until C++20)
      template<class T>

      constexprstd::complex<T> operator/(const T& lhs,

                                           conststd::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 subtractingrhs fromlhs.
      7-9) Multiplies its arguments.
      10-12) Divideslhs byrhs.

      Contents

      [edit]Parameters

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

      [edit]Return value

      1-3)std::complex<T>(lhs)+= rhs
      4-6)std::complex<T>(lhs)-= rhs
      7-9)std::complex<T>(lhs)*= rhs
      10-12)std::complex<T>(lhs)/= rhs

      [edit]Notes

      Becausetemplate 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

      Run this code
      #include <complex>#include <iostream> int main(){std::complex<double> c2(2.0,0.0);std::complex<double> 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

      compound assignment of two complex numbers or a complex and a scalar
      (public member function)[edit]
      applies unary operators to complex numbers
      (function template)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/numeric/complex/operator_arith3&oldid=154493"
      [8]ページ先頭
      ©2009-2025 Movatter.jp