Краткий ответ

Тип начального значения задаёт тип аккумулятора и возвращаемого результата std::accumulate. Поэтому для суммы типа long long нужно передать начальное значение этого типа, например 0LL; использование 0 делает аккумулятор типа int и может привести к переполнению или потере результата.

Исторический контекст

Обобщённые алгоритмы STL проектировались для работы с диапазонами разных контейнеров без привязки к конкретному типу контейнера. Алгоритму нужно было явно передать начальное состояние операции свёртки, поэтому именно этот аргумент стал основой для определения типа накапливаемого значения.

Такой подход позволяет суммировать не только числа, но и выполнять произвольные операции над элементами диапазона. Обратная сторона — тип аккумулятора не выводится автоматически из типа элементов диапазона.

Постановка проблемы

Вызов std::accumulate с начальным значением 0 создаёт аккумулятор типа int, даже если элементы имеют тип long long. При накоплении больших значений результат каждой итерации приводится обратно к типу аккумулятора.

Для знакового целого переполнение при арифметической операции приводит к неопределённому поведению. Если промежуточное выражение вычислилось в более широком типе, но его результат не представим в типе аккумулятора, преобразование к знаковому целому имеет реализационно-зависимый результат. В обоих случаях нельзя рассчитывать на корректную сумму.

Подробное решение

Упрощённо алгоритм последовательно выполняет операции вида accumulator = accumulator + element. Тип accumulator совпадает с типом переданного начального значения, а тип результата функции — с этим же типом.

#include <algorithm>
#include <iostream>
#include <numeric>
#include <vector>

int main() {
    std::vector<int> values{1'500'000'000, 1'500'000'000};

    auto bad = std::accumulate(values.begin(), values.end(), 0);
    auto good = std::accumulate(values.begin(), values.end(), 0LL);

    std::cout << good;
}

В варианте с 0 аккумулятор имеет тип int, поэтому сложение двух больших значений может вызвать неопределённое поведение. В варианте с 0LL аккумулятор имеет тип long long, и сумма вычисляется в подходящей разрядности.

Важно учитывать не только тип элементов, но и тип требуемого результата. Для суммы int-элементов также может потребоваться 0LL, если итог способен превысить диапазон int.

В стандарте C++20 внутри std::accumulate допускается перемещение аккумулятора перед операцией, но это не меняет правило выбора его типа. Если нужна параллельная или потенциально переупорядоченная свёртка, существует std::reduce, однако он также использует тип начального значения и предъявляет более строгие требования к операции: она должна корректно работать при изменении порядка вычислений.

Ситуация из практики

Сервис подсчитывает суммарный размер файлов. Размер каждого файла хранится в long long, но разработчик передал в std::accumulate начальное значение 0. На небольшом наборе данных ошибка не проявлялась, а после роста объёма данных сумма стала некорректной.

Можно было заменить алгоритм ручным циклом: это прозрачно, но добавляет код и не устраняет необходимость выбрать правильный тип. Можно было использовать std::reduce, но он не даёт преимущества для обычной последовательной суммы и требует аккуратного отношения к порядку операций. Выбранное решение — передать 0LL в std::accumulate: это минимальное изменение, сохраняющее последовательную семантику и обеспечивающее нужную разрядность.

Что кандидаты часто упускают

Вопрос 1: Если элементы имеют тип long long, разве std::accumulate не обязан автоматически выбрать этот тип?

Нет. Тип аккумулятора определяется начальным значением, а не типом элементов диапазона. Типы операндов могут участвовать в вычислении выражения, но результат каждой итерации сохраняется в аккумулятор, поэтому исходный тип аккумулятора остаётся определяющим.

Вопрос 2: Достаточно ли заменить 0 на 0L?

Не всегда. Суффикс L означает тип long, размер которого зависит от платформы и может совпадать с int. Для гарантированного использования типа long long следует применять 0LL. Если требуется беззнаковая арифметика, нужно явно выбрать соответствующий тип, например 0ULL, учитывая последствия беззнакового переполнения.

Вопрос 3: Можно ли безопасно использовать std::reduce вместо std::accumulate для чисел с плавающей точкой?

Не всегда. std::reduce может менять порядок сложения, а операции с плавающей точкой не являются строго ассоциативными из-за округления. Поэтому результат может отличаться от последовательного std::accumulate. std::reduce уместен, когда операция допускает переупорядочивание или такая погрешность заранее приемлема.