Использование станд :: вектор станд :: нить

Question

У меня есть программа, где я пройти через каждый класс в станд :: вектор, сделать некоторые операции на нем и записать его на новый станд :: вектор

В моя программа std :: vector большая, а операции, выполняемые в классах, занимают много времени. Так что мне было интересно, могу ли я использовать std :: thread, чтобы разбить операцию на std :: vector на куски. То, что я имею в виду под этим

============================== std::vector 
^ Processing by a single thread 

========== ========== ========== 
^ thread 1^thread 2 ^thread 3 

Так в идеале я бы нить 1, идущей от 1 до 10000 элементов резьбы 2 через следующую порцию элементов.

Также в конце я хочу, чтобы выход присутствовал в одном векторе. Поэтому мне не придется создавать несколько std :: векторов и присоединяться к нему.

Если это помогает, я работаю над созданием чего-то вроде нейронной сети. Хотя это не совсем так, поэтому я не могу использовать популярные реализации.

Что я опробовал: (ОТ ПРЕДЛОЖЕНИЮ НИЖЕ)

class obj_thread { 
private: 
    std::mutex m_mutex; 
    std::vector<int> *_data ; 
public: 
    obj_thread(int _size = 0) 
    { 
     _data = new std::vector<int>(0); 
     for(int elem_ = 0 ; elem_ < _size ; ++elem_) 
      _data->push_back(elem_ * 9); 
    } 
    ~obj_thread() 
    { 
     delete _data; 
    } 
    void setElemAt(int _val , int _elem) 
    { 
     std::lock_guard<std::mutex> locker(m_mutex); 
      _data->at(_elem) = _val; 
    }; 
    int getElem(int _elem) const { return _data->at(_elem);} 
    int getSize() const 
    { 
    // std::lock_guard<std::mutex> locker(m_mutex); 
     return _data->size(); 
    }; 
}; 

void zeroOut(std::vector<obj_thread*> * _obj , int _beg , int _end) 
{ 
    for(int idx_ = _beg ; idx_ < _end ; ++idx_) 
    { 
     for(int idxx_ = 0 ; idxx_ < _obj->at(idx_)->getSize() ; ++idxx_)  
      _obj->at(idx_)->setElemAt(0,idxx_); 
    } 
} 



int main() { 

std::vector<obj_thread*> * vec = new std::vector<obj_thread*>(0); 
for(unsigned int index_ = 0 ; index_ < _SIZE_ ; ++index_) 
    vec->push_back(new obj_thread(_SIZE_)); 


    std::thread thread1(zeroOut,vec,_SIZE_/4,_SIZE_/2); 
    std::thread thread2(zeroOut,vec,_SIZE_/2,_SIZE_*3/4); 
    std::thread thread3(zeroOut,vec,_SIZE_*3/4,_SIZE_); 

    thread1.join(); 
    thread2.join(); 
    thread3.join(); 

return 0 ; 
} 

Answer 1

модель вашей работы после станд :: копии.

Что-то вдоль линии

#include <thread> 

std::vector<int> in; // make whatever size you want 
std::vector<int> out; 

auto m_in = in.cbegin() + in.size()/2; 
auto m_out = out.begin() + in.size()/2; 

std::thread t1(std::copy, in.cbegin(), m_in, out.begin()); 
std::thread t2(std::copy, m_in, in.cend(), m_out); 

t1.join(); 
t2.join(); 

Это якобы скопировать половину входящего массива в одном потоке, а вторую половину в другом потоке. Не испытано!

Если это то, что вы хотите, теперь вы должны написать функцию, аналогичную StD :: копию, просто заменить задание с доменом конкретных обработки

http://www.cplusplus.com/reference/algorithm/copy/