Ranges library (C++20)

The ranges library provides components for dealing with ranges of elements, including a variety of view adaptors.

`<ranges>` 에 정의되어 있음.
`namespace std { namespace views = ranges::views; }`		(since C++20)

The namespace alias std::views is provided as a shorthand for std::ranges::views.

Defined in namespace `std::ranges`
목차 1 Range access 2 Range primitives 3 Dangling iterator handling 4 Range concepts 5 Views 6 Range factories 7 Range adaptors 7.1 Range adaptor objects 7.2 Range adaptor closure objects 8 Helper concepts 9 Example 10 Defect reports Range access
`<ranges>` 헤더에 정의됨.
`<iterator>` 헤더에 정의됨.
ranges::begin (C++20)	범위(range)의 시작점을 가리키는 반복자를 반환합니다 (customization point object) [edit]
ranges::end (C++20)	범위의 끝 경계값을 반환합니다 (customization point object) [edit]
Range primitives
`<ranges>` 헤더에 정의됨.
Dangling iterator handling
`<ranges>` 헤더에 정의됨.
Range concepts
`<ranges>` 헤더에 정의됨.
Views
`<ranges>` 헤더에 정의됨.
ranges::subrange (C++20)	combines an iterator-sentinel pair into a `view` (class template) [edit]

Range factories

틀:cpp/ranges/dsc empty view 틀:cpp/ranges/dsc single view 틀:cpp/ranges/dsc iota view 틀:cpp/ranges/dsc basic istream view

`<ranges>` 헤더에 정의됨.
Defined in namespace `std::ranges`

Range adaptors

`<ranges>` 헤더에 정의됨.
Defined in namespace `std::ranges`

Some range adaptors wrap their elements or function objects with the copyable wrapper.

Range adaptor objects

Range adaptor objects are customization point objects that accept viewable_range as their first arguments and return a view. Some range adaptor objects are unary, i.e. they takes one viewable_range as its only argument. Other range adaptor objects takes a viewable_range and other trailing arguments.

If a range adaptor object takes more than one argument, it also supports partial application: let

a be such a range adaptor object, and
args... be arguments (generally suitable for trailing arguments),

expression a(args...) has following properties:

it is valid if and only if for every argument e in args... such that E is decltype((e)), std::is_constructible_v<std::decay_t<E>, E> is true,
when the call is valid, its result object stores a subobject of type std::decay_t<E> direct-non-list-initialized with std::forward<E>(e), for every argument e in args... (in other words, range adaptor objects bind arguments by value), and
the result object is a range adaptor closure object.

Like other customization point objects, let

a be an object of the cv-unqualified version of the type of any range adaptor objects,
args... be any group of arguments that satisfies the constraints of the operator() of the type of a,

calls to

a(args...),
std::as_const(a)(args...),
std::move(a)(args...), and
std::move(std::as_const(a))(args...)

are all equivalent.

The result object of each of these expressions is either a view object or a range adaptor closure object.

Notes: operator() is unsupported for volatile-qualified or const-volatile-qualified version of range adaptor object types. Arrays and functions are converted to pointers while binding.

Range adaptor closure objects

Range adaptor closure objects are objects whose type is the same as one of the following objects (ignoring cv-qualification):

unary range adaptor objects,
the results of binding trailing arguments by range adaptor objects, and
the results of chaining two range adaptor closure objects by operator|.

Range adaptor closure objects take one viewable_range as its only argument and return a view. They are callable via the pipe operator: if C is a range adaptor closure object and R is a viewable_range, these two expressions are equivalent (both well-formed or ill-formed):

C(R)
R | C

This call forwards the bound arguments (if any) to the associated range adaptor object. The bound arguments (if any) are identically treated as lvalue or rvalue and cv-qualified to C.

Two range adaptor closure objects can be chained by operator| to produce another range adaptor closure object: if C and D are range adaptor closure objects, then C | D is also a range adaptor closure object if it is valid.

The bound arguments of C | D is determined as follows:

there is a subobject in the result object of the same type (cv-qualification discarded) for every subobject in both operands that is a bound argument,
such a bound argument is direct-non-list-initialized with the source subobject in its containing operand, where the source is identically treated as lvalue or rvalue and cv-qualified to the operand,
the result is valid if and only if the initialization of all bound arguments are valid.

The effect and validity of the operator() of the result is determined as follows: given a viewable_range R, these two expressions are equivalent (both well-formed or ill-formed):

R | C | D // (R | C) | D
R | (C | D)

Notes: operator() is unsupported for volatile-qualified or const-volatile-qualified version of range adaptor object closure types.

Helper concepts

Following exposition-only concepts are used for several types, but they are not parts of the interface of standard library.

`template<class R> concept __SimpleView = // exposition only ranges::view<R> && ranges::range<const R> && std::same_as<std::ranges::iterator_t<R>, std::ranges::iterator_t<const R>> && std::same_as<std::ranges::sentinel_t<R>, std::ranges::sentinel_t<const R>>;`

Example

코드 실행

#include <ranges>
#include <iostream>

int main()
{
    auto const ints = {0,1,2,3,4,5};
    auto even = [](int i) { return 0 == i % 2; };
    auto square = [](int i) { return i * i; };

    // "pipe" syntax of composing the views:
    for (int i : ints | std::views::filter(even) | std::views::transform(square)) {
        std::cout << i << ' ';
    }

    std::cout << '\n';

    // a traditional "functional" composing syntax:
    for (int i : std::views::transform(std::views::filter(ints, even), square)) {
        std::cout << i << ' ';
    }
}

Output:

0 4 16
0 4 16

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR	Applied to	Behavior as published	Correct behavior
LWG 3509	C++20	it was unclear how range adaptor objects bound trailing arguments	they are bound by value

컴파일러 지원
Freestanding and hosted
언어
표준 라이브러리 헤더
명명된 요구사항
Feature test macros (C++20)
언어 지원 라이브러리
개념 (C++20)
Diagnostics library
유틸리티 라이브러리
문자열 라이브러리
컨테이너 라이브러리
반복자 라이브러리
범위 라이브러리 (C++20)
알고리즘 라이브러리
수치 라이브러리
지역화 라이브러리
입/출력 라이브러리
파일시스템 라이브러리 (C++17)
정규 표현식 라이브러리 (C++11)
아토믹 연산 라이브러리 (C++11)
쓰레드 지원 라이브러리 (C++11)
Technical specifications
Symbols index
외부 라이브러리들

cppreference.com

검색

이름공간

변수

보기

행위

Ranges library (C++20)

목차

Range access

Range primitives

Dangling iterator handling

Range concepts

Views