Параллельная обработка файлов

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <vector>
#include <boost\filesystem.hpp>
#include <boost\filesystem\fstream.hpp>
#include <boost\thread\thread.hpp>
 
 
using namespace std;
namespace fs = boost::filesystem;
 
int main()
{   
    setlocale(LC_ALL, "rus");
    vector<int> values;
    FILE* txt;
    fs::path path("c:\\text");
 
    int result = 0;
 
    cout << "Введите путь к файлам (*.txt): ";
    cin >> path;
    cout << endl;
 
    for (fs::directory_iterator it(path); it != fs::directory_iterator(); ++it)
    {
        if (it->path().extension() == ".txt")
        {
            fs::ifstream ifs(*it);
            if (ifs.is_open())
            {
                int val;
                ifs >> val;
                values.push_back(val);
                cout << it->path().filename() << ":" << val << endl;
                txt = fopen(it->path().string().c_str(), "r");
                fclose(txt);
            }
            else
                cerr << "Ошибка!" << endl;
        }
    }
 
    boost::this_thread::sleep(boost::posix_time::milliseconds(100));
 
    if (values.empty())
    {
        cerr << "Ошибка! Чисел нет!" << endl;
    }
    else
    {
        for (int i = 0; i < values.size(); i++)
        {
            result = values[i] + result;
        }
        cout << "Сумма всех чисел: " << result << endl;
    }
 
    system("pause");
    return 0;
}

#include <iostream>
#include <iterator>
#include <vector>
#include <algorithm>
#include <boost/filesystem.hpp>
#include <boost/filesystem/fstream.hpp>
#define BOOST_THREAD_VERSION 4
#include <boost/thread.hpp>
 
namespace fs = boost::filesystem;
 
long long read_and_calc(const fs::path &p) {
   fs::ifstream ifs(p);
   if (ifs.is_open()) {
      return std::accumulate(std::istream_iterator<int>(ifs),
                             std::istream_iterator<int>(), 0LL);
   }
   return 0;
}
 
template <typename Iter>
long long bloc_calc(Iter first, Iter last) {
   long long res = 0;
   while (first != last) res += read_and_calc(*first++);
   return res;
}
 
int main()
{
   fs::path directory_path("D:\Temp");
   std::vector<fs::path> files{fs::recursive_directory_iterator(directory_path),
            fs::recursive_directory_iterator()};
 
   // remove all except .txt files:
   files.erase(std::remove_if(files.begin(), files.end(),
                              [](const fs::path &p){return !fs::is_regular_file(p)
            || p.extension() != ".txt";}
   ), files.end() );
 
   std::size_t num_threads = boost::thread::hardware_concurrency();
   std::size_t block_size = files.size() / num_threads;
   std::vector<boost::future<long long>> futures;
 
   using iter = std::vector<fs::path>::const_iterator;
   for (iter start = files.begin(); start != files.end(); start += block_size) {
      futures.push_back(boost::async(boost::launch::async,
                        bloc_calc<iter>, start, start + block_size));
   }
 
   long long sum = 0;
   for (auto& f : futures) {
      sum += f.get();
   }
   std::cout << "Sum of all sums of all numbers into all txt files: " << sum << "\n";
}