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)
Défini dans l'en-tête <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 ) ;
} ;

/* aucune des quatre expressions ci-dessus n'est requise pour préserver l'égalité */
(depuis C++20)

Le concept indirectly_writable < Out, T > spécifie les exigences pour écrire une valeur dont le type et la catégorie de valeur sont encodés par T dans l'objet référencé par un itérateur Out .

Exigences sémantiques

Soit e une expression telle que decltype ( ( e ) ) est T , et o un objet déréférençable de type Out , alors indirectly_writable < Out, T > est modélisé seulement si :

o n'est pas requis d'être déréférençable après l'évaluation de l'une quelconque des expressions d'affectation ci-dessus. Si e est une xvalue, l'état résultant de l'objet qu'elle désigne est valide mais non spécifié.

Préservation de l'égalité

Les expressions déclarées dans les requires expressions des concepts de la bibliothèque standard doivent être equality-preserving (sauf indication contraire).

Notes

La seule utilisation valide de operator * est sur le côté gauche d'une expression d'affectation. L'affectation via la même valeur d'un type indirectement inscriptible ne peut se produire qu'une seule fois.

Les expressions requises avec const_cast empêchent les objets indirectly_readable avec des types prvalue reference de satisfaire accidentellement aux exigences syntaxiques de indirectly_writable , tout en permettant aux références proxy de continuer à fonctionner tant que leur constance est superficielle. Voir 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, assigne à la valeur référencée par *i1
    *i2 = o;  // OK, mais sans signification : Ceci assigne au temporaire retourné par *i2
    *i3 = o;  // OK, appelle ProxyReference::operator=(const Object& o) const
              // qui effectue *ptr = o, où ptr est (*i3).p
}