std::indirectly_writable(C++20)

namespace std {
  template<class Out, class T>
  concept indirectly_writable = 
    requires(Out&& o, T&& t) {
      *o = std::forward<T>(t);
      *std::forward<Out>(o) = std::forward<T>(t);
      const_cast<const iter_reference_t<Out>&&>(*o) = std::forward<T>(t);
      const_cast<const iter_reference_t<Out>&&>(*std::forward<Out>(o)) = std::forward<T>(t);
    };
}

概要

indirectly_writableは、任意の型Outが間接参照演算子（operator*）によって型Tの値を書き込み（出力）可能であることを表すコンセプトである。

イテレータ型に限らず、ポインタ型、スマートポインタ型などがこのコンセプトのモデルとなることができる。

要件

このコンセプトを構成する4つの制約式は全て、等しさを保持することを要求しない。

const_castを用いる制約式は、右辺値に対しても代入できるがconstな右辺値では代入できなくなる非プロキシイテレータのprvalue（例えばstd::stringそのものなど）を返すイテレータを弾くためにある。これによって、間接参照がprvalueを返すようなイテレータ型はindirectly_writableのモデルとならないが、出力可能なプロキシオブジェクトを返すイテレータはindirectly_writableのモデルとなる事ができる。

モデル

decltype((E)) == Tとなるような式E及びdereferenceableな型Outのオブジェクトoについて次の条件を満たす場合に限って、型Out, Tはindirectly_writableのモデルである。

• Out, Tが次の制約式のモデルとなる場合、式Eを上記（定義内）式のいずれかの形で出力した後で、*oは元のEの値と等値（equal）になる。
  • ただし、そのような出力の後でoが間接参照可能である必要はない。

indirectly_readable<Out> && same_as<iter_value_t<Out>, decay_t<T>>

Eの値カテゴリがxvalueの場合、上記式による出力後Eのオブジェクトは有効だが未規定な状態となる

備考

indirectly_writableのモデルとなるOutのoperator*は出力（上記式による代入文の左辺に来ること）だけが唯一有効な使用法であり、indirectly_readableである必要はない。

例

#include <iostream>
#include <concepts>
#include <iterator>
#include <memory>
#include <vector>
#include <optional>

template<typename Out, typename T>
requires std::indirectly_writable<Out, T>
void f(const char* out, const char* t) {
  std::cout << out << " is indirectly writable " << t << std::endl;
}

template<typename Out, typename T>
void f(const char* out, const char* t) {
  std::cout << out << " is not indirectly writable " << t << std::endl;
}


struct writable {
  int& operator*();
};

struct not_writable {
  //prvalueを返す、出力不可能
  int operator*();
};


int main() {
  f<int*, int>("int*", "int");
  f<std::unique_ptr<int>, int&>("std::unique_ptr<int>", "int&");
  f<std::vector<int>::iterator, int&&>("std::vector<int>::iterator", "int&&");
  f<std::ostream_iterator<double>, double>("std::ostream_iterator<double>", "double");
  f<writable, int>("writable", "int");

  std::cout << "\n";
  f<std::vector<bool>::iterator, bool>("std::vector<bool>::iterator", "bool");
  f<std::optional<int>, int>("std::optional<int>", "int");
  f<not_writable, int>("not_writable", "int");
}

出力

int* is indirectly writable int
std::unique_ptr<int> is indirectly writable int&
std::vector<int>::iterator is indirectly writable int&&
std::ostream_iterator<double> is indirectly writable double
writable is indirectly writable int

std::vector<bool>::iterator is not indirectly writable bool
std::optional<int> is not indirectly writable int
not_writable is not indirectly writable int

バージョン

言語

• C++20

処理系

• Clang: ??
• GCC: 10.1
• Visual C++: 2019 Update 6

関連項目

• C++20 コンセプト

参照

• P0896R4 The One Ranges Proposal (was Merging the Ranges TS)
• P2214R0 A Plan for C++23 Ranges
  • const_castを用いる制約式についての説明がなされている