Início / coding / Perguntas / 78827063
Accepted
rodrigocfd
Asked: 2024-08-03 03:56:39 +0800 CST

Como escrever uma função C++ 20 aceitando um intervalo com T e const T?

  • 772

Eu defini a seguinte função:

template<
    std::ranges::contiguous_range R,
    typename T = std::ranges::range_value_t<R>
>
std::span<T> foo(R&& r, const T& someValue) {
    std::span<T> sp{r.begin(), r.end()};
    /// ...
    return sp;
}

Agora tenho três casos de uso:

std::vector<std::string> baseVec;
auto a = foo(baseVec, {""});

std::span<std::string> sp{baseVec};
auto b = foo(sp, {""});

const std::vector<std::string>& ref = baseVec;
auto c = foo(ref, {""}); // <------------------ problem here!

Pelo que entendi, foo(ref)não será possível compilar porque o spaninterior criado fooé do tipo span<T>, enquanto neste caso deveria ser span<const T>.

Então, como posso escrever foode forma que aceite todos os três casos?

c++

2 respostas

  1. Best Answer

    A questão é que o valor value_typede um intervalo nunca é constqualificado. Mas referenceo tipo de intervalo poderia ser - embora isso ainda esteja errado porque seria string const&.

    Os iteradores contíguos são obrigados a ter seu tipo de referência for U&some type U, portanto, se simplesmente descartarmos a referência final, obteremos um tipo potencialmente qualificado para const:

    template<
    std::ranges::contiguous_range R,
    typename T = std::remove_reference_t<std::ranges::range_reference_t<R>>
>
std::span<T> foo(R&& r, const T& someValue) {
    std::span<T> sp(r);
    /// ...
    return sp;
}

    Observe que você não precisa passar r.begin()e r.end()into span, spanpossui um construtor de intervalo.

    No entanto, isso ainda não está correto porque o original também estava errado. contiguousé um critério insuficiente aqui, também precisamos que o intervalo seja sizedpara que possamos construir um valor spana partir dele:

    template<
    std::ranges::contiguous_range R,
    typename T = std::remove_reference_t<std::ranges::range_reference_t<R>>
>
    requires std::ranges::sized_range<R>
std::span<T> foo(R&& r, const T& someValue) {
    std::span<T> sp(r);
    /// ...
    return sp;
}

    Além disso, você provavelmente não deseja deduzir Tdo argumento - você realmente deseja que seja especificamente o correto Tassociado ao intervalo:

    template<
    std::ranges::contiguous_range R,
    typename T = std::remove_reference_t<std::ranges::range_reference_t<R>>
>
    requires std::ranges::sized_range<R>
std::span<T> foo(R&& r, std::type_identity_t<T> const& someValue) {
    std::span<T> sp(r);
    /// ...
    return sp;
}

    Observe que alterei seu código para construir spanusando parênteses em vez de colchetes. Isso ocorre porque passar um par de iteradores para um inicializador usando chaves não é uma boa ideia, porque poderia facilmente fazer a coisa errada. Considerar:

    auto x = std::vector{1, 2, 3, 4};

auto a = std::vector(x.begin(), x.end()); // four ints: [1, 2, 3, 4]
auto b = std::vector{x.begin(), x.end()}; // two iterators: [x.begin(), x.end()]

    E o mesmo vale para span, que terá um initializer_listconstrutor começando em C++26.

    • 6

  2. Você pode seguir o caminho proverbial. Se o compilador for tão inteligente, deixe-o descobrir o tipo sozinho. Com a dedução de argumentos do modelo de classe, é possível.

    template<
    std::ranges::contiguous_range R,
    typename T = std::ranges::range_value_t<R>
>
auto foo(R&& r, const T&) {
    std::span sp (r.begin(), r.end()); // CTAD + auto return type
    /// ...
    return sp;
}
    • 1

relate perguntas