std::ranges:: advance

만약 n 이 음수이면, 반복자는 감소합니다. 이 경우 I 는 std::bidirectional_iterator 를 모델해야 하며, S 는 bound 가 제공된 경우 I 와 동일한 타입이어야 합니다. 그렇지 않으면 동작이 정의되지 않습니다.

이 페이지에서 설명하는 함수형 개체들은 algorithm function objects (일반적으로 niebloids 로 알려진) 즉:

• 명시적 템플릿 인수 목록은 이들 중 어느 것을 호출할 때도 지정할 수 없습니다.
• 이들 중 어느 것도 인수 의존 이름 검색 에 보이지 않습니다.
• 이들 중 어느 것이 함수 호출 연산자의 왼쪽 이름으로 일반 비한정 이름 검색 에 의해 발견될 때, 인수 의존 이름 검색 이 억제됩니다.

매개변수

반환값

복잡도

선형.

그러나 I 가 추가적으로 std::random_access_iterator 를 모델링하거나, S 가 std:: sized_sentinel_for < I > 를 모델링하거나, I 와 S 가 std:: assignable_from < I & , S > 를 모델링하는 경우, 복잡도는 상수입니다.

참고 사항

지정된 증감 연속이 비증가 가능 반복자(예: 끝 반복자)를 증가시키거나 비감소 가능 반복자(예: 앞 반복자 또는 특이 반복자)를 감소시키도록 요구하는 경우, 이 동작은 정의되지 않습니다.

가능한 구현

struct advance_fn
{
    template<std::input_or_output_iterator I>
    constexpr void operator()(I& i, std::iter_difference_t<I> n) const
    {
        if constexpr (std::random_access_iterator<I>)
            i += n;
        else
        {
            while (n > 0)
            {
                --n;
                ++i;
            }
            if constexpr (std::bidirectional_iterator<I>)
            {
                while (n < 0)
                {
                    ++n;
                    --i;
                }
            }
        }
    }
    template<std::input_or_output_iterator I, std::sentinel_for<I> S>
    constexpr void operator()(I& i, S bound) const
    {
        if constexpr (std::assignable_from<I&, S>)
            i = std::move(bound);
        else if constexpr (std::sized_sentinel_for<S, I>)
            (*this)(i, bound - i);
        else
            while (i != bound)
                ++i;
    }
    template<std::input_or_output_iterator I, std::sentinel_for<I> S>
    constexpr std::iter_difference_t<I>
    operator()(I& i, std::iter_difference_t<I> n, S bound) const
    {
        if constexpr (std::sized_sentinel_for<S, I>)
        {
            // std::abs는 C++23까지 constexpr이 아님
            auto abs = [](const std::iter_difference_t<I> x) { return x < 0 ? -x : x; };
            if (const auto dist = abs(n) - abs(bound - i); dist < 0)
            {
                (*this)(i, bound);
                return -dist;
            }
            (*this)(i, n);
            return 0;
        }
        else
        {
            while (n > 0 && i != bound)
            {
                --n;
                ++i;
            }
            if constexpr (std::bidirectional_iterator<I>)
            {
                while (n < 0 && i != bound)
                {
                    ++n;
                    --i;
                }
            }
            return n;
        }
    }
};
inline constexpr auto advance = advance_fn();

예제

#include <iostream>
#include <iterator>
#include <vector>
int main()
{
    std::vector<int> v {3, 1, 4};
    auto vi = v.begin();
    std::ranges::advance(vi, 2);
    std::cout << "1) value: " << *vi << '\n' << std::boolalpha;
    std::ranges::advance(vi, v.end());
    std::cout << "2) vi == v.end(): " << (vi == v.end()) << '\n';
    std::ranges::advance(vi, -3);
    std::cout << "3) value: " << *vi << '\n';
    std::cout << "4) diff: " << std::ranges::advance(vi, 2, v.end())
              << ", value: " << *vi << '\n';
    std::cout << "5) diff: " << std::ranges::advance(vi, 4, v.end())
              << ", vi == v.end(): " << (vi == v.end()) << '\n';
}

1) value: 4
2) vi == v.end(): true
3) value: 3
4) diff: 0, value: 4
5) diff: 3, vi == v.end(): true

참고 항목