Проверить, завершит ли функция работу за X мс. (Потоки)

#include <iostream>
#include <conio.h>
#include <thread>
 
using namespace std;
 
template<typename Function, typename... Args>
bool returnedInMilliseconds(unsigned long long milliseconds, Function fn, Args... arg)
{
    volatile bool returned = false, timeOver = false;
    
    auto fn1 = []
    (Function _fn)
    {
        _fn(arg);
        returned = true;
    };
 
    auto waitFn = []
    (unsigned long long ms)
    {
        _sleep(ms);
        timeOver = true;
    };
 
    _STD thread t1(fn1, fn);
    _STD thread t2(_sleep, milliseconds);
 
    while (1)
    {
        if (returned)
            return true;
        if (timeOver)
            return false;
    }
}
 
int main()
{
    
    cout << boolalpha << returnedInMilliseconds(5000, _getch);
 
    return 0;
}

auto waitFn = [&]
(unsigned long long ms)
{
    _sleep(ms);
    timeOver = true;
};

std::future

std::promise

#include <thread>
#include <future>
#include <iostream>
 
void test_function()
{
    std::cin.get();
}
 
template<typename Function, typename... Args>
bool returnedInMilliseconds(unsigned long long milliseconds, Function fn, Args... args)
{
    std::promise<void> promise;
    const std::future<void> future = promise.get_future();
 
    std::thread thread([&]
    {
        try {
            fn(std::forward<Args>(args)...);
            promise.set_value();
        }
        catch (...) {
            // Если вызвать у future метод get, то он выкинет пойманное тут исключение
            promise.set_exception(std::current_exception());
        }
    });
 
    // Тут зависит от вашей задачи
    thread.detach();
 
    const auto status = future.wait_for(std::chrono::milliseconds(milliseconds));
    return status == std::future_status::ready;
}
 
int main()
{
    const bool returned = returnedInMilliseconds(1000, &test_function);
    std::cout << std::boolalpha << returned;
    return 0;
}