std::partial_sum

template< class InputIt, class OutputIt >
OutputIt partial_sum( InputIt first, InputIt last,
                      OutputIt d_first );

template< class InputIt, class OutputIt, class BinaryOp >
OutputIt partial_sum( InputIt first, InputIt last,
                      OutputIt d_first, BinaryOp op );

실제 이항 연산이 binary_op일 때:

• 다음 조건 중 하나라도 만족하면 프로그램의 형식이 잘못되었습니다(ill-formed):

• InputIt의 값 타입이 *first에서 생성 가능(constructible)하지 않습니다.
• acc이 에 쓸 수 없습니다(writable)d_first.
• binary_op(acc, *iter)(C++20까지)binary_op(std::move(acc), *iter)(C++20부터)의 결과가 InputIt의 값 타입으로 암시적으로 변환 가능하지 않습니다.

• d_last이 반환될 반복자일 때, 다음 조건 중 하나라도 만족하면 동작이 정의되지 않습니다(undefined):

• binary_op[first, last) 또는 [d_first, d_last)의 요소를 수정합니다.
• binary_op[first, last] 또는 [d_first, d_last]의 반복자나 하위 범위를 무효화합니다.

매개변수

반환값

마지막으로 기록된 요소의 다음 요소를 가리키는 반복자, 또는 d_first (만약 [ first , last ) 범위가 비어 있는 경우).

복잡도

주어진 \(\scriptsize N\) N 이 std:: distance ( first, last ) 인 경우:

가능한 구현

template<class InputIt, class OutputIt>
constexpr // since C++20
OutputIt partial_sum(InputIt first, InputIt last, OutputIt d_first)
{
    if (first == last)
        return d_first;
    typename std::iterator_traits<InputIt>::value_type sum = *first;
    *d_first = sum;
    while (++first != last)
    {
        sum = std::move(sum) + *first; // std::move since C++20
        *++d_first = sum;
    }
    return ++d_first;
    // 또는 C++14부터:
    // return std::partial_sum(first, last, d_first, std::plus<>());
}

template<class InputIt, class OutputIt, class BinaryOp>
constexpr // since C++20
OutputIt partial_sum(InputIt first, InputIt last, 
                     OutputIt d_first, BinaryOp op)
{
    if (first == last)
        return d_first;
    typename std::iterator_traits<InputIt>::value_type acc = *first;
    *d_first = acc;
    while (++first != last)
    {
        acc = op(std::move(acc), *first); // std::move since C++20
        *++d_first = acc;
    }
    return ++d_first;
}

참고 사항

acc 는 LWG 이슈 539 의 해결로 인해 도입되었습니다. 결과를 직접 합산하는 방식(즉 * ( d_first + 2 ) = ( * first + * ( first + 1 ) ) + * ( first + 2 ) ; ) 대신 acc 를 사용하는 이유는 다음과 같은 유형이 일치하지 않을 경우 후자의 의미가 혼란스러울 수 있기 때문입니다:

• InputIt 의 값 타입
• OutputIt 의 쓰기 가능 타입(들)
• operator + 또는 op 의 매개변수 타입들
• operator + 또는 op 의 반환 타입

acc 는 계산의 각 단계에 대한 값을 저장하고 제공하는 중간 객체 역할을 합니다:

• 그 타입은 InputIt 의 값 타입입니다
• 그것은 d_first 에 기록됩니다
• 그 값은 operator + 또는 op 에 전달됩니다
• 그것은 operator + 또는 op 의 반환 값을 저장합니다

enum not_int { x = 1, y = 2 };
char i_array[4] = {100, 100, 100, 100};
not_int e_array[4] = {x, x, y, y};
int  o_array[4];
// 정상: operator+(char, char)를 사용하고 char 값을 int 배열에 할당함
std::partial_sum(i_array, i_array + 4, o_array);
// 오류: not_int 값을 int 배열에 할당할 수 없음
std::partial_sum(e_array, e_array + 4, o_array);
// 정상: 필요한 경우 변환을 수행함
// 1. char 타입의 "acc" 생성(값 타입)
// 2. char 인수가 long 곱셈에 사용됨(char -> long)
// 3. long 곱이 "acc"에 할당됨(long -> char)
// 4. "acc"가 "o_array"의 요소에 할당됨(char -> int)
// 5. 입력 범위의 나머지 요소를 처리하기 위해 2단계로 돌아감
std::partial_sum(i_array, i_array + 4, o_array, std::multiplies<long>{});

예제

#include <functional>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
int main()
{
    std::vector<int> v(10, 2); // v = {2, 2, 2, 2, 2, 2, 2, 2, 2, 2}
    std::cout << "The first " << v.size() << " even numbers are: ";
    // 결과를 cout 스트림에 출력
    std::partial_sum(v.cbegin(), v.cend(), 
                     std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
    // 결과를 벡터 v에 다시 기록
    std::partial_sum(v.cbegin(), v.cend(),
                     v.begin(), std::multiplies<int>());
    std::cout << "The first " << v.size() << " powers of 2 are: ";
    for (int n : v)
        std::cout << n << ' ';
    std::cout << '\n';
}

The first 10 even numbers are: 2 4 6 8 10 12 14 16 18 20 
The first 10 powers of 2 are: 2 4 8 16 32 64 128 256 512 1024

결함 보고서

다음의 동작 변경 결함 보고서들은 이전에 발표된 C++ 표준에 소급 적용되었습니다.

참고 항목