26
Ranges library
[ranges]
26.7
Range adaptors
[range.adaptors]
26.7.20
Common view
[range.common]
26.7.20.1
Overview
[range.common.overview]
1
#
common_
view
takes a view which has different types for its iterator and sentinel and turns it into a view of the same elements with an iterator and sentinel of the same type
.
2
#
[
Note
1
:
common_
view
is useful for calling legacy algorithms that expect a range's iterator and sentinel types to be the same
.
—
end note
]
3
#
The name
views
::
common
denotes a range adaptor object (
[range.
adaptor.
object]
)
.
Given a subexpression
E
, the expression
views
::
common
(
E
)
is expression-equivalent to:
(3.1)
views
::
all
(
E
)
, if
decltype
(
(
E
)
)
models
common_
range
and
views
::
all
(
E
)
is a well-formed expression
.
(3.2)
Otherwise,
common_
view
{
E
}
.
4
#
[
Example
1
:
// Legacy algorithm:
template
<
class
ForwardIterator
>
size_t count
(
ForwardIterator first, ForwardIterator last
)
;
template
<
forward_
range
R
>
void
my_algo
(
R
&
&
r
)
{
auto
&
&
common
=
views
::
common
(
r
)
;
auto
cnt
=
count
(
common
.
begin
(
)
, common
.
end
(
)
)
;
// ...
}
—
end example
]
26.7.20.2
Class template
common_
view
[range.common.view]
🔗
namespace
std
::
ranges
{
template
<
view
V
>
requires
(
!
common_
range
<
V
>
&
&
copyable
<
iterator_t
<
V
>
>
)
class
common_view
:
public
view_interface
<
common_view
<
V
>
>
{
private
:
V
base_
=
V
(
)
;
//
exposition only
public
:
common_view
(
)
requires
default_
initializable
<
V
>
=
default
;
constexpr
explicit
common_view
(
V r
)
;
constexpr
V base
(
)
const
&
requires
copy_
constructible
<
V
>
{
return
base_
;
}
constexpr
V base
(
)
&
&
{
return
std
::
move
(
base_
)
;
}
constexpr
auto
begin
(
)
requires
(
!
simple-view
<
V
>
)
{
if
constexpr
(
random_
access_
range
<
V
>
&
&
sized_
range
<
V
>
)
return
ranges
::
begin
(
base_
)
;
else
return
common_iterator
<
iterator_t
<
V
>
, sentinel_t
<
V
>
>
(
ranges
::
begin
(
base_
)
)
;
}
constexpr
auto
begin
(
)
const
requires
range
<
const
V
>
{
if
constexpr
(
random_
access_
range
<
const
V
>
&
&
sized_
range
<
const
V
>
)
return
ranges
::
begin
(
base_
)
;
else
return
common_iterator
<
iterator_t
<
const
V
>
, sentinel_t
<
const
V
>
>
(
ranges
::
begin
(
base_
)
)
;
}
constexpr
auto
end
(
)
requires
(
!
simple-view
<
V
>
)
{
if
constexpr
(
random_
access_
range
<
V
>
&
&
sized_
range
<
V
>
)
return
ranges
::
begin
(
base_
)
+
ranges
::
distance
(
base_
)
;
else
return
common_iterator
<
iterator_t
<
V
>
, sentinel_t
<
V
>
>
(
ranges
::
end
(
base_
)
)
;
}
constexpr
auto
end
(
)
const
requires
range
<
const
V
>
{
if
constexpr
(
random_
access_
range
<
const
V
>
&
&
sized_
range
<
const
V
>
)
return
ranges
::
begin
(
base_
)
+
ranges
::
distance
(
base_
)
;
else
return
common_iterator
<
iterator_t
<
const
V
>
, sentinel_t
<
const
V
>
>
(
ranges
::
end
(
base_
)
)
;
}
constexpr
auto
size
(
)
requires
sized_
range
<
V
>
{
return
ranges
::
size
(
base_
)
;
}
constexpr
auto
size
(
)
const
requires
sized_
range
<
const
V
>
{
return
ranges
::
size
(
base_
)
;
}
}
;
template
<
class
R
>
common_view
(
R
&
&
)
-
>
common_view
<
views
::
all_t
<
R
>
>
;
}
🔗
constexpr
explicit
common_view
(
V base
)
;
1
#
Effects
: Initializes
base_
with
std
::
move
(
base
)
.