Namespaces
Variants

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

    From es.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) (desde C++20)
    constexpr decltype ( auto ) operator * ( ) const
    requires /*dereferenceable*/ < const I > ;
    		(2) (desde C++20)
    constexpr auto operator - > ( ) const
    requires /* ver descripción */ ;
    		(3) (desde C++20)
    Tipos auxiliares
    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) ( solo para exposición* )

    Devuelve un puntero o referencia al elemento actual, o un proxy que lo contiene.

    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,2) Devuelve el resultado de desreferenciar it .
    3) Retorna un puntero o iterador subyacente al elemento actual, o un proxy que lo contiene:
    • Equivalente a return it ; , si I es un tipo puntero o si la expresión it. operator - > ( ) está bien formada.
    • En caso contrario, equivalente a auto && tmp = * it ; return std:: addressof ( tmp ) ; , si std:: iter_reference_t < I > es un tipo referencia.
    • En caso contrario, equivalente a return proxy ( * it ) ; , donde proxy es una clase solo de exposición (4) .
    La expresión en la cláusula requires es equivalente a
    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 >>

    )     .

    Contenidos

    Parámetros

    (ninguno)

    Valor de retorno

    1,2) Referencia al elemento actual, o valor temporal prvalue. Equivalente a * it .
    3) Puntero o iterador al elemento actual o proxy que lo contiene como se describió anteriormente.

    Ejemplo

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

    Salida: 

    (3.14,2) 3.14

    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
    LWG 3574 C++20 variant era completamente constexpr (P2231R1) pero common_iterator no lo era también hecho constexpr
    LWG 3595 C++20 las funciones del tipo proxy carecían de constexpr y noexcept añadidos
    LWG 3672 C++20 operator-> podría retornar por referencia en casos usuales siempre retorna por valor

    Véase también

    		construye un nuevo common_iterator
    (función miembro pública)