Написать консольную программу для генерации сигнатуры указанного файла (задействовать параллелизм)

#include <queue>
#include <memory>
#include <mutex>
#include <condition_variable>
 
template <class T>
class tsQueue
{
private:
    mutable std::mutex trafLight;
    std::queue<T> fifo;
    std::condition_variable tCondition;
 
public:
    tsQueue(){}
    tsQueue(tsQueue const& another){
        std::lock_guard<std::mutex> lk(another.trafLight);
        fifo = another.fifo;
    }
 
    tsQueue& operator= (const tsQueue&) = delete;
 
    void push (T new_value){
        std::lock_guard<std::mutex> lk(trafLight);
        fifo.push(new_value);
        tCondition.notify_one();
    }
 
    void pop (T& value){
        std::unique_lock<std::mutex> lk(trafLight);
        tCondition.wait(lk, [this]{return !fifo.empty();});
        value = fifo.front();
        fifo.pop();
    }
 
    T pop (){
        std::unique_lock<std::mutex> lk(trafLight);
        tCondition.wait(lk, [this]{return !fifo.empty();});
        T value = fifo.front();
        fifo.pop();
        return value;
    }
 
    bool empty()const {
        std::lock_guard<std::mutex> lk(trafLight);
        return fifo.empty();
    }
 
 
};

#ifndef SIGN_H
#define SIGN_H
 
#include <iostream>
#include <fstream>
#include <exception>
#include <stdexcept>
#include <thread>
#include <atomic>
 
#include "safequeu.h"
 
#define MAXLEN 128
#define DEFBLOCKSIZE 1024 // размер блока в Кб
 
using namespace std;
 
class SignCreater {
private:
    char innerFile [MAXLEN];
    char outerFile [MAXLEN];
    unsigned int blockSize;
    std::atomic<bool> finish;
    ifstream hInnerFile;
    ofstream hOuterFile;
    tsQueue<std::shared_ptr<char>> fifoWrite;
    tsQueue<std::shared_ptr<char>> fifoHash;
    tsQueue<unsigned int> fifoAnswerHash;
 
public:
    SignCreater(){
        finish.store(false);
        blockSize = DEFBLOCKSIZE * 1024;
        for (int i =0 ;i < MAXLEN; i++)
            innerFile[i]=0, outerFile[i]=0;
 
    }
    ~SignCreater(){
        if(hInnerFile.is_open())
            hInnerFile.close();
        if(hOuterFile.is_open())
            hOuterFile.close();
    }
 
    void processing();
    void getInOutFile();
    void readFile();
    void writeFile();
    uint32_t CRC32(unsigned char *block, unsigned int len);
 
};
 
 
#endif // SIGN_H

#include "signClass.h"
#include <future>
 
void SignCreater::getInOutFile(){
    char ch = 0;
 
    do {
        try {
            cout<<"Введите полный путь до входящего файла:"<<endl;
            cin.unsetf(ios::skipws);
            cin.getline(innerFile, MAXLEN);
            if(cin.good()){
                hInnerFile.exceptions(ios::failbit|ios::badbit|ios::eofbit);
                hInnerFile.open(innerFile, ios::out|ios::binary);
 
                cout<<"Enter path for outputfile: "<<endl;
                cin.getline(outerFile, MAXLEN);
                if(outerFile == 0){
                    cout<<"File will be create in local directory!"<<endl;
 
                }
                hOuterFile.exceptions(ios::failbit|ios::badbit);
                hOuterFile.open(outerFile, ios::in|ios::binary|ios::app);
 
                cout<< "Enter size of block (Kb): ";
                cin>>blockSize;
                if(cin.good())
                {
                    if(blockSize == 0){
                       blockSize = DEFBLOCKSIZE;
                    }
                    blockSize *= 1024;
                }
                break;
            }
 
        }
        catch (ios::failure &err){
            cerr<<"Ошибка: "<<err.what()<<endl;
            cerr<<"Невозможно найти или открыть Inner файл!"<<endl;
            cin.clear();
            cout<<"Хотите попробовать еще раз? y/n"<<endl;
            cin>>ch;
        }
        catch (range_error &err){
            cerr<<"Ошибка: "<< err.what()<<endl;
            cin.clear();
            cout<<"Хотите попробовать еще раз? y/n"<<endl;
            cin>>ch;
        }
    } while(ch == 'y');
}
 
void SignCreater::readFile(){
    unsigned int size;
 
    hInnerFile.seekg(0, ios::end);
    size = hInnerFile.tellg();
    hInnerFile.seekg(0, ios::beg);
 
    try{
        if(!hInnerFile.is_open()){
 //           throw system_error(errno);
        }
        else
        {
            int k=0;
            while(!hInnerFile.fail()&& !hInnerFile.eof()){
                if(size<blockSize)
                    blockSize = size;
                shared_ptr<char> pInBlock(new char [blockSize], [](char * buf) {delete[] buf;});
                hInnerFile.read(pInBlock.get(), blockSize);
                fifoWrite.push(pInBlock);
                fifoHash.push(pInBlock);
               size -= blockSize;
               ++k;
               cout<<k<<endl;
            }
            finish.store(true);
            hInnerFile.close();
 
        }
    }
    catch(system_error &err){
 
    }
}
 
//Функция перед запуском должна проверяться на наличие элементов в очереди
//Должна быть функция обрабатывающая очередь и передающая указатель блока на запись и подсчет хэша
 
void SignCreater::writeFile(){
    try{
        if(!hOuterFile){
            //здесь что то должно быть
        }
        else{
            hOuterFile.clear();
            while(!finish.load() && !fifoWrite.empty()){
                shared_ptr<char> pOutBlock(new char [2048], [] (char *buf){delete [] buf;});
                fifoWrite.pop(pOutBlock);
                hOuterFile.write(reinterpret_cast<char*>(pOutBlock.get()), 2048);
            }
            cout<<"Finish:"<<finish<<endl;
        }
    }
    catch (system_error &err){
 
    }
 
}
 
 
void SignCreater::processing(){
    this->getInOutFile();
 
    try {
        std::thread readingThread(&SignCreater::readFile, this);
            if(readingThread.joinable())
                readingThread.detach();
 
        std::thread writeThread(&SignCreater::writeFile, this);
            if(writeThread.joinable())
                writeThread.join();
 
    }
    catch(system_error& err){
        cerr<<"Error thread: "<<err.what()<<endl;
    }
}