Остановка выполнения программы на C++

#include <iostream>
 
    using namespace std;

Здесь функция остановки программы, если ее работа превышает 1-2 секунды

int main() {
    Код программы...
return 0;
}

#include <iostream>
#include <climits>
#include <fstream>
#include <chrono> 
 
    using namespace std;
 
int main() {
    
    auto start = chrono::high_resolution_clock::now();
    
    ifstream in("input.txt");
    int n, m, x, y, max;
    in >> n >> m;
    int** a = new int*[n];
    for (int i = 0; i < n; i++) {
        a[i] = new int[m];
    }
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            in >> a[i][j];
        }
    }
    for (int i = 1; i <= 400000000; i++); //Задержка выполнения ~ 0.6 сек.(на моем PC)
    max = INT_MIN;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (a[i][j] > max) {
                max = a[i][j];
                x = i;
                y = j;
            }
        }
    }
    cout << ++x << " " << ++y << "\n";
    for (int i = 0; i < n; i++) {
        delete[] a[i];
    }
    delete[] a;
    
    auto finish = std::chrono::high_resolution_clock::now();
    auto duration = chrono::duration_cast<chrono::microseconds>(finish - start).count();
    cout.precision(3);
    cout << "Elapsed time: " << fixed << (double)duration / 1000000.0 << "\n";
    
    return 0;
}

#include <iostream>
#include <chrono>
#include <thread>
#include <ctime>
#include <atomic>
 
//#include <mutex>
//std::mutex mym;
 
void user_main(std::atomic<int>& b, int argc, char ** argv)
{
    // код пользователя
    std::this_thread::sleep_for(std::chrono::seconds(1));
    
    //std::lock_guard<std::mutex> lock(mym);
    b = 1;
}
 
using time_ = std::chrono::duration<double, std::milli>;
 
#define TIME_START  auto s = std::chrono::high_resolution_clock::now()
#define TIME_FINISH auto f = std::chrono::high_resolution_clock::now() - s
 
int main(int argc, char ** argv)
{   setlocale(0, "");
 
    std::atomic<int> a{0};
                                                        
    auto timer = [](std::atomic<int>& t)
    {   std::this_thread::sleep_for(std::chrono::seconds(6));
        //std::lock_guard<std::mutex> lock(mym);
        t = 2;
    };
    
    std::thread timer_(timer, std::ref(a));
                timer_.detach();
    
    TIME_START;
    std::thread user_(user_main, std::ref(a), argc, argv);
                user_.detach();
                
    int   b = 0;
    while(b == 0)
    {   std::this_thread::sleep_for(std::chrono::seconds(1));
        //std::lock_guard<std::mutex> lock(mym);
        b = a;
    }
    TIME_FINISH;
 
    if(a == 2) std::cout << "Лимит времени исчерпан!\n\n";
    else
    {   std::cout << "user_main() закончил работу.\n\n";
        std::cout << "Затраченное время: " << time_(f).count()//1000
                  << " sec.\n\n";
    }
 
    std::cout << "Для выхода в ОС нажмите ENTER\n";
    std::cin.get();
    return 0;
}

#include <iostream>
#include <thread>
#include <future>
 
int user_main(int argc, char ** argv)
{
    // Код пользователя, эмулируем задержку в 1 сек
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return 0;
}
 
int main(int argc, char ** argv)
{
    std::chrono::microseconds timeout{3000000}; // время для ожидания (3 sec)
 
    using result_type = std::pair<int, std::chrono::microseconds>;
 
    std::future<result_type> res = std::async(std::launch::async
      , [](int argc, char ** argv)
        {
            using namespace std::chrono;
 
            auto beg = high_resolution_clock::now();
            int code = user_main(argc, argv);
            auto end = high_resolution_clock::now();
 
            return std::make_pair(code, duration_cast<microseconds>(end - beg));
        }
      , argc, argv
    );
    std::future_status status;
    do
    {
        status = res.wait_for(timeout);
        if(status == std::future_status::timeout)
        {
            std::cout << "Time Limit Exceeded\n";
        }
        else if(status == std::future_status::ready)
        {
            result_type v = res.get();
            std::cout << "Execution time " << (v.second.count() / 1000000.)
                      << " sec, with code " << v.first << '\n';
        }
    }
    while(status == std::future_status::deferred);
}