ranges_in_out_result.md

in_out_result

• algorithm[meta header]
• std::ranges[meta namespace]
• function template[meta id-type]
• cpp20[meta cpp]

namespace std::ranges {
  // (1)
  template<class I, class O>
  struct in_out_result {
    [[no_unique_address]] I in;
    [[no_unique_address]] O out;

    template<class I2, class O2>
      requires convertible_to<const I&, I2> && convertible_to<const O&, O2>
    constexpr operator in_out_result<I2, O2>() const & {
      return {in, out};
    }

    template<class I2, class O2>
      requires convertible_to<I, I2> && convertible_to<O, O2>
    constexpr operator in_out_result<I2, O2>() && {
      return {std::move(in), std::move(out)};
    }
  };

  // (2)
  template<class I, class O>
  using copy_result = in_out_result<I, O>;

  // (3)
  template<class I, class O>
  using copy_n_result = in_out_result<I, O>;

  // (4)
  template<class I, class O>
  using copy_if_result = in_out_result<I, O>;

  // (5)
  template<class I, class O>
  using copy_backward_result = in_out_result<I, O>;

  // (6)
  template<class I, class O>
  using move_result = in_out_result<I, O>;

  // (7)
  template<class I, class O>
  using move_backward_result = in_out_result<I, O>;

  // (8)
  template<class I, class O>
  using unary_transform_result = in_out_result<I, O>;

  // (9)
  template<class I, class O>
  using replace_copy_result = in_out_result<I, O>;

  // (10)
  template<class I, class O>
  using replace_copy_if_result = in_out_result<I, O>;

  // (11)
  template<class I, class O>
  using remove_copy_result = in_out_result<I, O>;

  // (12)
  template<class I, class O>
  using remove_copy_if_result = in_out_result<I, O>;

  // (13)
  template<class I, class O>
  using unique_copy_result = in_out_result<I, O>;

  // (14)
  template<class I, class O>
  using reverse_copy_result = in_out_result<I, O>;

  // (15)
  template<class I, class O>
  using rotate_copy_result = in_out_result<I, O>;

  // (16)
  template<class I, class O>
  using partial_sort_copy_result = in_out_result<I, O>;

  // (17)
  template<class I, class O>
  using set_difference_result = in_out_result<I, O>;
}

• no_unique_address[link /lang/cpp20/language_support_for_empty_objects.md]
• convertible_to[link /reference/concepts/convertible_to.md]
• std::move[link /reference/utility/move.md]

概要

• (1): 2つのイテレータを格納する型
• (2): ranges::copyで使用するエイリアス
• (3): ranges::copy_nで使用するエイリアス
• (4): ranges::copy_ifで使用するエイリアス
• (5): ranges::copy_backwardで使用するエイリアス
• (6): ranges::moveで使用するエイリアス
• (7): ranges::move_backwardで使用するエイリアス
• (8): ranges::transformで使用するエイリアス
• (9): ranges::replace_copyで使用するエイリアス
• (10): ranges::replace_copy_ifで使用するエイリアス
• (11): ranges::remove_copyで使用するエイリアス
• (12): ranges::remove_copy_ifで使用するエイリアス
• (13): ranges::unique_copyで使用するエイリアス
• (14): ranges::reverse_copyで使用するエイリアス
• (15): ranges::rotate_copyで使用するエイリアス
• (16): ranges::partial_sort_copyで使用するエイリアス
• (17): ranges::set_differenceで使用するエイリアス

この型は、関数が入力用と出力用に範囲を受け取る場合に、それぞれ処理した範囲の末尾を返すために使用される。

標準アルゴリズム関数ではこの型を直接返す代わりに、関数毎にエイリアスを定義している。

メンバ変数

名前	説明	対応バージョン
[[no_unique_address]] I in	処理した範囲の末尾	C++20
[[no_unique_address]] O out	出力した範囲の末尾	C++20

メンバ関数

名前	説明	対応バージョン
operator in_out_result<I2, O2>	変換演算子	C++20

変換演算子は、各テンプレートパラメーターが変換できる場合のみオーバーロード解決に参加する。

例

#include <cassert>
#include <algorithm>
#include <vector>

int main() {
  std::vector<int> v = { 1, 2, 3 };
  std::vector<int> v2(5);

  const std::ranges::in_out_result result = std::ranges::copy(v, v2.begin());

  assert(result.in == v.end());
  assert(result.out == v2.begin() + 3);
}

• std::ranges::in_out_result[color ff0000]
• std::ranges::copy[link ranges_copy.md]

出力

バージョン

言語

• C++20

処理系

• Clang: ??
• GCC: 10.1.0
• ICC: ??
• Visual C++: 2019 Update 10

参照

• N4861 25 Algorithms library