最終更新日時(UTC): 2019年04月05日 17時10分51秒
Akira Takahashi が更新

履歴 編集

function
<complex>

# std::complex::operator=

    complex<T>& operator=(const T& rhs);                    // (1) C++03
    constexpr complex<T>& operator=(const T& rhs);          // (1) C++20

    complex<T>& operator=(const complex<T>& rhs);           // (2) C++03
    constexpr complex<T>& operator=(const complex<T>& rhs); // (2) C++20

    template <class X>
    complex<T>& operator=(const complex<X>& rhs);           // (3) C++03
    template <class X>
    constexpr complex<T>& operator=(const complex<X>& rhs); // (3) C++20

## 概要

複素数の代入を行う

## 効果

- (1) スカラー値 `rhs` を `*this` の実部にコピー代入する。`*this` の虚部は`0.0`になる。
- (2) 複素数値 `rhs` を `*this` にコピー代入する。
- (3) 変換可能な複素数値 `rhs` を `*this` にコピー代入する。

## 戻り値

`*this`

## 備考

- (1) の形式の場合、引数の型は `const T&` なので、引数（演算子の右オペランド）の型が `T` ではない場合には暗黙の型変換が適用される。
  例えば、`T` が規格でサポートが明示されている `float`、`double`、`long double` の場合、各種の暗黙の標準変換が（縮小変換も含めて）効くため、`complex<float>` に `long double` を加えるといったこともできる。
- (2) の形式の場合、`rhs` の型はクラステンプレートなので、引数そのものに暗黙の型変換が適用されることはない。
  しかし、（規格書内に明確な規定は無いが）`*this` に `rhs` を加える際には各コンポーネント間の演算となるため、やはり暗黙の型変換が適用されると考えて良いと思われる。

## 例

    #include <iostream>
    #include <complex>

    int main()
    {
      std::complex<double> c(1.0, 2.0);
      std::complex<long double> d(2.0, 3.0);
      std::cout << "c = " << c << ", d = " << d << std::endl;
      c = d;
      std::cout << "c = " << c << ", d = " << d << std::endl;
      c = 7;
      std::cout << "c = " << c << ", d = " << d << std::endl;
    }

### 出力

    c = (1,2), d = (2,3)
    c = (2,3), d = (2,3)
    c = (7,0), d = (2,3)

## 関連項目

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

## 参照

- P0415R1 Constexpr for `std::complex`