Namespaces
Variants

std::common_iterator<I,S>:: operator*,->

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)
std::common_iterator
constexpr decltype ( auto ) operator * ( ) ;
(1) (depuis C++20)
constexpr decltype ( auto ) operator * ( ) const
requires /*dereferenceable*/ < const I > ;
(2) (depuis C++20)
constexpr auto operator - > ( ) const
requires /* voir description */ ;
(3) (depuis C++20)
Types auxiliaires
class /*proxy*/ {

std:: iter_value_t < I > keep_ ;
constexpr proxy ( std:: iter_reference_t < I > && x )
: keep_ ( std :: move ( x ) ) { }
public :
constexpr const std:: iter_value_t < I > * operator - > ( ) const noexcept {
return std:: addressof ( keep_ ) ;
}

} ;
(4) ( exposition uniquement* )

Retourne un pointeur ou une référence vers l'élément actuel, ou un proxy le contenant.

Le comportement n'est pas défini si l'objet membre sous-jacent std::variant var ne contient pas un objet de type I , c'est-à-dire si std:: holds_alternative < I > ( var ) est égal à false .

Soit it l'itérateur de type I détenu par var , c'est-à-dire std :: get < I > ( var ) .

1,2) Retourne le résultat du déréférencement de it .
3) Retourne un pointeur ou un itérateur sous-jacent vers l'élément actuel, ou un proxy le contenant :
  • Équivalent à return it ; , si I est un type pointeur ou si l'expression it. operator - > ( ) est bien formée.
  • Sinon, équivalent à auto && tmp = * it ; return std:: addressof ( tmp ) ; , si std:: iter_reference_t < I > est un type référence.
  • Sinon, équivalent à return proxy ( * it ) ; , où proxy est une classe d'exposition uniquement (4) .
L'expression dans la requires -clause est équivalente à
std:: indirectly_readable < const I > && (

requires ( const I & i ) { i. operator - > ( ) ; } ||
std:: is_reference_v < std:: iter_reference_t < I >> ||
std:: constructible_from < std:: iter_value_t < I > , std:: iter_reference_t < I >>

) .

Table des matières

Paramètres

(aucun)

Valeur de retour

1,2) Référence à l'élément actuel, ou prvalue temporaire. Équivalent à * it .
3) Pointeur ou itérateur vers l'élément courant ou proxy le contenant comme décrit ci-dessus.

Exemple

Exécuter ce code 
#include <complex>
#include <initializer_list>
#include <iostream>
#include <iterator>
using std::complex_literals::operator""i;
int main()
{
    const auto il = {1i, 3.14 + 2i, 3i, 4i, 5i};
    using CI = std::common_iterator<
        std::counted_iterator<decltype(il)::iterator>,
        std::default_sentinel_t>;
    CI ci{std::counted_iterator{std::next(begin(il), 1), std::ssize(il) - 1}};
    std::cout << *ci << ' ' << ci->real() << '\n';
}

Sortie : 

(3.14,2) 3.14

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 3574 C++20 variant était entièrement constexpr (P2231R1) mais common_iterator ne l'était pas également rendu constexpr
LWG 3595 C++20 les fonctions du type proxy manquaient de constexpr et noexcept ajoutés
LWG 3672 C++20 operator-> pouvait retourner par référence dans les cas usuels retourne toujours par valeur

Voir aussi

construit un nouveau common_iterator
(fonction membre publique)