View source for cpp/ranges/subrange

{{cpp/ranges/title|subrange}}
{{cpp/ranges/subrange/navbar}}

{{dcl begin}}
{{dcl header|ranges}}
{{dcl|num=1|since=c++20|1=
template<
    std::input_or_output_iterator I,
    std::sentinel_for<I> S = I,
    ranges::subrange_kind K = std::sized_sentinel_for<S, I> ?
                                  ranges::subrange_kind::sized :
                                  ranges::subrange_kind::unsized
>
    requires (K == ranges::subrange_kind::sized {{!!}}
                 !std::sized_sentinel_for<S, I>)
class subrange
    : public ranges::view_interface<subrange<I, S, K>>
}}
{{dcl h|Helper concepts}}
{{dcla|num=2|expos=yes|1=
template<class From, class To>
concept /*uses-nonqualification-pointer-conversion*/ =
    /* see description */;
}}
{{dcla|num=3|expos=yes|1=
template<class From, class To>
concept /*convertible-to-non-slicing*/ = /* see description */;
}}
{{dcl end}}

@1@ The {{tt|subrange}} class template combines together an iterator and a sentinel into a single {{lconcept|view}}. It models {{lconcept|sized_range}} whenever the final template parameter is {{c|subrange_kind::sized}} (which happens when {{c|std::sized_sentinel_for<S, I>}} is satisfied or when size is passed explicitly as a constructor argument).

@2@ Determintes whether {{tt|From}} is convertible to {{tt|To}} without {{lsd|cpp/language/implicit conversion#Qualification conversions}}. Equivalent to:
{{source|1=
template<class From, class To>
concept /*uses-nonqualification-pointer-conversion*/ =
    std::is_pointer_v<From> && std::is_pointer_v<To> &&
        !std::convertible_to<std::remove_pointer_t<From>(*)[],
                             std::remove_pointer_t<To>(*)[]>;
}}

@3@ Determintes whether {{tt|From}} is convertible to {{tt|To}} without derived-to-base conversion:
{{source|1=
template<class From, class To>
concept /*convertible-to-non-slicing*/ =
    std::convertible_to<From, To> &&
        !/*uses-nonqualification-pointer-conversion*/
            <std::decay_t<From>, std::decay_t<To>>;
}}

===Data members===
{{dsc begin}}
{{dsc hitem|Member|Definition}}
{{dsc expos mem sconst|spec={{c/core|constexpr bool}}|StoreSize|id=StoreSize|{{box|{{c/core|1=K == ranges::subrange_kind::sized &&}}<br>{{nbspt|4}}{{c/core|!std::sized_sentinel_for<S, I>}}}}}}
{{dsc expos mem obj|spec={{tt|I}}|begin_|id=begin|an iterator to the beginning of the subrange}}
{{dsc expos mem obj|spec={{tt|S}}|end_|id=end|a sentinel denoting the end of the subrange}}
{{dsc expos mem obj|spec={{lsi|cpp/ranges#make-unsigned-like-t}}{{sep}}{{c/core|<std::iter_difference_t<I>>}}|size_|id=size|maybe=(present only if {{tti|StoreSize}} is {{c|true}})|the size of the subrange}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor|cpp/ranges/subrange/subrange|creates a new {{tt|subrange}}}}
{{dsc inc|cpp/ranges/subrange/dsc operator PairLike}}

{{dsc h2|Observers}}
{{dsc inc|cpp/ranges/subrange/dsc begin}}
{{dsc inc|cpp/ranges/subrange/dsc end}}
{{dsc inc|cpp/ranges/subrange/dsc empty}}
{{dsc inc|cpp/ranges/subrange/dsc size}}

{{dsc h2|Iterator operations}}
{{dsc inc|cpp/ranges/subrange/dsc advance}}
{{dsc inc|cpp/ranges/subrange/dsc prev}}
{{dsc inc|cpp/ranges/subrange/dsc next}}

{{cpp/ranges/view_interface/inherit|embedded=yes|empty=yes|size=yes}}
{{dsc end}}

==={{rl|deduction guides|Deduction guides}}===

===Non-member functions===
{{dsc begin}}
{{dsc inc|cpp/ranges/subrange/dsc get}}
{{dsc end}}

===Helper types===
{{dsc begin}}
{{dsc inc|cpp/ranges/dsc subrange_kind}}
{{dsc inc|cpp/ranges/subrange/dsc tuple_size}}
{{dsc inc|cpp/ranges/subrange/dsc tuple_element}}
{{dsc end}}

===Helper templates===
{{ddcl|since=c++20|1=
template< class I, class S, ranges::subrange_kind K >
constexpr bool ranges::enable_borrowed_range<ranges::subrange<I, S, K>> = true;
}}
This specialization of {{c/core|ranges::enable_borrowed_range}} makes {{tt|subrange}} satisfy {{lconcept|borrowed_range}}.

===Example===
{{example
|code=
#include <map>
#include <print>
#include <ranges>
 
void make_uppercase(char& v)
{
    v += 'A' - 'a';
}
 
void uppercase_transform(std::multimap<int, char>& m, int k)
{
    auto [first, last] = m.equal_range(k);
    for (auto& [_, v] : std::ranges::subrange(first, last))
        make_uppercase(v);
}
 
int main()
{
    std::multimap<int, char> mm{<!---->{4, 'a'}, {3, '-'}, {4, 'b'}, {5, '-'}, {4, 'c'}<!---->};
    std::println("Before: {}", mm);
    uppercase_transform(mm, 4);
    std::println("After:  {}", mm);
}
|output=
Before: {3: '-', 4: 'a', 4: 'b', 4: 'c', 5: '-'}
After:  {3: '-', 4: 'A', 4: 'B', 4: 'C', 5: '-'}
}}

===Defect reports===
{{dr list begin}}
{{dr list item|wg=lwg|dr=3470|std=C++20|before={{tti|convertible-to-non-slicing}} might reject qualification conversions|after=always accepts them}}
{{dr list end}}

===See also===
{{dsc begin}}
{{dsc inc|cpp/ranges/dsc view_interface}}
{{dsc end}}

===External links===
{{eli|[https://stackoverflow.com/a/59659686 Read/write all values of a {{tt|std::multimap}} with a given key in C++20] &mdash; SO}}

{{langlinks|es|ja|ru|zh}}