mnogopotok 2

#include <windows.h>
#include <iostream>
#include <random>
#include <vector>
#include <thread>
#include <future>

using namespace std;

class Timer { // found in internet
private:
    using clock_t = std::chrono::high_resolution_clock;
    using second_t = std::chrono::duration<double, std::ratio<1> >;

    std::chrono::time_point<clock_t> m_beg;

public:
    Timer() : m_beg(clock_t::now()) { }

    double elapsed() const {
        return std::chrono::duration_cast<second_t>(clock_t::now() - m_beg).count();
    }
};

struct Result {
    int minimal_val;
    int maximal_val;
    int minimal_index;
    int maximal_index;

    Result() {
        this->minimal_val = INT_MAX;
        this->maximal_val = INT_MIN;
        this->minimal_index = 0;
        this->maximal_index = 0;
    }
};

vector<int> vect;

void search(promise <Result>& prms, int leftIdx, int rightIdx) {
    Result threadAns = Result();

    for (int i = leftIdx; i <= rightIdx; ++i) {
        if (vect[i] > threadAns.maximal_val)
        {
            threadAns.maximal_val = vect[i];
            threadAns.maximal_index = i;
        }
        if (vect[i] < threadAns.minimal_val)
        {
            threadAns.minimal_val = vect[i];
            threadAns.minimal_index = i;
        }
    }

    prms.set_value(threadAns);
}

void start(int i) {
    Result overall_answer = Result();
    vector <thread> threads(i);
    vector <promise <Result> > promises(i);

    int leftGran = 0;
    int rightGran = 0;

    cout << "\nUsing " << i << " threads\n";

    Timer timer;

    for (int j = 0; j < i; j++) {
        leftGran = rightGran;
        rightGran = leftGran + (vect.size() / i);

        if (j + 1 == i) {
            rightGran = vect.size() - 1;
        }

        threads[j] = thread(search, ref(promises[j]), leftGran, rightGran);
    }

    for (int j = 0; j < i; j++) {
        threads[j].join();

        Result localAnswer = promises[j].get_future().get();
        if (localAnswer.maximal_val > overall_answer.maximal_val) {
            overall_answer.maximal_index = localAnswer.maximal_index;
            overall_answer.maximal_val = localAnswer.maximal_val;
        }

        if (localAnswer.minimal_val < overall_answer.minimal_val) {
            overall_answer.minimal_index = localAnswer.minimal_index;
            overall_answer.minimal_val = localAnswer.minimal_val;
        }
    }

    cout << "min value: " << overall_answer.minimal_val << " | index: " << overall_answer.minimal_index << endl;
    cout << "max value:  " << overall_answer.maximal_val << " | index: " << overall_answer.maximal_index << endl;
    cout << "time taken: " << timer.elapsed() << " sec" << endl << endl;
}

int main() {
    mt19937 mersenne;
    mersenne.seed(time(0));

    cout << "array lenght: ";
    int arrLength;
    cin >> arrLength;

    for (int i = 0; i < arrLength; i++) {
        vect.push_back(mersenne());
    }

    for (int i = 2; i <= 16; i *= 2) {
        start(i);
    }

    return 0;
}