Namespaces
Variants

Non-propagating cache (C++20)

From cppreference.net
C++
Ranges library
Range adaptors
Helper items
(until C++23) (C++23)
non-propagating-cache


template < class T >

requires std:: is_object_v < T >

class /*non-propagating-cache*/ ;
(depuis C++20)
( exposition uniquement* )

Certains adaptateurs de gamme tels que ranges::join_view et ranges::lazy_split_view stockent conditionnellement une valeur (par exemple un itérateur) qui est spécifiée en termes d'un modèle de classe d'exposition uniquement non-propagating-cache .

Le wrapper se comporte exactement comme std:: optional < T > , sauf que :

  • il ne copie pas la valeur de la source lorsqu'il est copié-construit ou assigné,
  • il réinitialise la valeur de la source lorsqu'il est déplacé,
  • il réinitialise sa propre valeur lorsqu'il est assigné, et
  • il fournit en outre un modèle de fonction membre pour permettre à une vue d'entrée de mettre temporairement en cache les valeurs pendant son parcours.

L'encapsuleur encapsule un cache contenant une valeur. Vider le cache est une opération équivalente à réinitialiser une valeur contenue. Cette opération est effectuée lors de la copie ou du déplacement d'un encapsuleur.

Table des matières

Paramètres du modèle

T - le type de la valeur contenue, doit être un type objet

Fonctions membres

Constructeurs de copie et de déplacement

constexpr /*non-propagating-cache*/
( const /*non-propagating-cache*/ & ) noexcept { }
(1) (depuis C++20)
constexpr /*non-propagating-cache*/
( /*non-propagating-cache*/ && other ) noexcept { other. reset ( ) ; }
(2) (depuis C++20)
1) Le constructeur de copie n'a aucun effet.
2) Le constructeur de déplacement vide le cache de other .

Opérateurs d'affectation par copie et par déplacement

constexpr /*non-propagating-cache*/ &

operator = ( const /*non-propagating-cache*/ & other ) noexcept
{
if ( std:: addressof ( other ) ! = this )
reset ( ) ;
return * this ;

}
(1) (depuis C++20)
constexpr /*non-propagating-cache*/ &

operator = ( /*non-propagating-cache*/ && other ) noexcept
{
reset ( ) ;
other. reset ( ) ;
return * this ;

}
(2) (depuis C++20)
1) L'opérateur d'affectation par copie vide le cache de * this .
2) L'opérateur d'affectation par déplacement vide les caches de * this et de other .

non-propagating-cache <T>:: emplace-deref

template < class I >
constexpr T & /*emplace-deref*/ ( const I & i ) ;
(depuis C++20)
( exposition uniquement* )

Initialise la valeur contenue par initialisation directe (mais pas l'initialisation directe de liste) avec * i . Si * this contient déjà une valeur avant l'appel, reset ( ) est appelé.

Retourne une référence à la nouvelle valeur contenue.

Le programme est mal formé sauf si la déclaration T t ( * i ) ; est bien formée pour une variable inventée t . Si * i est une prvalue de T éventuellement qualifié cv, alors elle n'a pas besoin d'être déplaçable.

Membres identiques à std:: optional

Fonctions membres

construit l'objet optional
(fonction membre publique de std::optional<T> )
détruit la valeur contenue, s'il y en a une
(fonction membre publique de std::optional<T> )
assigne le contenu
(fonction membre publique de std::optional<T> )
Observateurs
accède à la valeur contenue
(fonction membre publique de std::optional<T> )
vérifie si l'objet contient une valeur
(fonction membre publique de std::optional<T> )
Modificateurs
détruit toute valeur contenue
(fonction membre publique de std::optional<T> )
construit la valeur contenue en place
(fonction membre publique de std::optional<T> )

Notes

non-propagating-cache est utilisé dans les implémentations pour mettre en cache le résultat de begin ( ) afin de fournir une complexité temporelle amortie constante de la méthode.

Voir aussi

(C++20)
une view constituée de la séquence obtenue en aplatissant une view de range s
(modèle de classe) (objet adaptateur de range)
(C++23)
une view constituée de la séquence obtenue en aplatissant une view de ranges, avec le délimiteur entre les éléments
(modèle de classe) (objet adaptateur de range)
(C++20)
une view sur les sous-ranges obtenus en divisant une autre view en utilisant un délimiteur
(modèle de classe) (objet adaptateur de range)
(C++20)
une view sur les sous-ranges obtenus en divisant une autre view en utilisant un délimiteur
(modèle de classe) (objet adaptateur de range)
(C++23)
un range de view s qui sont des chunks successifs non chevauchants de taille N des éléments d'une autre view
(modèle de classe) (objet adaptateur de range)