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 common_iterator & operator ++ ( ) ;
(1) (depuis C++20)
constexpr decltype ( auto ) operator ++ ( int ) ;
(2) (depuis C++20)
Types auxiliaires
class /*postfix_proxy*/ {

std:: iter_value_t < I > keep_ ;
constexpr postfix_proxy ( std:: iter_reference_t < I > && x )
: keep_ ( std:: forward < std:: iter_reference_t < I >> ( x ) ) { }
public :
constexpr const std:: iter_value_t < I > & operator * ( ) const noexcept {
return keep_ ;
}

} ;
(3) ( exposition uniquement* )

Incrémente l'itérateur sous-jacent.

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) Pré-incrémente de un. Équivalent à ++ it ; return * this ; .
2) Post-incrémente de un :
  • Équivalent à : auto tmp = * this ; ++* this ; return tmp ; , si I modélise forward_iterator .
  • Équivalent à : return it ++ ; , si la définition de variable auto && ref = * it ++ ; est bien formée, ou si l'une des conditions suivantes est
est false .
  • Équivalent à : postfix_proxy p ( ** this ) ; ++* this ; return p ; sinon, où postfix_proxy est un type d'aide à titre d'exposition uniquement (3) .

Table des matières

Paramètres

(aucun)

Valeur de retour

1) * this
2) Une copie de * this qui a été faite avant le changement, ou un résultat du post-incrément de l'itérateur sous-jacent, ou un proxy conservant la valeur de l'élément actuel, comme décrit ci-dessus.

Exemple

Exécuter ce code 
#include <algorithm>
#include <initializer_list>
#include <iostream>
#include <iterator>
int main()
{
    const auto il = {1, 2, 3, 4, 5, 6};
    using CI = std::common_iterator<
                   std::counted_iterator<std::initializer_list<int>::iterator>,
                   std::default_sentinel_t
                   >;
    CI first{std::counted_iterator{std::begin(il), std::ssize(il) - 2}};
    for (; first != std::default_sentinel; ++first)
        std::cout << *first << ' ';
    std::cout << '\n';
}

Sortie : 

1 2 3 4

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é
P2259R1 C++20 l'incrémentation postérieure pourrait ignorer son résultat dans plus de situations une classe proxy est utilisée pour conserver le résultat
LWG 3546 C++20 l'initialisation de l'objet proxy était parfois mal formée situation et définition ajustées
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

Voir aussi

calcule la distance entre deux adaptateurs d'itérateur
(modèle de fonction)