这段代码使用了线程。

#include <iostream>
#include <thread>
#include <chrono>
#include <string>

int main()
{
   std::string password;
   std::cout << "Enter your password! \n";
   std::cout << "Password: ";

   //try to read a passsword in 10 seconds
   std::thread t1([&]() {
       std::cin >> password;
       });
   std::this_thread::sleep_for(std::chrono::seconds(10));
   t1.detach();

   //check if password was entered
   if (password.empty())
       std::cout << "TIME IS OUT\n";
   else
       if (password == "password123")
           std::cout << "Correct";
       else
           std::cout << "Worng";

   return 0;
}

字符串
但是如果你检查一下，你可以看到它会等到10秒结束，即使用户及时输入了密码。你可以这样改进它：

#include <iostream>
#include <thread>
#include <chrono>
#include <string>

int main()
{
    std::string password;
    std::cout << "Enter your password! \n";
    std::cout << "Password: ";

    time_t start = time(NULL);
    time_t waitTime = 10;

    //try to read a passsword in 10 seconds
    while (time(NULL) < start + waitTime && password.empty())
    {
        std::thread t1([&]() {
            std::cin >> password;
            });
        std::this_thread::sleep_for(std::chrono::milliseconds(20));
        t1.detach();
    }
    
    

    //check if password was entered
    if (password.empty())
        std::cout << "\nTIME IS OUT\n";
    else
        if (password == "password123")
            std::cout << "Correct";
        else
            std::cout << "Worng";

    return 0;
}

型

我最近遇到了同样的问题。我从@user1952500找到了答案，提出了有趣的方法。其中，第二个对我来说更容易理解。
但是，我还没有找到好的代码解决方案。更一般地说，使用detach不会杀死线程，但它允许独立运行（“在主线程之外”）。这意味着线程将永远运行，直到整个代码终止，如果我们分离多个线程，这将是更糟糕的情况。
要使用线程正确地实现超时的键盘输入，必须从另一个线程中杀死该线程。问题是：只使用C++标准库是不可能的。
必须使用依赖于平台的函数。这是我的Linux解决方案：

#include <thread>
#include <chrono>
#include <stdio.h>
#include <pthread.h>
#include <string>

std::chrono::milliseconds now_ms(){
    return std::chrono::duration_cast<std::chrono::milliseconds>(
        std::chrono::system_clock::now().time_since_epoch()
    );
}

int main(){
    // set timeout
    std::chrono::milliseconds timeout(10000);

    // variable to check if the thread terminated by itself
    bool thread_terminated = false;
    // variable to store input 
    std::string answer;
    // create thread
    std::thread t1([&]() {
        std::cin >> answer;
        thread_terminated = true;
    });

    // get native handle
    auto t_handle = t1.native_handle();
    // start the thread
    auto start_ts = now_ms();
    t1.detach()

    // check for timeout or answer received
    while(this->now_ms_d() - start_ts < timeout && answer.empty()){
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
    // if the thread didn't terminate, kill it
    if(! thread_terminated) pthread_cancel(t_handle);
    
    if (answer.empty()){
        std::cout << "no answer received" << std::endl;
    }
    else{
        /* do what you need to do with answer */
    }

    return 0;
}

字符串
对于不同的平台，您需要调用不同的函数，而不是pthread_cancel(t_handle)。
例如，在Windows上，您可以使用TerminateThread。

一个规范的C++解决方案应该是这样的：

#include <iostream>
#include <chrono>
#include <string>

int main() {
     std::string password;

     std::cout << "Enter your password! \n";
     std::cout << "Password: ";
     auto start_s = std::chrono::system_clock::now();
     std::cin >> password;

     auto stop_s = std::chrono::system_clock::now();
     if(stop_s - start_s >= std::chrono::seconds(10)) {
        std::cout << "TIME RAN OUT!";
     }
     else if (password == "password123") {
            std::cout << "Correct!";
     } else {
         std::cout << "Wrong!";
     }

}

字符串

您要做的是从stdin进行一次非阻塞（异步）读取，超时时间为10秒。这不是太坚韧，但可能涉及到许多新的概念，这取决于你目前的水平。
这里的关键概念是cin >> password;是一个 * 阻塞 * 调用，也就是说，在它完成之前，控制不会在此代码中进一步流动。所以我们需要以某种方式使它非阻塞，或者保持它阻塞，并在超时到期时打破它。
根据系统的设计要求和约束，有几种常见的实现方式。每种实现方式都因操作系统而异，但技术非常相似。

1.异步：带超时的STDIN这种方法通常用于网络编程，可以扩展到其他形式的输入，例如当前情况。

1.将标准输入（STDIN）句柄（handle = 0）放入“监视列表”。
1.在监视列表中设置超时。
1.无论何时STDIN发生变化，都应进行处理。
1.当超时过期时，检查我们处理的内容是否完成了工作。
在Linux（以及许多其他Unix版本）中，可以使用FD_SET和select系统调用来处理监视列表。在Windows中，您需要使用WaitForMultipleEvents。
我不确定我是否能为这个问题的目的准确地解释这些概念。作为参考，另一个有一些代码指针的问题是here。

2.同步：带中断的多线程这是一种常见的技术，用于需要细粒度事件调度程序/定时器的情况。

1.创建两个线程A和B。

1. A将等待指示的超时。
2. B将等待阻塞读取
   1.如果A在B完成之前终止（超时），则A向B发送信号，B决定下一步要做什么（终止、重复消息等）
   1.如果B读取了密码并且它正常，则B向A发送信号并要求它死亡。
   另一种实现相同的方法是使OS中断线程B如comments之一中所述。

3.同步：轮询这是用于我们不需要太多细粒度控制的情况。

1.使用非阻塞读取（kbhit()）检查输入中是否有任何内容
1.如果没有，并且超时还有剩余时间，则等待更短的时间delta（例如10ms）
1.如果超时已经过期并且没有剩余时间，则执行任何需要的处理（通知用户、退出等）
注意，在这种情况下，根据delta，该方法可能会消耗大量CPU，并且可能效率低下。例如，如果delta=10ms如上所述，线程将每秒被唤醒100次，这将是低效的，特别是当用户在键盘上输入字符不那么快时。