Ссылка на метод дочернего класса из родительского

@YagDen · Регистрация: 06.02.2019

Студворк — интернет-сервис помощи студентам

Всем привет! Я новичок в C++. Помогите, пожалуйста, сослаться из родительского класса на метод, реализованный в дочернем классе, и, соответственно, вызвать его в родительском классе.
Пытаюсь сделать так:

Родительский класс:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
template <typename TP>
class ThreadPull
{
void (TP::*ThreadFunc)(size_t &i, size_t &n) = nullptr; // ссылка на метод дочернего класса
.....
}
.....
template <typename TP>
void ThreadPull<TP>::LaunchPull(void (TP::*_ThreadFunc)(size_t &i, size_t &n), std::function<void(void)> lambda)
{
ThreadFunc = _ThreadFunc; // присваивается так
}
.....
template <typename TP>
void ThreadPull<TP>::MultiThreadTask(size_t id)
{
(this->*ThreadFunc)(i, n); // вызывается так
}

Дочерний класс:

C++
1
2
3
4
5
class LongArrayProcessing : public ThreadPull<LongArrayProcessing>
.....
LaunchPull(&LongArrayProcessing::ThreadMultipliar, [this]() {
        arrSize = d.size();
    });

Программа не компилируется. Помогите, пожалуйста, разобраться, в чем дело.
Полный код программы:
Файл ThreadPull.h

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
#ifndef THREADPULL
#define THREADPULL
 
#include <list>
#include <thread>
#include <mutex>
#include <condition_variable>
 
template <typename TP>
class ThreadPull
{
protected:
    const unsigned int numCores = std::thread::hardware_concurrency();
 
    unsigned int calcRange;
    std::list<std::thread> threads;
    std::mutex mx;
    std::condition_variable cv;
    volatile size_t mi = 0;
    volatile size_t inuse = 0;
    volatile bool stop = false;
    size_t arrSize;
 
    void (TP::*ThreadFunc)(size_t &i, size_t &n) = nullptr;
    void MultiThreadTask(size_t id);
 
public:
    ThreadPull();
    ~ThreadPull();
 
    void LaunchPull(void (TP::*_ThreadFunc)(size_t &i, size_t &n), std::function<void(void)> lambda);
};
 
#include <algorithm>
 
template <typename TP>
ThreadPull<TP>::ThreadPull()
{
    for (size_t i = (size_t)numCores; i > 0; --i)
    {
        threads.push_back(std::thread([this, i]() {
            MultiThreadTask(i);
        }));
    }
}
 
template <typename TP>
ThreadPull<TP>::~ThreadPull()
{
    {
        std::lock_guard<std::mutex> lock(mx);
        stop = true;
        cv.notify_all();
    }
 
    for (auto &thread : threads)
        if (thread.joinable())
            thread.join();
}
 
template <typename TP>
void ThreadPull<TP>::MultiThreadTask(size_t id)
{
    while (true)
    {
        size_t i, n;
        {
            std::unique_lock<std::mutex> lock(mx);
            while (true)
            {
                if (stop)
                    return;
 
                if (mi < arrSize)
                {
                    i = mi;
                    n = mi = std::min(arrSize, mi + calcRange);
 
                    ++inuse;
                    break;
                }
                cv.wait(lock);
            }
        }
 
        (this->*ThreadFunc)(i, n);
 
        std::lock_guard<std::mutex> lock(mx);
        --inuse;
        cv.notify_all();
    }
}
 
template <typename TP>
void ThreadPull<TP>::LaunchPull(void (TP::*_ThreadFunc)(size_t &i, size_t &n), std::function<void(void)> lambda)
{
    {
        std::lock_guard<std::mutex> lock(mx);
 
        mi = 0;
        lambda();
        calcRange = arrSize / numCores;
        ThreadFunc = _ThreadFunc;
 
        cv.notify_all();
    }
 
    {
        std::unique_lock<std::mutex> lock(mx);
        while (mi < arrSize || inuse != 0)
            cv.wait(lock);
    }
}
 
#endif // !THREADPULL

Файл LongArrayProcessing.h

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#ifndef LONGARRAYPROCESSING
#define LONGARRAYPROCESSING
 
#include <vector>
#include <list>
#include <thread>
#include <mutex>
#include <condition_variable>
 
#include "ThreadPull.h"
 
class LongArrayProcessing : public ThreadPull<LongArrayProcessing>
{
private:
    const unsigned int cnt;
 
    unsigned int maxArrIdx;
    std::vector<double> a;
    std::vector<double> b;
    std::vector<double> c;
    std::vector<double> d;
    std::vector<double> correctAns;
    double *e, *sumCorrectAns;
    unsigned int eCnt;
 
    double MyRandom();
    void MultiThreadTest(unsigned int startIdx, unsigned int endIdx);
 
    void ThreadMultipliar(size_t &i, size_t &n);
    void ThreadSummator(size_t &i, size_t &n);
 
public:
    void Init();
    LongArrayProcessing(unsigned int _cnt, unsigned int _eCnt);
    ~LongArrayProcessing();
    std::chrono::milliseconds ProcessArray();
    std::chrono::milliseconds ProcessArrayCondVar();
    std::chrono::milliseconds ProcessArraySummator();
    std::vector<double> &GetC() { return c; }
    std::vector<double> &GetD() { return d; }
    std::vector<double> &GetCorrectAns() { return correctAns; }
    double *GetE() { return e; }
    double *GetSumCorrectAns() { return sumCorrectAns; }
};
 
#endif // !LONGARRAYPROCESSING

Файл LongArrayProcessing.cpp

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
#include "LongArrayProcessing.h"
 
#include <ctime>
#include <iostream>
#include <algorithm>
 
using namespace std;
 
LongArrayProcessing::LongArrayProcessing(unsigned int _cnt, unsigned int _eCnt)
    : cnt(_cnt), eCnt(_eCnt), maxArrIdx(cnt), a(cnt), b(cnt), c(cnt), d(cnt), correctAns(cnt)
{
    cout << "Start!" << endl;
 
    e = new double[eCnt];
    sumCorrectAns = new double[eCnt];
 
    cout << "End!" << endl;
}
 
LongArrayProcessing::~LongArrayProcessing()
{
    delete[] e;
    delete[] sumCorrectAns;
}
 
void LongArrayProcessing::Init()
{
    for (unsigned int i = 0; i < cnt; i++)
    {
        a[i] = 100.0 * MyRandom() - 50.0;
        b[i] = 100.0 * MyRandom() - 50.0;
        c[i] = 0;
        d[i] = 0;
        correctAns[i] = a[i] * b[i];
    }
 
    for (unsigned int i = 0; i < eCnt; i++)
    {
        e[i] = 0;
        sumCorrectAns[i] = a[i] + b[i];
    }
}
 
double LongArrayProcessing::MyRandom()
{
    return static_cast<double>(rand()) / RAND_MAX;
}
 
void LongArrayProcessing::MultiThreadTest(unsigned int startIdx, unsigned int endIdx)
{
    for (unsigned int i = startIdx; i < endIdx; i++)
    {
        c[i] = a[i] * b[i];
    }
}
 
chrono::milliseconds LongArrayProcessing::ProcessArray()
{
    unsigned int numCores = std::thread::hardware_concurrency();
    unsigned int numThreads = numCores - 1;
    unsigned int calcRange = (unsigned int)c.size() / numCores;
 
    auto begin = chrono::steady_clock::now();
 
    list<thread> ts;
    unsigned int startIdx = 0;
 
    for (unsigned int t = 0; t < numThreads; t++)
    {
        unsigned int endIdx = startIdx + calcRange;
        ts.push_back(thread([this, startIdx, endIdx]() {
            MultiThreadTest(startIdx, endIdx);
        }));
        startIdx = endIdx;
    }
 
    MultiThreadTest(startIdx, maxArrIdx);
 
    for (auto &el : ts)
        el.join();
 
    auto end = chrono::steady_clock::now();
    return chrono::duration_cast<chrono::milliseconds>(end - begin);
}
 
chrono::milliseconds LongArrayProcessing::ProcessArrayCondVar()
{
    auto begin = chrono::steady_clock::now();
 
    LaunchPull(&LongArrayProcessing::ThreadMultipliar, [this]() {
        arrSize = d.size();
    });
 
    auto end = chrono::steady_clock::now();
    return chrono::duration_cast<chrono::milliseconds>(end - begin);
}
 
void LongArrayProcessing::ThreadMultipliar(size_t &i, size_t &n)
{
    for (; i < n; ++i)
    {
        d[i] = a[i] * b[i];
    }
}
 
std::chrono::milliseconds LongArrayProcessing::ProcessArraySummator()
{
    auto begin = chrono::steady_clock::now();
 
    LaunchPull(&LongArrayProcessing::ThreadSummator, [this]() {
        arrSize = (size_t)eCnt;
    });
 
    auto end = chrono::steady_clock::now();
    return chrono::duration_cast<chrono::milliseconds>(end - begin);
}
 
void LongArrayProcessing::ThreadSummator(size_t &i, size_t &n)
{
    for (; i < n; ++i)
    {
        e[i] = a[i] + b[i];
    }
}

@YagDen · 25.07.2019, 12:41 **[ТС]**

Сообщение от oleg-m1973

огда ты делаешь ThreadFunc = std::bind..., то старое значение удаляется и присваивается новое. Если ты в это время попытаешься вызвать в другом потоке ThreadFunc(), то будет ошибка

Все равно не понял. LaunchPull запускается в однопотоке, он меняет значение ThreadFunc. Все потоки в это время ждут

C++
1
cv.wait(lock);

дальше LaunchPull пробуждает потоки

C++
1
cv.notify_all();

и сразу блокируется, пока все потоки не завершатся

C++
1
2
3
4
5
{
        std::unique_lock<std::mutex> lock(mx);
        while (mi < arrSize || inuse)
            cv.wait(lock);
    }

а потоки тем временем обрабатывают каждый свой кусок, а после этого блокируются мьютексом и пробуждают LaunchPull

C++
1
2
3
4
5
ThreadFunc(i, n);
 
        std::lock_guard<std::mutex> lock(mx);
        --inuse;
        cv.notify_all();

и когда потоки завершаются, LaunchPull разблокируется и завершается. Если не так, поправьте, пожалуйста.

@oleg-m1973 · 25.07.2019, 12:54

Сообщение от YagDen

Все равно не понял. LaunchPull запускается в однопотоке, он меняет значение ThreadFunc. Все потоки в это время ждут

А, ну да, вижу. Закомментарь код в ThreadMultipliar и ThreadSummator и проверь, что работает.

@YagDen · 25.07.2019, 17:36 **[ТС]**

Сообщение от oleg-m1973

А, ну да, вижу. Закомментарь код в ThreadMultipliar и ThreadSummator и проверь, что работает.

Ок, домой приду, отпишусь.

Добавлено через 4 часа 29 минут
Похоже, какой-то поток действительно что-то не ждет.

Сообщение от oleg-m1973

Закомментарь код в ThreadMultipliar и ThreadSummator и проверь, что работает.

Да, работает. Но позже я заметил, что достаточно закомментить только ThreadSummator, код не только работает, но и считает правильно, мою проверку проходит. А еще позже заметил, что код начинает корректно выполняться, если закомментить код:

C++
1
2
3
4
5
for (int i = 0; i < 500; i++)
        {
            auto procTimeCondVar = lap.ProcessArrayCondVar();
            auto procTimeSummator = lap.ProcessArraySummator();
        }

или даже если просто добавить в него операцию, которая занимает некоторое время:

C++
1
2
3
4
5
6
for (int i = 0; i < 500; i++)
        {
            auto procTimeCondVar = lap.ProcessArrayCondVar();
            auto procTimeSummator = lap.ProcessArraySummator();
            cout << ":";
        }

@oleg-m1973 · 25.07.2019, 18:28

Сообщение от YagDen

Да, работает. Но позже я заметил, что достаточно закомментить только ThreadSummator, код не только работает, но и считает правильно, мою проверку проходит. А еще позже заметил, что код начинает корректно выполняться, если закомментить код:

Смотри, чему у тебя равен arrSize в MultiThreadTask, сделай там printf("%d\n", arrSize);

@YagDen · 25.07.2019, 19:03 **[ТС]**

Сообщение от oleg-m1973

Смотри, чему у тебя равен arrSize в MultiThreadTask, сделай там printf("%d\n", arrSize);

Как и должно быть. Значения корректные.

Добавлено через 7 минут
Проблемы с длиной массива. Если сделать массивы одинаковой длины, проблем нет. У меня ощущение, что часть потоков просто не успевают рэнжи свои пересчитывать до запуска. Лямбда все-таки нужна. Нельзя ее комментить.

Добавлено через 17 минут
Решил с помощью костылей:
Файл ThreadPull.h

C++
1
size_t *arrSizePtr = nullptr;

Вместо лямбды в LaunchPull:

C++
1
arrSize = *arrSizePtr;

А при вызове LaunchPull теперь не arrSize заполняю, а arrSizePtr. Просто чудовищные костыли. Я уверен, что есть решение лучше! Может, можно туда как-то лямбду вернуть?

@oleg-m1973 · 25.07.2019, 21:15

Сообщение от YagDen

Проблемы с длиной массива. Если сделать массивы одинаковой длины, проблем нет. У меня ощущение, что часть потоков просто не успевают рэнжи свои пересчитывать до запуска. Лямбда все-таки нужна. Нельзя ее комментить.

Не нужна там твоя лямбда. Проблема в том, что ты криво сделал всё, вообще. Ну, теперь остаётся только костыли втыкать, тут я тебе плохой помощник.

@YagDen · 25.07.2019, 22:09 **[ТС]**

Сообщение от oleg-m1973

Не нужна там твоя лямбда. Проблема в том, что ты криво сделал всё, вообще. Ну, теперь остаётся только костыли втыкать, тут я тебе плохой помощник.

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

Добавлено через 37 минут
Заюзал код. В этот раз все заработало. Еще раз благодарю за помощь. Если мало ли кому-нибудь понадобится этот код - вот конечная версия:
Файл ThreadPull.h

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#ifndef THREADPULL
#define THREADPULL
 
#include <list>
#include <thread>
#include <mutex>
#include <condition_variable>
 
class ThreadPull
{
protected:
    const unsigned int numCores = std::thread::hardware_concurrency();
 
    unsigned int calcRange = 0;
    std::list<std::thread> threads;
    std::mutex mx;
    std::condition_variable cv;
    volatile size_t mi = 0;
    volatile size_t inuse = 0;
    volatile bool stop = false;
    size_t arrSize = 0;
    size_t arrSizeBuf = 0;
 
    void MultiThreadTask(size_t id);
 
public:
    ThreadPull();
    ~ThreadPull();
 
    std::function<void(size_t &i, size_t &n)> ThreadFunc;
 
    template <typename TFunc, typename... TT>
    void LaunchPull(TFunc &&func, TT&&... args);
};
 
template <typename TFunc, typename... TT>
void ThreadPull::LaunchPull(TFunc &&func, TT&&... args)
{
    {
        std::lock_guard<std::mutex> lock(mx);
 
        mi = 0;
        arrSize = arrSizeBuf;
 
        calcRange = arrSize / numCores;
        ThreadFunc = std::bind(std::forward<TFunc>(func), std::forward<TT>(args)..., std::placeholders::_1, std::placeholders::_2);
 
        cv.notify_all();
    }
 
    {
        std::unique_lock<std::mutex> lock(mx);
        while (mi < arrSize || inuse)
            cv.wait(lock);
    }
}
 
#endif // !THREADPULL

Файл ThreadPull.cpp

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#include "ThreadPull.h"
 
#include <algorithm>
 
using namespace std;
 
ThreadPull::ThreadPull()
{
    for (size_t i = (size_t)numCores; i > 0; --i)
    {
        threads.push_back(thread([this, i]() {
            MultiThreadTask(i);
        }));
    }
}
 
ThreadPull::~ThreadPull()
{
    {
        lock_guard<mutex> lock(mx);
        stop = true;
        cv.notify_all();
    }
 
    for (auto &thread : threads)
        if (thread.joinable())
            thread.join();
}
 
void ThreadPull::MultiThreadTask(size_t id)
{
    while (true)
    {
        size_t i, n;
        {
            unique_lock<mutex> lock(mx);
            while (true)
            {
                if (stop)
                    return;
 
                if (mi < arrSize)
                {
                    i = mi;
                    n = mi = min(arrSize, mi + calcRange);
 
                    ++inuse;
                    break;
                }
                cv.wait(lock);
            }
        }
 
        ThreadFunc(i, n);
 
        lock_guard<mutex> lock(mx);
        --inuse;
        cv.notify_all();
    }
}

Файл LongArrayProcessing.h

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#ifndef LONGARRAYPROCESSING
#define LONGARRAYPROCESSING
 
#include <vector>
#include <list>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <ctime>
 
#include "ThreadPull.h"
 
class LongArrayProcessing : public ThreadPull
{
private:
    const unsigned long cnt;
    
    unsigned int maxArrIdx;
    std::vector<double> a;
    std::vector<double> b;
    std::vector<double> c;
    std::vector<double> d;
    std::vector<double> correctAns;
    double *e, *sumCorrectAns;
    unsigned long eCnt;
 
    double MyRandom();
    void MultiThreadTest(unsigned int startIdx, unsigned int endIdx);
 
    void ThreadMultipliar(size_t &i, size_t &n);
    void ThreadSummator(size_t &i, size_t &n);
 
public:
    void Init();
    LongArrayProcessing(unsigned long _cnt, unsigned long _eCnt);
    ~LongArrayProcessing();
    std::chrono::milliseconds ProcessArray();
    std::chrono::milliseconds ProcessArrayCondVar();
    std::chrono::milliseconds ProcessArraySummator();
    std::vector<double> &GetC() { return c; }
    std::vector<double> &GetD() { return d; }
    std::vector<double> &GetCorrectAns() { return correctAns; }
    double *GetE() { return e; }
    double *GetSumCorrectAns() { return sumCorrectAns; }
};
 
#endif // !LONGARRAYPROCESSING

Файл LongArrayProcessing.cpp

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
#include <iostream>
#include <algorithm>
 
#include "LongArrayProcessing.h"
 
using namespace std;
 
LongArrayProcessing::LongArrayProcessing(unsigned long _cnt, unsigned long _eCnt)
    : cnt(_cnt), eCnt(_eCnt), maxArrIdx(cnt), a(cnt), b(cnt), c(cnt), d(cnt), correctAns(cnt)
{
    cout << "Start!" << endl;
 
    e = new double[eCnt];
    sumCorrectAns = new double[eCnt];
 
    cout << "End!" << endl;
}
 
LongArrayProcessing::~LongArrayProcessing()
{
    delete[] e;
    delete[] sumCorrectAns;
}
 
void LongArrayProcessing::Init()
{
    for (unsigned int i = 0; i < cnt; i++)
    {
        a[i] = 100.0 * MyRandom() - 50.0;
        b[i] = 100.0 * MyRandom() - 50.0;
        c[i] = 0;
        d[i] = 0;
    }
 
    auto begin = chrono::steady_clock::now();
 
    for (unsigned int i = 0; i < cnt; i++)
        correctAns[i] = a[i] * b[i];
 
    auto end = chrono::steady_clock::now();
    auto tm = chrono::duration_cast<chrono::milliseconds>(end - begin);
    cout << "No multithreads: " << tm.count() << " ms\n";
 
    for (unsigned int i = 0; i < eCnt; i++)
    {
        e[i] = 0;
        sumCorrectAns[i] = a[i] + b[i];
    }
}
 
double LongArrayProcessing::MyRandom()
{
    return static_cast<double>(rand()) / RAND_MAX;
}
 
void LongArrayProcessing::MultiThreadTest(unsigned int startIdx, unsigned int endIdx)
{
    for (unsigned int i = startIdx; i < endIdx; i++)
    {
        c[i] = a[i] * b[i];
    }
}
 
chrono::milliseconds LongArrayProcessing::ProcessArray()
{
    unsigned int numCores = std::thread::hardware_concurrency();
    unsigned int numThreads = numCores - 1;
    unsigned int calcRange = (unsigned int)c.size() / numCores;
 
    auto begin = chrono::steady_clock::now();
 
    list<thread> ts;
    unsigned int startIdx = 0;
 
    for (unsigned int t = 0; t < numThreads; t++)
    {
        unsigned int endIdx = startIdx + calcRange;
        ts.push_back(thread([this, startIdx, endIdx]() {
            MultiThreadTest(startIdx, endIdx);
        }));
        startIdx = endIdx;
    }
 
    MultiThreadTest(startIdx, maxArrIdx);
 
    for (auto &el : ts)
        el.join();
 
    auto end = chrono::steady_clock::now();
    return chrono::duration_cast<chrono::milliseconds>(end - begin);
}
 
chrono::milliseconds LongArrayProcessing::ProcessArrayCondVar()
{
    auto begin = chrono::steady_clock::now();
 
    arrSizeBuf = d.size();
    LaunchPull(&LongArrayProcessing::ThreadMultipliar, this);
 
    auto end = chrono::steady_clock::now();
    return chrono::duration_cast<chrono::milliseconds>(end - begin);
}
 
void LongArrayProcessing::ThreadMultipliar(size_t &i, size_t &n)
{
    for (; i < n; ++i)
    {
        d[i] = a[i] * b[i];
    }
}
 
std::chrono::milliseconds LongArrayProcessing::ProcessArraySummator()
{
    auto begin = chrono::steady_clock::now();
 
    arrSizeBuf = (size_t)eCnt;
    LaunchPull(&LongArrayProcessing::ThreadSummator, this);
 
    auto end = chrono::steady_clock::now();
    return chrono::duration_cast<chrono::milliseconds>(end - begin);
}
 
void LongArrayProcessing::ThreadSummator(size_t &i, size_t &n)
{
    for (; i < n; ++i)
    {
        e[i] = a[i] + b[i];
    }
}

Файл main.cpp

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
#include <iostream>
#include <ctime>
 
#include "LongArrayProcessing.h"
 
using namespace std;
 
void main()
{
    const unsigned long cnt = 9999999;
    const unsigned long eCnt = cnt / 2;
 
    srand(static_cast<unsigned int>(time(NULL)));
 
    LongArrayProcessing lap(cnt, eCnt);
    unsigned int itrNum = 0;
 
    bool err, err2;
 
    do
    {
        lap.Init();
 
        for (int i = 0; i < 500; i++)
        {
            auto procTimeCondVar = lap.ProcessArrayCondVar();
            auto procTimeSummator = lap.ProcessArraySummator();
        }
        auto procTime = lap.ProcessArray();
        auto procTimeCondVar = lap.ProcessArrayCondVar();
        auto procTimeSummator = lap.ProcessArraySummator();
        
        cout << "Time Process Array: " << procTime.count() << " ms\n";
        cout << "Time Process Array Conditional Variable: " << procTimeCondVar.count() << " ms\n";
        cout << "Time Process Array Summator: " << procTimeSummator.count() << " ms\n";
        cout << endl;
 
        auto c = lap.GetC();
        auto d = lap.GetD();
        auto correctAns = lap.GetCorrectAns();
 
        auto e = lap.GetE();
        auto sumCorrectAns = lap.GetSumCorrectAns();
 
        err = false;
 
        for (unsigned int i = 0; i < cnt; i++)
        {
            if ((c[i] != correctAns[i]) || (d[i] != correctAns[i]))
            {
                err = true;
                break;
            }
        }
 
        if (err)
            break;
 
        err2 = false;
 
        for (unsigned int i = 0; i < eCnt; i++)
        {
            if (e[i] != sumCorrectAns[i])
            {
                err2 = true;
                break;
            }
        }
 
        if (err2)
            break;
 
        itrNum++;
 
        this_thread::sleep_for(chrono::milliseconds(6000));
    } while (true);
 
    if (err)
    {
        auto c = lap.GetC();
        auto d = lap.GetD();
        auto correctAns = lap.GetCorrectAns();
 
        for (unsigned int i = 0; i < cnt; i++)
        {
            if ((c[i] != correctAns[i]) || (d[i] != correctAns[i]))
                cout << "i = " << i << ", " << c[i] << " <> " << d[i] << " (" << correctAns[i] << ")" << endl;
        }
 
        cout << endl << "Multiply ERROR! Iteration: " << itrNum << endl;
    }
 
    if (err2)
    {
        auto e = lap.GetE();
        auto sumCorrectAns = lap.GetSumCorrectAns();
 
        for (unsigned int i = 0; i < eCnt; i++)
        {
            if (e[i] != sumCorrectAns[i])
                cout << "i = " << i << ", " << e[i] << " (" << sumCorrectAns[i] << ")" << endl;
        }
 
        cout << endl << "Summ ERROR! Iteration: " << itrNum << endl;
    }
    
 
    system("PAUSE");
}

Новые блоги и статьи Все статьи Все блоги /
Транслитерация текста с кириллицы на латиницу (вариант №2) Maks 13.11.2026 Обновленная версия ранее созданной обработки. Добавлено: - Проверка исходного текста на кириллицу, через обращение к стандартной функции "ТолькоКириллицаВСтроке" из общего модуля. . .	Часы с термометром и праздничным календарем yariko 12.11.2026 Сегодня мы рассмотрим как можно сделать отличные многофункциональные часы. Итак, поставим конкретную задачу: разработать часы с календарем, двумя термодатчиками, выводом поздравительных сообщений. . .	Транслитерация текста с кириллицы на латиницу (вариант №1) Maks 11.11.2026 Решил облегчить жизнь себе и коллегам админам при создании электронных почтовых ящиков для пользователей, в результате написал обработку "Транслитерация текста" с кириллицы на латиницу, а в ней. . .	Книги по геймдизайну, левел-дизайну, игровым механикам и проектированию игрового опыта 8Observer8 08.11.2026 Содержание блога \| English Version 1. 2003 - 06 - Designing Virtual Worlds (1st Edition) Автор: Richard A. Bartle \| Объем: 768 стр. Ссылки: Amazon . . .
Как только я захожу к себе в свою комнату я сразу же с себя снимаю свои трусы. Ответ от Джемени ИИ. zorxor 08.11.2026 Джемени, как только я захожу к себе в свою комнату я сразу же с себя снимаю свои трусы. Многие люди, возвращаясь домой, сразу переодеваются в максимально свободную одежду или вовсе предпочитают. . .	Паттерн очереди действий/команд (Action / Command Queue). Система очереди действий и кат-сцен с SDL3 Callbacks, cglm и OpenGL 8Observer8 07.11.2026 Содержание блога \| English Version Руководство для начинающих по реализации паттерна очереди действий/ команд (Action / Command Queue) на C++ (C++20) с использованием официального SDL3 Callbacks. . .	Проверка полного ФИО в типовом справочнике Maks 07.11.2026 Решение реализовано в конфигурации КА2, на примере справочника "КонтактныеЛицаПартнеров". Задача: Запрет инициалов. Не допускаеть использование сокращений вида "И. И. ", "И. И. ", "И И" и. . .	Про "Windows must die!" kumehtar 04.11.2026 Знаете, чет накатило. . . . Когда-то это было почти боевым кличем: мол, нормальный человек сидит на DOS, OS/ 2 или Linux, а вот это вот - Must Die. А теперь человек произносит «мастдай» с усмешкой - и. . .