C ++ Input and output to the console window simultaneously

Question

I write a server (mainly for windows, but it would be great if I could support its multi-platform), and I just use the usual console window for this. However, I want the server to be able to execute commands like text_to_say_here or kick the username, etc. How can I get asynchronous input / output? I already tried some things with the usual printf () and gets_s, but this led to some really ... weird things.

I mean something like 1

thanks.

Answer 1

Fast code to take advantage of C ++ 11 features (e.g. cross-platform)

#include <atomic> #include <thread> #include <iostream> void ReadCin(std::atomic<bool>& run) { std::string buffer; while (run.load()) { std::cin >> buffer; if (buffer == "Quit") { run.store(false); } } } int main() { std::atomic<bool> run(true); std::thread cinThread(ReadCin, std::ref(run)); while (run.load()) { // main loop } run.store(false); cinThread.join(); return 0; } 

Answer 2

You can simulate asynchronous I / O using threads, but more importantly, you should share the mutex between the two read / write streams in order to avoid problems with the stream advancing to another stream, and write to the console on top of the output of the other stream. In other words, std::cout , std::cin , fprintf() , etc. They are not multithreaded, and as a result you will get an unpredictable pattern of alternation between two operations in which reading or writing occurs, while another reading or writing was already there. You could easily finish reading by trying to take place in the middle of the recording, and in addition, while you type in the input to the console, another stream of letters can start writing to the console, creating a visual mess of what you're trying to enter as input.

To properly manage asynchronous read and write streams, it would be better to configure two classes: one for reading and the other for writing. In each class, set up a message queue that either saves messages (most likely std::string ) for the main stream, which will be retrieved in case of a read stream, and for the main stream for entering messages in the case of a write stream, You may also want to create A special version of the read stream that can print the invitation, with the message placed in the message queue by the main stream, which will print the invitation before reading from stdin or std::cin . Then both classes will have a common mutex or semaphore to prevent unpredictable I / O interleaving. By blocking the shared mutex before any iostream calls (after it is unlocked), any unpredictable I / O rotation can be avoided. Each thread will also add another mutex, which is unique to each thread, which can be used to provide exclusivity when accessing the class’s internal message queue. Finally, you can implement message queues in each class as std::queue<std::string> .

If you want to make your program as cross-platform as possible, I would suggest implementing it either with Boost :: threads or with the new std :: threads C ++ 0x libraries.

Answer 3

If you turn off the console window and use TCP connections for management and control, it will be much easier for your server to support multi-platform, as well as simpler and more flexible.

Answer 4

You can try placing input and output in separate threads. I'm not quite sure why you want to do this, but threads should do the job. :)

http://en.wikibooks.org/wiki/C++_Programming/Threading