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) (desde C++20)
constexpr decltype ( auto ) operator ++ ( int ) ;
(2) (desde C++20)
Tipos auxiliares
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) ( solo para exposición* )

Incrementa el iterador subyacente.

El comportamiento es indefinido si el objeto miembro subyacente std::variant var no contiene un objeto de tipo I , es decir, si std:: holds_alternative < I > ( var ) es igual a false .

Sea it el iterador de tipo I contenido en var , es decir std :: get < I > ( var ) .

1) Pre-incrementa en uno. Equivalente a ++ it ; return * this ; .
2) Post-incremento en uno:
  • Equivalente a: auto tmp = * this ; ++* this ; return tmp ; , si I modela forward_iterator .
  • Equivalente a: return it ++ ; , si la definición de variable auto && ref = * it ++ ; está bien formada, o cualquiera de
es false .
  • Equivalente a: postfix_proxy p ( ** this ) ; ++* this ; return p ; en caso contrario, donde postfix_proxy es un tipo auxiliar solo para exposición (3) .

Contenidos

Parámetros

(ninguno)

Valor de retorno

1) * this
2) Una copia de * this que se realizó antes del cambio, o un resultado del post-incremento del iterador subyacente, o un proxy que mantiene el valor del elemento actual, como se describió anteriormente.

Ejemplo

Ejecutar este código 
#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';
}

Salida: 

1 2 3 4

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
P2259R1 C++20 el post incremento podría descartar su resultado en más situaciones se utiliza una clase proxy para mantener el resultado
LWG 3546 C++20 la inicialización del objeto proxy a veces era incorrecta situación y definición ajustadas
LWG 3574 C++20 variant era completamente constexpr (P2231R1) pero common_iterator no lo era también se hizo constexpr
LWG 3595 C++20 las funciones del tipo proxy carecían de constexpr y noexcept añadidas

Véase también

calcula la distancia entre dos adaptadores de iterador
(plantilla de función)