C++同时输入输出到控制台窗口

发布于 2024-11-24 07:55:07 字数 287 浏览 1 评论 0原文

我正在编写一个服务器（主要用于Windows，但如果我可以保持它的多平台，那就太酷了），我只使用一个普通的控制台窗口。但是，我希望服务器能够执行诸如 say text_to_say_here 或 kick playername 等命令。我怎样才能有异步输入/输出？我已经用普通的 printf() 和 gets_s 尝试了一些东西，但这导致了一些非常......奇怪的东西。

我的意思是这样的1

谢谢。

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

身边 2024-12-01 07:55:07

利用 C++11 功能（即跨平台）的快速代码

#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;
}

Quick code to take advantage of C++11 features (i.e. 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;
}

回复收藏 0 原文

ヤ经典坏疍 2024-12-01 07:55:07

您可以使用线程模拟异步 I/O，但更重要的是，您必须在两个读/写线程之间共享互斥锁，以避免一个线程踩在另一个线程上并在输出之上写入控制台的任何问题另一个线程的。换句话说，std::cout、std::cin、fprintf()等都不是多线程安全的，并且作为结果，您将在两个操作之间得到不可预测的交错模式，其中一个读或写发生，而另一个读或写已经发生。您很容易会在写入过程中尝试进行读取，此外，当您在控制台上键入输入时，另一个写入线程可能会开始在控制台上写入，从而使您的内容在视觉上变得混乱。正在尝试键入作为输入。

为了正确管理异步读写线程，最好设置两个类，一个用于读取，另一个用于写入。在每个类中，设置一个消息队列，该队列将存储消息（很可能是 std::string）供主线程在读取线程的情况下检索，并供主线程推送消息对于写线程的情况。您可能还想制作一个特殊版本的读取线程，它可以打印提示，主线程将消息推送到其消息队列中，主线程将在从 stdin 或 读取之前打印提示>std::cin。然后，两个类将共享一个公共互斥体或信号量，以防止不可预测的 I/O 交错。通过在任何 iostream 调用之前锁定公共互斥体（之后解锁），可以避免任何不可预测的 I/O 交错。每个线程还将添加另一个互斥体，该互斥体对于每个线程都是唯一的，可用于保持对类的内部消息队列的访问的排他性。最后，您可以将每个类中的消息队列实现为 std::queue。

如果您想让您的程序尽可能跨平台，我建议使用 Boost::threads 或使用新的 C++0x std::threads 库来实现这一点。

You can simulate asynchronous I/O using threads, but more importantly, you must share a mutex between the two read/write threads in order to avoid any issues with a thread stepping on another thread, and writing to the console on top of the output of another thread. In other words std::cout, std::cin, fprintf(), etc. are not multi-thread safe, and as a result, you will get an unpredictable interleaving pattern between the two operations where a read or write takes place while another read or write was already happening. You could easily end up with a read trying to take place in the middle of a write, and furthermore, while you're typing an input on the console, another writing thread could start writing on the console, making a visual mess of what you're trying to type as input.

In order to properly manage your asynchronous read and write threads, it would be best to setup two classes, one for reading, and another for writing. In each class, setup a message queue that will either store messages (most likely std::string) for the main thread to retrieve in the case of the read thread, and for the main thread to push messages to in the case of the write thread. You may also want to make a special version of your read thread that can print a prompt, with a message pushed into its message queue by the main thread that will print a prompt before reading from stdin or std::cin. Both classes will then share a common mutex or semaphore to prevent unpredictable interleaving of I/O. By locking the common mutex before any iostream calls (an unlocking it afterwards), any unpredictable interleaving of I/O will be avoided. Each thread will also add another mutex that is unique to each thread that can be used to maintain exclusivity over access to the class's internal message queue. Finally, you can implement the message queues in each class as a std::queue<std::string>.

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

回复收藏 0 原文