Início / coding / Perguntas / 79182541
Accepted
Serge Weinstock
Asked: 2024-11-13 03:50:58 +0800 CST

Qual conceito usar para verificar o tipo de valor de um iterador?

  • 772

Sou novo em conceitos e intervalos/visões.

Estou tentando escrever a inicialização de uma classe passando uma sequência de valores definidos por um iterador ou por um intervalo/visualização.

Eu consigo verificar se os argumentos da função são iteradores ou intervalos. Mas não consigo verificar se os valores retornados pelos iteradores são de um tipo específico.

Por exemplo (C++23):

#include <print>
#include <vector>

struct Data {
    int i;
    std::string l;
};

struct DataContainer {
    // iterator version
    // QUESTION: how can I check that I handles "Data"?
    template<std::input_iterator I, std::sentinel_for<I> S>
    void add(I start, S end) {
        for (auto data = start; data != end; ++data) {
            _data.push_back(*data);
        }
    }
    // range/views version
    // QUESTION: how can I check that R handles "Data"?
    template<std::ranges::input_range R>
    void add(R &&r) {
        add(std::begin(r), std::end(r));
    }
    void dump() const {
        for (const auto& d: _data){
            std::print("[{},'{}'], ", d.i, d.l);
        }
        std::println();
    }
    std::vector<Data> _data;
};

int main()
{
    std::vector<Data> init{{1, "one"}, {2, "two"}, {3, "three"}};
    {
        DataContainer dc;
        dc.add(init.begin(), init.end());
        dc.dump();
    }
    {
        DataContainer dc;
        dc.add(init);
        dc.dump();
    }
    return 0;
}

Como posso verificar se *startretorna um Data?

c++

3 respostas

  1. Para este:

        // iterator version
    // QUESTION: how can I check that I handles "Data"?
    template<std::input_iterator I, std::sentinel_for<I> S>
    void add(I start, S end) {
        for (auto data = start; data != end; ++data) {
            _data.push_back(*data);
        }
    }

    O tipo de *dataé iter_reference_t<I>. Isso é chamado de tipo de referência do iterador, o que é um pouco enganoso porque, na verdade, não precisa ser nenhum tipo de referência. Normalmente, os algoritmos devem ser restringidos com base no tipo de referência - é com isso que você realmente interage. Então, isso se torna:

    template <std::input_iterator I, std::sentinel_for<I> S>
  requires std::convertible_to<std::iter_reference_t<I>, Data>
void add(I, S);

    Você só deve usar o tipo de valor de um iterador se realmente precisar produzir valores.

    Para este:

        // range/views version
    // QUESTION: how can I check that R handles "Data"?
    template<std::ranges::input_range R>
    void add(R &&r) {

    A ideia é a mesma, só que é escrito std::ranges::range_reference_t<R>. Isto é definido como std::iter_reference_t<std::ranges::iterator_t<R>>(ou seja, o tipo de referência do intervalo é o tipo de referência do tipo iterador do intervalo).

    template <std::ranges::input_range R>
  requires std::convertible_to<std::ranges::range_reference_t<R>, Data>
void add(R &&r) {
  add(std::ranges::begin(r), std::ranges::end(r));
}

    Note que isso precisa usar std::ranges::{begin,end}, não std::{begin,end}. O último é incorreto para alguns tipos de intervalo - aqueles que definem begine endcomo funções não-membro que são encontradas pelo ADL, mas não estão em std.

    • 9
  2. Best Answer

    Em ambos os casos, você pode adicionar uma restrição:

    template <std::input_iterator I, std::sentinel_for<I> S>
    requires std::convertible_to<std::iter_value_t<I>, Data> // constraint added
void add(I start, S end) {
    // ...
}

template <std::ranges::input_range R>
    requires std::convertible_to<std::ranges::range_value_t<R>, Data> // constraint added
void add(R&& r) {
    // ...
}

    std::convertible_to:

    O conceito convertible_to<From, To>especifica que uma expressão do mesmo tipo e categoria de valor que aquelas de std::declval<From>()pode ser convertida implícita e explicitamente para o tipo To, e as duas formas de conversão produzem resultados iguais.

    std::iter_value_t

    1. Calcula o tipo de valor de T.
    • Se std::iterator_traits<std::remove_cvref_t<T>>não é especializado, então std::iter_value_t<T>é std::indirectly_readable_traits<std::remove_cvref_t<T>>::value_type.
    • Caso contrário, é std::iterator_traits<std::remove_cvref_t<T>>::value_type.

    std::ranges::range_value_t:

    Usado para obter o tipo de valor do tipo iterador do tipo intervalo R.

    Uma versão mais relaxada poderia usar std::constructible_fromem vez de std::convertible_to.

    • 5

  3. Barry deu uma resposta muito abrangente!

    Apenas como um pequeno acréscimo - se você usar algoritmos padrão (neste caso std::ranges::copy), o código pode ser mais conciso e requiresnão é necessário escrever nada adicional - ele é "costurado" no próprio algoritmo:

    template<std::ranges::input_range R>
void add1(R&& r) 
{
    std::ranges::copy(r, std::back_inserter(_data));
}
    • 0

relate perguntas