Threads

#include <iostream>
#include <vector>
#include <thread>
#include <numeric>   // std::accumulate

// Суммирует диапазон data[from..to) и кладёт ответ в result
void sum_part(const std::vector<int>& data,
              size_t from,
              size_t to,
              long long& result)
{
    result = std::accumulate(data.begin() + from,
                             data.begin() + to,
                             0LL);

    std::cout << "Поток завершил диапазон ["
              << from << ", " << to << ")
";
}

int main()
{
    constexpr size_t N = 1'000'000;
    constexpr size_t THREADS = 4;

    std::vector<int> data(N);

    // Заполним: 1, 2, 3, ..., N
    for (size_t i = 0; i < N; ++i)
        data[i] = static_cast<int>(i + 1);

    long long partial[THREADS] = {};  // по отдельной ячейке на поток
    std::thread workers[THREADS];

    const size_t block = N / THREADS;

    // Запускаем 4 независимые работы
    for (size_t i = 0; i < THREADS; ++i)
    {
        const size_t from = i * block;
        const size_t to = (i == THREADS - 1) ? N : from + block;

        workers[i] = std::thread(sum_part,
                                 std::cref(data),
                                 from, to,
                                 std::ref(partial[i]));
    }

    // Ждём все рабочие потоки
    for (auto& t : workers)
        t.join();

    // Складываем их результаты уже в главном потоке
    long long total = 0;
    for (long long x : partial)
        total += x;

    std::cout << "Сумма = " << total << '
';

    // Ожидаемое значение: N * (N + 1) / 2
    std::cout << "Ожидалось = "
              << 1LL * N * (N + 1) / 2 << '
';
}