Namespaces
Variants

std:: indirectly_writable

From cppreference.net
C++
Iterator library
Iterator concepts
Iterator primitives
Algorithm concepts and utilities
Indirect callable concepts
Common algorithm requirements
(C++20)
(C++20)
(C++20)
Utilities
(C++20)
Iterator adaptors
Range access
(C++11) (C++14)
(C++14) (C++14)
(C++11) (C++14)
(C++14) (C++14)
(C++17) (C++20)
(C++17)
(C++17)
Definiert in Header <iterator>
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 std:: iter_reference_t < Out > && > ( * o ) = std:: forward < T > ( t ) ;
const_cast < const std:: iter_reference_t < Out > && > ( * std:: forward < Out > ( o ) ) =
std:: forward < T > ( t ) ;
} ;

/* keine der vier oben genannten Ausdrücke muss gleichheitserhaltend sein */
(seit C++20)

Das Konzept indirectly_writable < Out, T > spezifiziert die Anforderungen zum Schreiben eines Werts, dessen Typ und Wertkategorie durch T kodiert sind, in das referenzierte Objekt eines Iterators Out .

Semantische Anforderungen

Sei e ein Ausdruck, sodass decltype ( ( e ) ) gleich T ist, und o ein dereferenzierbares Objekt vom Typ Out , dann wird indirectly_writable < Out, T > nur modelliert, wenn:

o muss nach der Auswertung eines der obigen Zuweisungsausdrücke nicht dereferenzierbar sein. Wenn e ein X-Wert ist, ist der resultierende Zustand des Objekts, das es bezeichnet, gültig aber unspezifiziert.

Gleichheitserhaltung

Ausdrücke, die in requires expressions der Standardbibliothek-Konzepte deklariert werden, müssen equality-preserving sein (sofern nicht anders angegeben).

Hinweise

Die einzige gültige Verwendung von operator * ist auf der linken Seite eines Zuweisungsausdrucks. Die Zuweisung durch denselben Wert eines indirekt beschreibbaren Typs darf nur einmal erfolgen.

Die erforderlichen Ausdrücke mit const_cast verhindern, dass indirectly_readable -Objekte mit Prvalue- reference -Typen versehentlich die syntaktischen Anforderungen von indirectly_writable erfüllen, während Proxy-Referenzen weiterhin funktionieren, solange ihre Constness oberflächlich ist. Siehe Ranges TS Issue 381 . 

struct Object
{
    Object& operator=(const Object& other) = default;
    int x;
};
struct ProxyReference
{
    ProxyReference& operator=(const ProxyReference& other) = default;
    const ProxyReference& operator=(const Object& o) const
    {
        *p = o;
        return *this;
    }
    Object* p;
};
struct I1 { Object& operator*(); };
struct I2 { Object operator*(); };
struct I3 { ProxyReference operator*(); };
static_assert(std::indirectly_writable<I1, Object>);
static_assert(!std::indirectly_writable<I2, Object>);
static_assert(std::indirectly_writable<I3, Object>);
static_assert(!std::indirectly_writable<I3, ProxyReference>);
void f(I1 i1, I2 i2, I3 i3, Object o)
{
    *i1 = o;  // OK, weist dem durch *i1 referenzierten Wert zu
    *i2 = o;  // OK, aber bedeutungslos: Dies weist dem temporären Objekt zu, das von *i2 zurückgegeben wird
    *i3 = o;  // OK, ruft ProxyReference::operator=(const Object& o) const auf
              // was *ptr = o ausführt, wobei ptr (*i3).p ist
}