다음을 통해 공유

<ranges> 별칭 템플릿

  • 아티클

별칭 템플릿은 코드를 더 읽기 쉽게 만들 수 있는 다른 형식의 별칭입니다. 예를 들어 다음 별칭은 전달되는 종류 range 에 따라 범위 또는 dangling borrowed_range 범위에 대한 별칭conditional_t입니다.

// requires /std:c++20, or later

#include <iostream>
#include <list>
#include <span>
#include <algorithm>
#include <ranges>
#include <type_traits>

using namespace std;

// Define an alias template called my_iterator_t
// If the provided range R is a borrowed_range, then the 
// returned type is iterator_t<R>; otherwise, ranges::dangling
template<ranges::range R>
using my_iterator_t = conditional_t<
    ranges::borrowed_range<R>,
    ranges::iterator_t<R>, ranges::dangling>;

int main()
{
    my_iterator_t<list<int>> aDanglingRange; // list<> isn't a borrowed_range
    constexpr bool same = same_as<
        decltype(aDanglingRange),
        ranges::dangling>; // true

    my_iterator_t<span<int, 5>> anIterator_t; // span<> is a borrowed_range
    constexpr bool same2 = same_as<
        decltype(anIterator_t),
        ranges::iterator_t<span<int, 5>>>; // true

    cout << boolalpha << same << "," << same2; // outputs true, true
}

별칭 템플릿에 대한 자세한 내용은 별칭 및 typedefs를 참조 하세요.

헤더는 <algorithm> 반복기 및 센티넬의 형식을 결정하는 다음 별칭 템플릿을 정의합니다.range

별칭 템플릿 설명
borrowed_iterator_tC++20 반환된 반복기가 range 수명이 종료된 범위를 참조하는지 확인합니다.
borrowed_subrange_tC++20 반환 range 된 subrange 수명이 종료된 범위를 참조하는지 확인합니다.
danglingC++20 반환된 반복기가 range/subrange 참조하는 수 range/subrange 명보다 오래 있음을 나타냅니다.
iterator_tC++20 지정된 범위에 대한 반복기 형식을 반환합니다.
range_difference_tC++20 지정된 범위의 반복기에 대한 차이 형식을 반환합니다.
range_reference_tC++20 지정된 범위의 반복기에 대한 참조 형식을 반환합니다.
range_rvalue_reference_tC++20 지정된 범위의 반복기에 대한 rvalue 참조 형식을 반환합니다. 즉, 범위 요소의 rvalue 참조 형식입니다.
range_size_tC++20 지정된 범위의 를 보고하는 데 사용되는 형식을 반환합니다 size.
range_value_tC++20 지정된 범위 반복기의 값 형식을 반환합니다. 즉, 범위에 있는 요소의 형식입니다.
sentinel_tC++20 지정된 범위에 대한 sentinel 형식을 반환합니다.

borrowed_iterator_t

반복기를 반환하는 알고리즘 함수가 rvalue range 인수를 사용하여 호출되면 호출 후 범위의 수명이 종료됩니다. 즉, 반환된 반복기는 수명이 종료된 요소를 참조할 수 있습니다. 현수 반복기를 사용하면 정의되지 않은 동작이 발생합니다.

이 템플릿 별칭은 지정된 범위 인수의 상황임을 나타내거나 모델을 borrowed_range 참조하는 범위 또는 std::ranges::iterator_t<R> 범위가 lvalue로 전달되었기 때문에 반환된 반복기를 사용하는 것이 안전하다는 것을 나타내기 위해 반환 ranges::dangling 됩니다.

template<ranges::range R>
using borrowed_iterator_t = conditional_t<ranges::borrowed_range<R>,
    ranges::iterator_t<R>, ranges::dangling>;

매개 변수

R
테스트할 범위입니다.

설명

rvalue 범위의 수명은 범위 모델 borrowed_range 여부에 관계없이 함수 호출 후에 끝날 수 있습니다. 이 경우 범위의 borrowed_range수명이 종료되는 시기에 관계없이 잘 정의된 동작으로 반복기를 계속 사용할 수 있습니다.

예를 들어 컨테이너와 같은 vector 경우 또는 list 컨테이너의 수명이 종료될 때 반복기가 제거된 요소를 참조하기 때문에 이러한 경우가 사실이 아닙니다.

예를 들어 view iota_view<int>{0, 42} 반복기가 borrowed_range요청 시 생성되므로 삭제되지 않는 값 집합을 초과하여 반복기를 계속 사용할 수 있습니다.

반복기가 수명에 ranges::dangling 종속된 범위를 알고리즘 함수에 전달하면 반복기 또는 하위 범위 대신 반환되므로 컴파일 시간에 잠재적인 오용이 검색됩니다.

예: borrowed_iterator_t

다음 예제에서는 현수 반복기를 검색하는 방법을 borrowed_iterator_t 보여 줍니다. 함수 ranges::max_element() 는 이 템플릿 별칭을 사용하여 반환 형식을 확인합니다.

// requires /std:c++20, or later

#include <vector>
#include <span>
#include <ranges>
#include <iostream>
#include <algorithm>

using namespace std;

int main()
{
    // Not dangling ------------------

    int a[] = {0,1,2,3};

    // not dangling even though an rvalue because span models ranges::borrowed
    auto result1 = ranges::max_element(span{a});
    cout << boolalpha << ranges::borrowed_range<decltype(span{a})> << endl; // outputs true because the temporary models ranges::borrowed
    cout << same_as<decltype(result1), ranges::dangling> << endl; // outputs false because the result isn't dangling

    vector<int> v{0,1,2,3}; // doesn't model ranges::borrowed
    auto result2 = ranges::max_element(v); // Yet not dangling because passed as an lvalue
    cout << same_as<decltype(result2), ranges::dangling> << endl; // outputs false because the result isn't dangling
    
    // Dangling ------------------

    auto result3 = ranges::max_element(vector{0,1,2,3}); // dangling because vector doesn't model ranges::borrowed and is passed as an rvalue
    cout << same_as<decltype(result3), ranges::dangling>; // outputs true because the result is dangling
}

true
false
false
true

borrowed_subrange_t

rvalue range 인수를 subrange 사용하여 반환하는 알고리즘 함수가 호출되면 호출 후 범위의 수명이 종료됩니다. 즉, 반환 subrange 된 수명이 종료된 요소를 참조할 수 있습니다. 현수 subrange 동작을 사용하면 정의되지 않은 동작이 발생합니다.

이 템플릿 별칭은 지정된 범위 인수의 상황이 될 수 있음을 나타내거나 subrange<ranges::iterator_t<R>> 반환된 하위 범위를 사용하는 것이 안전하다는 것을 나타내기 위해 반환 ranges::dangling 됩니다. 모델 borrowed_range 또는 범위를 참조하는 요소가 lvalue로 전달된 범위이기 때문입니다.

template<ranges::range R>
using borrowed_subrange_t = conditional_t<ranges::borrowed_range<R>,
    ranges::subrange<ranges::iterator_t<R>>, ranges::dangling>;

매개 변수

R
테스트할 범위입니다.

설명

rvalue 범위의 수명은 범위 모델 borrowed_range 여부에 관계없이 함수 호출 후에 끝날 수 있습니다. 이 경우 범위의 borrowed_range수명이 종료되는 시기에 관계없이 잘 정의된 동작으로 반복기를 계속 사용할 수 있습니다.

예를 들어 컨테이너와 같은 vector 경우 또는 list 컨테이너의 수명이 종료될 때 반복기가 제거된 요소를 참조하기 때문에 이러한 경우가 사실이 아닙니다.

예를 들어 view iota_view<int>{0, 42} 반복기가 borrowed_range요청 시 생성되므로 삭제되지 않는 값 집합을 초과하여 반복기를 계속 사용할 수 있습니다.

알고리즘 함수가 반복기가 수명에 ranges::dangling 종속된 범위를 전달하면 컴파일 시간에 잠재적인 오용이 검색되도록 하위 범위 대신 반환됩니다.

예: borrowed_subrange_t

다음 예제에서는 이 템플릿 별칭을 사용하여 반환 형식을 확인하므로 현수 반복기를 equal_range() max_element 검색하는 방법을 borrowed_subrange_t 보여 줍니다.

// requires /std:c++20, or later

#include <vector>
#include <iostream>
#include <algorithm>
#include <span>
#include <ranges>

int main()
{
    using namespace std;

    // Not dangling ------------------

    vector vec{0, 1, 1, 2};

    auto result1 = ranges::equal_range(span{vec}, 1); // not dangling even though passing as an rvalue because span models borrowed_range
    cout << boolalpha << ranges::borrowed_range<decltype(span{vec})> << endl;  // true because the temporary is a borrowed range
    cout << boolalpha << same_as<decltype(result1), ranges::dangling> << endl; // false because the result isn't dangling

    // result2 isn't dangling even though vec doesn't model ranges::borrowed because it's an lvalue
    auto result2 = ranges::max_element(vec);
    cout << boolalpha << ranges::borrowed_range<decltype(vec)> << endl;  // false because vector isn't a borrowed_range
    cout << boolalpha << same_as<decltype(result2), ranges::dangling> << endl; // false because the result isn't dangling

    // Dangling -----------------------

    // result3 is dangling because the temporary is an rvalue that doesn't model borrowed_range
    auto result3 = ranges::max_element(vector{0,1,1,2});
    cout << boolalpha << same_as<decltype(result3), ranges::dangling> << endl; // true because the result is dangling
}

true
false
false
false
true

dangling

반복기를 반환하거나 subrange rvalue range 인수를 사용하여 호출하는 알고리즘 함수가 호출된 후 범위 인수의 수명이 끝날 수 있습니다. 즉, 반환된 반복기를 의미하거나 subrange 수명이 종료된 요소를 참조할 수 있습니다. 현수 반복기를 사용하거나 subrange 정의되지 않은 동작이 발생합니다.

반복기가 수명에 ranges::dangling 종속된 범위를 알고리즘 함수에 전달하면 컴파일 시간에 잠재적인 오용이 검색되도록 반복기 또는 하위 범위 대신 반환됩니다.

1) constexpr dangling() noexcept = default;
2) template<class... Args>
constexpr dangling(Args&&...) noexcept {}

매개 변수

Args
비 형식void 의 가변 수입니다. 그들은 아무런 영향을 미치지 않습니다. 인수는 반복기 형식과 형식의 생성을 처리하기 위해 다른 코드 경로가 필요하지 않도록 편리합니다 dangling . 이는 전달된 값이 반복기 대신 반환되어야 임을 dangling 나타내는 경우에 유용합니다.

예: dangling

다음 예제에서는 현수 반복기를 검색하는 방법을 max_element 보여 줍니다.

// requires /std:c++20, or later

#include <vector>
#include <iostream>
#include <ranges>
#include <algorithm>

using namespace std;

int main()
{
    auto result1 = ranges::max_element(vector{1,2,3}); // dangling because vector doesn't model ranges::borrowed and is passed as an rvalue
    cout << boolalpha << same_as<decltype(result1), ranges::dangling> << endl; // outputs true because the result is dangling

    vector<int> v{3,4,5};
    auto result2 = ranges::max_element(v); // Not dangling because passed as an lvalue
    cout << same_as<decltype(result2), ranges::dangling>; // outputs false because the result isn't dangling
}

true
false

iterator_t

이 템플릿 별칭은 제공된 범위 형식을 반복하는 데 사용되는 반복기 형식을 반환합니다.

template<class T>
using iterator_t = decltype(ranges::begin(declval<T&>()));

매개 변수

T
반복기 형식을 가져올 범위 형식입니다.

예: iterator_t

다음 예제에서는 벡터에 대한 반복기를 선언하는 데 사용할 수 있는 방법을 iterator_t 보여줍니다.

// requires /std:c++20, or later

#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    using namespace std;

    vector<int> v{1,2,3};

    ranges::iterator_t<decltype(v)> it = v.begin();
    cout << *it << "\n"; // outputs 1
    cout << typeid(it).name(); // outputs class _Vector_iterator<class _Vector_val<struct _Simple_types<int>>>
}

1
class std::_Vector_iterator<class std::_Vector_val<struct std::_Simple_types<int> > >

range_difference_t

지정된 범위의 반복기에 대한 차이 형식을 반환합니다.

template<range R>
using range_difference_t = iter_difference_t<iterator_t<R>>;

매개 변수

R
반복기가 차이 형식을 제공할 범위입니다.

예: range_difference_t

다음 예제에서는 범위의 요소 간 거리를 유지하는 방법을 range_difference_t 보여 있습니다.

// requires /std:c++20, or later

#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    using namespace std;

    vector<int> v{1,2,3};

    auto findIt = ranges::find(v, 2);
    // type of distance is ptrdiff_t
    ranges::range_difference_t<decltype(v)> distance = ranges::distance(v.begin(), findIt);
    cout << distance << endl; // outputs 1
}

1

range_reference_t

지정된 범위의 반복기에 대한 참조 형식을 반환합니다. 즉, 범위 요소의 참조 형식입니다.

template <range R>
using range_reference_t = iter_reference_t<ranges::iterator_t<R>>;

매개 변수

R
반복기 형식의 참조 형식이 반환되는 범위입니다.

예: range_reference_t

다음 예제에서는 범위에 있는 요소의 형식을 참조하는 방법을 보여 range_reference_t 드립니다.

// requires /std:c++20, or later

#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    using namespace std;

    vector<int> v{1,2,3};

    ranges::range_reference_t<decltype(v)> ref = v[0];

    cout << ref << endl; // outputs 1
    cout << typeid(ref).name() << endl; // outputs int
}

1
int

range_rvalue_reference_t

지정된 범위의 반복기에 대한 rvalue 참조 형식을 반환합니다. 즉, 범위 요소의 rvalue 참조 형식입니다.

template <range R>
using range_rvalue_reference_t = iter_reference_t<ranges::iterator_t<R>>;

매개 변수

R
rvalue 참조 형식을 반복기 형식으로 가져올 범위입니다.

예: range_rvalue_reference_t

다음 예제에서는 범위에 있는 요소의 rvalue 형식을 참조하는 방법을 보여 range_rvalue_reference_t 드립니다.

// requires /std:c++20, or later

#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    using namespace std;

    vector<int> v{1,2,3};

    ranges::range_rvalue_reference_t<decltype(v)> elementRvalueType = v[0] * 10; // elementRvalueType is int&& 

    cout << elementRvalueType << endl; // outputs 10
    cout << typeid(elementRvalueType).name() << endl; // outputs int
}

10
int

range_size_t

지정된 sized_range함수의 size 형식을 반환합니다.

template <range R>
using range_size_t = iter_reference_t<ranges::iterator_t<R>>;

매개 변수

R
함수 size 의 형식을 가져올 범위입니다.

예: range_size_t

다음 예제에서는 범위의 요소 수를 참조하는 방법을 보여 range_size_t 드립니다.

// requires /std:c++20, or later

#include <vector>
#include <iostream>
#include <ranges>

int main()
{
    using namespace std;

    vector<int> v{1,2,3};

    ranges::range_size_t<decltype(v)> size = v.size();
    cout << size << endl; // outputs 3
    cout << typeid(size).name(); // outputs unsigned __int64
}

3
unsigned __int64

range_value_t

지정된 범위 반복기의 값 형식을 반환합니다. 즉, 범위에 있는 요소의 형식입니다.

template <ranges::range R>
using range_value_t = iter_value_t<ranges::iterator_t<R>>;

매개 변수

R
반복기의 값 형식을 가져올 범위입니다.

예: range_value_t

다음 예제에서는 범위의 요소 형식을 참조하는 방법을 range_value_t 보여 줍니다.

// requires /std:c++20, or later

#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    using namespace std;

    vector<int> v{1,2,3};
    ranges::range_value_t<decltype(v)> elementType = v[2]; // elementType is an int 

    cout << elementType << endl; // outputs 3
    cout << typeid(elementType).name() << endl; // outputs int
}

3
unsigned int

sentinel_t

지정된 범위에 대한 sentinel 형식을 반환합니다.

template <range R>
using sentinel_t = decltype(ranges::end(declval<R&>()));

매개 변수

R
sentinel 형식을 가져올 범위입니다.

예: sentinel_t

다음 예제에서는 반복기 형식과 sentinel 형식이 동일한지 여부를 확인하는 데 사용하는 sentinel_t 방법을 보여 있습니다.

// requires /std:c++20, or later

#include <iostream>
#include <list>
#include <ranges>

int main()
{
    using namespace std;

    list myList{1, 2, 3};
    ranges::subrange count = std::views::counted(myList.begin(), myList.size());

    ranges::iterator_t<decltype(count)> first;
    ranges::sentinel_t<decltype(count)> last;

    // The iterator type and the sentinel type of a subrange
    // obtained from views::counted are not the same
    cout << boolalpha << is_same<decltype(first), decltype(last)>::value << endl; // outputs false
    cout << "iter: " << typeid(first).name() << "\n\n end: " << typeid(last).name() << endl;
}

false
iter: class std::counted_iterator<class std::_List_iterator<class std::_List_val<struct std::_List_simple_types<int> > > >

 end: struct std::default_sentinel_t

참고 항목

<ranges>
범위 어댑터
클래스 보기