最終更新日時: 2019年04月06日 02時10分51秒 (JST)
Akira Takahashi が更新

履歴 編集

function template
<complex>

# std::operator+

    namespace std {
      template <class T>
      complex<T>
        operator+(const complex<T>& lhs, const complex<T>& rhs); // (1) C++03

      template <class T>
      constexpr complex<T>
        operator+(const complex<T>& lhs, const complex<T>& rhs); // (1) C++20

      template <class T>
      complex<T>
        operator+(const complex<T>& lhs, const T& rhs);          // (2) C++03

      template <class T>
      constexpr complex<T>
        operator+(const complex<T>& lhs, const T& rhs);          // (2) C++20

      template <class T>
      complex<T>
        operator+(const T& lhs, const complex<T>& rhs);          // (3) C++03

      template <class T>
      constexpr complex<T>
        operator+(const T& lhs, const complex<T>& rhs);          // (3) C++20
    }

## 概要

複素数の加算を行う

## 戻り値

`complex<T>(lhs) += rhs`
（`lhs` を基に新たな `complex<T>` 型のオブジェクトを作成し、そのオブジェクトに `operator+=` を用いて `rhs` を加えた上で、当該オブジェクトを返す）

## 備考

`lhs` と `rhs` の両辺に現れる型 `T` は（残念ながら）同じ型でなければならない。（`complex<double>` と `complex<float>` の加算や、`complex<double>` と `float` の加算などを行うことはできない。）
特に、これらの演算子は関数テンプレートであるため、`operator+=` の場合と異なり、暗黙の型変換は行われないことに注意。

## 例

    #include <iostream>
    #include <complex>

    int main()
    {
      std::complex<float> c(1.0, 2.0);
      std::complex<float> d(2.0, 3.0);
      std::cout << c << " + " << d << " = " << (c + d) << std::endl;
      std::cout << c << " + " << 3.0F << " = " << (c + 3.0F) << std::endl;
      std::cout << 5.0F << " + " << d << " = " << (5.0F + d) << std::endl;
    }

### 出力

    (1,2) + (2,3) = (3,5)
    (1,2) + 3 = (4,2)
    5 + (2,3) = (7,3)

## 関連項目

名前 | 説明
--- | ---
`operator=` | 代入する。
`operator+=` | 複素数の加算を行う。
`operator-=` | 複素数の減算を行う。
`operator*=` | 複素数の乗算を行う。
`operator/=` | 複素数の除算を行う。
`operator-` | 複素数の減算を行う。（非メンバ関数）
`operator*` | 複素数の乗算を行う。（非メンバ関数）
`operator/` | 複素数の除算を行う。（非メンバ関数）

## 参照

- P0415R1 Constexpr for `std::complex`