Пользовательский ввод C++ во время поиска связанного файла

Я пытался уничтожать/уничтожать потоки с помощью cin, getchar и т. д. и всегда наблюдал случаи, когда команда неверна.

Поэтому, если можно иметь несколько exe-файлов, я предлагаю использовать выделенный процесс (и, возможно, другое консольное окно) для ввода и подход межпроцессного взаимодействия.

Вот пример (только для Windows) с использованием именованных каналов. Не до конца, но все же дает представление. IPC (имя, сокет и т. д.) существуют на всех платформах, и я почти уверен, что вы найдете переносимый класс. Возможно, система («начать ...») также должна будет зависеть от платформы.

main.cpp

#include <iostream>
#include <thread>
#include <mutex>
#include <string>
#include <queue>
#include <chrono>
#include <windows.h>
#define BUFSIZE 256
using std::thread;

bool running = true;
unsigned long nb_secs = 0;
std::mutex mtx;
static std::string command;
static std::queue<std::string> commands;

// simulates your calculations
void count_secs(){
    while(nb_secs < 100){
        std::this_thread::sleep_for(std::chrono::seconds(1));
        nb_secs++;
    }
}
// pipe name
LPCTSTR lpszPipename = TEXT((char*) "\\\\.\\pipe\\MethodiclesCmdPipe");
HANDLE hPipe;


void get_cmd(HANDLE cltPipe){
    DWORD bytesRead;
    BOOL ret_code;
    std::vector<char> buffer(BUFSIZE);
    do {
        ret_code = ReadFile(cltPipe, buffer.data(), buffer.size(), &bytesRead, NULL);
        if (!ret_code || bytesRead == 0) {
            if (GetLastError() == ERROR_BROKEN_PIPE) {
                std::cout<<"**error** BROKEN_PIPE."<<std::endl;
                break;
            } else {
                std::cout<<"**error** ReadFile failed, GLE = "<<GetLastError()<<std::endl;
                break;
            }
            // manage errors, more data & cie
        }
        std::lock_guard<std::mutex> lock(mtx);
        commands.push(std::string(buffer.data()));
        
    } while (bytesRead > 0  && running);
    FlushFileBuffers(cltPipe);
    DisconnectNamedPipe(cltPipe);
    CloseHandle(cltPipe);
    running = false;// no commands => exit
}


int main(int argc, char *argv[])
{
    // create an IPC - a windows namedpipe here but you may find more portable
    HANDLE hPipe = CreateNamedPipe(
                                lpszPipename, // pipe name
                                PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, // read/write access
                                PIPE_TYPE_MESSAGE | // message type pipe
                                PIPE_READMODE_MESSAGE | // message-read mode
                                PIPE_WAIT, // blocking mode
                                PIPE_UNLIMITED_INSTANCES, // max. instances
                                BUFSIZE, // output buffer size
                                BUFSIZE, // input buffer size
                                0, // client time-out
                                NULL);
    if (hPipe == INVALID_HANDLE_VALUE) {
        std::cout<<"**error** Creating named pipe. GLE = "<< GetLastError()<<std::endl;
        return 1;
    }
    // run input process
    system("start MethodiclesInput.exe");// start /B MethodiclesInput.exe to have all in the same console
    
    std::cout<<"Waiting for client to connect..."<<std::endl;
    if (ConnectNamedPipe(hPipe, NULL) ? TRUE : (GetLastError() == ERROR_PIPE_CONNECTED)) {      
        std::cout<<"Client connected!"<<std::endl;
    } else {
        std::cout<<"**error** Error connecting to client. GLE = "<< GetLastError()<<std::endl;
        return 1;
    }
    
    // a simple thread that counts 1 sec loop   
    thread(count_secs).detach();
    // the pipe (commands) reader
    thread(get_cmd, hPipe).detach();
    while(running) 
    {
        // commented : not given in your example
        // if (completedThreads.load() == threadPool.size())
        // ...
    
        // that part comes instead of std::cin>>
        {
            // every once in a while, read the commands (could also check if empty everytime, depending on what's in your loop while(running)
            std::this_thread::sleep_for(std::chrono::seconds(2));
            std::lock_guard<std::mutex> lock(mtx);// will use commands now
            if (commands.empty())
                std::cout<<'.';// purely informative...
            else while(!commands.empty()){
                command = commands.front();
                commands.pop();
                std::cout<<"Got command "<<command<<std::endl;
                if (command == "dump"){
                    std::cout<<"Dumping Results: " << std::endl;
                    std::cout<<"\n val is " << nb_secs << std::endl;
                }
                else if (command == "exit"){
                    running = false;
                    //results.clear();
                    //cv.notify_all();
                    //break;
                    system("taskkill /IM MethodiclesInput.exe");
                    
                }
            }
        }
        // ...
   }
   return 0;
}

inputconsole.cpp

#include <iostream>
#include <string>
#include <windows.h>
using std::cout;
using std::endl;
LPCTSTR lpszPipename = TEXT((char*) "\\\\.\\pipe\\MethodiclesCmdPipe");

int main(){
    HANDLE hPipe;

    hPipe = CreateFile(
                    lpszPipename, // pipe name
                    GENERIC_WRITE, // write access
                    0, // no sharing
                    NULL, // default security attributes
                    OPEN_EXISTING, // opens existing pipe
                    0, //FILE_FLAG_OVERLAPPED 
                    NULL); // no template file

    // Exit if an error other than ERROR_PIPE_BUSY occurs
    int l = GetLastError();
    //.. manage errors!
    if (hPipe != INVALID_HANDLE_VALUE) {
        do {
            LPDWORD cbWritten;
            //WriteFile(hPipe, LPTSTR((char*)"Hello"),12,  cbWritten, NULL);
            //cout<<"Sent hello : "<<cbWritten<<endl;
            cout<<"Enter command."<<endl;
            std::string command;
            std::cin>>command;
            LPTSTR lpvMessage = (char*) command.c_str();
            size_t cbToWrite = (lstrlen(lpvMessage) + 1) * sizeof (TCHAR);

            // sends message through the named pipe
            int fSuccess = WriteFile(
                                hPipe, // pipe handle
                                lpvMessage, // message
                                cbToWrite, // message length
                                cbWritten, // bytes written
                                NULL); // not overlapped
            if (!fSuccess) {
                int l = GetLastError();
                if (l) {
                    if (l != ERROR_PIPE_BUSY) {
                        cout<<"**error** Couldnt write in pipe. GLE = "<<l<<endl;
                        Sleep(50);

                        if (l == 6) {
                            cout<<"Closing handle "<< hPipe<<endl;
                            CloseHandle(hPipe);
                            // try to reconnect or (cleanup &) exit
                            getchar();
                            return 0;
                        }
                    } else if (!WaitNamedPipe(lpszPipename, 5000)) {
                        cout<<"**error** Could not open pipe: 5 second wait timed out. GLE = "<<GetLastError()<<endl;
                    }
                    // there might be other reasons  / errors to manage
                }
            }
            if (!fSuccess) {
                break;
            }
        } while (true);

        
    }
    getchar();
    return 0;
}

бегать

g++ inputconsole.cpp -o MethodiclesInput
g++ main.cpp -o test && test

Надеюсь, вам понравится, получайте удовольствие!