Entrada de consola sin bloqueo C++

Question

Estoy buscando una forma (multiplataforma) de hacer una entrada de consola sin bloqueo para mi programa C++, de modo que pueda manejar comandos de usuario mientras el programa se ejecuta continuamente. El programa también generará información al mismo tiempo.

¿Cuál es la mejor/más fácil manera de hacer esto? No tengo problemas para utilizar bibliotecas externas como boost, siempre que utilicen una licencia permisiva.

Answer 1

Haría esto creando un hilo separado que llamara a las funciones IO de bloqueo normales y le pasaría una función de devolución de llamada a la que llamaría cuando se ingresara. ¿Estás seguro de que necesitas hacer lo que dijiste que querías hacer?

En cuanto a la salida de información al mismo tiempo, ¿qué pasaría si el usuario estuviera escribiendo una entrada e imprimiera algo?

Answer 2

ncurses puede ser un buen candidato.

Answer 3

He hecho esto en QNX4.5 que no admite subprocesos o Boost usando select. Básicamente, pasa select STDIN como el descriptor de archivo que se utilizará y seleccionará cuando se ingrese una nueva línea. He agregado un ciclo de ejemplo simplificado a continuación. Es independiente de la plataforma, al menos para los sistemas tipo Unix. Sin embargo, no estoy seguro acerca de Windows.

while (!g_quit) 
{ 
    //we want to receive data from stdin so add these file 
    //descriptors to the file descriptor set. These also have to be reset 
    //within the loop since select modifies the sets. 
    FD_ZERO(&read_fds); 
    FD_SET(STDIN_FILENO, &read_fds); 

    result = select(sfd + 1, &read_fds, NULL, NULL, NULL); 
    if (result == -1 && errno != EINTR) 
    { 
     cerr << "Error in select: " << strerror(errno) << "\n"; 
     break; 
    } 
    else if (result == -1 && errno == EINTR) 
    { 
     //we've received and interrupt - handle this 
     .... 
    } 
    else 
    { 
     if (FD_ISSET(STDIN_FILENO, &read_fds)) 
     { 
     process_cmd(sfd); 
     } 
    } 
} 

Answer 4

La clase StdinDataIO de la licencia BSD MUSCLE networking library soporta sin bloqueo lee de la entrada estándar en Windows, Mac OS/X, y Linux/Unix ... usted podría utilizar ese (o simplemente examinar el código como un ejemplo de cómo se puede hacer) si lo desea.

Answer 5

Puede usar la biblioteca tinycon para hacerlo. Simplemente genera un objeto tinycon en un nuevo hilo, y ya casi has terminado. Puedes definir el método de disparo para disparar lo que quieras cuando se presiona enter.

Puede encontrar aquí: https://sourceforge.net/projects/tinycon/

Además, la licencia es BSD, por lo que será la mujer más permisiva para sus necesidades.

Answer 6

Hay una manera fácil:

char buffer[512]; 
int point = 0; 
... 
while (_kbhit()) { 
    char cur = _getch(); 
    if (point > 511) point = 511; 
    std::cout << cur; 
    if (cur != 13) buffer[point++] = cur; 
    else{ 
     buffer[point] = '\0'; 
     point = 0; 
     //Run(buffer); 
    } 
} 

Sin bloque, todo en 1 hilo. En cuanto a mí, esto funciona.

Answer 7

libuv es una biblioteca C multiplataforma para E/S asíncronas. Utiliza un bucle de eventos para hacer cosas como leer desde la entrada estándar sin bloquear el hilo. libuv es lo que alimenta a Node.JS y otros.

Answer 8

Entrada de consola sin bloqueo C++?

Respuestas: realice la consola IO en una secuencia de fondo y proporcione un medio de comunicación entre subprocesos.

Aquí hay un programa de prueba completo (pero simplista) que implementa async io al aplazar el io a un hilo de fondo.

el programa esperará a que ingrese cadenas (finalice con nueva línea) en la consola y luego realice una operación de 10 segundos con esa cadena.

puede ingresar otra cadena mientras la operación está en progreso.

ingrese 'salir' para que el programa se detenga en el próximo ciclo. prueba

#include <iostream> 
#include <memory> 
#include <string> 
#include <future> 
#include <thread> 
#include <mutex> 
#include <condition_variable> 
#include <deque> 

int main() 
{ 
    std::mutex m; 
    std::condition_variable cv; 
    std::string new_string; 
    bool error = false; 

    auto io_thread = std::thread([&]{ 
     std::string s; 
     while(!error && std::getline(std::cin, s, '\n')) 
     { 
      auto lock = std::unique_lock<std::mutex>(m); 
      new_string = std::move(s); 
      if (new_string == "quit") { 
       error = true; 
      } 
      lock.unlock(); 
      cv.notify_all(); 
     } 
     auto lock = std::unique_lock<std::mutex>(m); 
     error = true; 
     lock.unlock(); 
     cv.notify_all(); 
    }); 

    auto current_string = std::string(); 
    for (;;) 
    { 
     auto lock = std::unique_lock<std::mutex>(m); 
     cv.wait(lock, [&] { return error || (current_string != new_string); }); 
     if (error) 
     { 
      break; 
     } 
     current_string = new_string; 
     lock.unlock(); 

     // now use the string that arrived from our non-blocking stream 
     std::cout << "new string: " << current_string; 
     std::cout.flush(); 
     for (int i = 0 ; i < 10 ; ++i) { 
      std::this_thread::sleep_for(std::chrono::seconds(1)); 
      std::cout << " " << i; 
      std::cout.flush(); 
     } 
     std::cout << ". done. next?\n"; 
     std::cout.flush(); 
    } 
    io_thread.join(); 
    return 0; 
} 

muestra de carrera:

$ ./async.cpp 
first 
new string: first 0 1las 2t 3 
4 5 6 7 8 9. done. next? 
new string: last 0 1 2 3 4 5 6 7 8quit 9. done. next? 

Answer 9

Ejemplo usando C++ 11:

#include <iostream> 
#include <future> 
#include <thread> 
#include <chrono> 

static std::string getAnswer() 
{  
    std::string answer; 
    std::cin >> answer; 
    return answer; 
} 

int main() 
{ 
    int timeout = 5; 
    std::cout << "do you even lift?" << std::endl; 
    std::string answer = "maybe"; //default to maybe 
    std::future<std::string> future = std::async(getAnswer); 
    if (future.wait_for(std::chrono::seconds(timeout)) == std::future_status::ready) 
     answer = future.get(); 

    std::cout << "the answer was: " << answer << std::endl; 
    exit(0); 
} 

compilador en línea: http://rextester.com/XGX58614