Выполнение / оставайтесь в цикле в течение определенного времени, например, 1 минута

Используйте #include <chrono>

auto t0 = std::chrono::system_clock::now();
while ( (std::chrono::system_clock::now()-t0) < std::chrono::minutes{1})
{
    // do stuff
}

Этот фрагмент кода нуждается как минимум в C++ 11 и может содержать несколько сложных объектов C++, но вот как я это себе представлял.

#include <iostream>
#include <future>     //std::async
#include <atomic>
#include <chrono>
#include <sstream>

int main()
{   
    int i = 0;
    std::stringstream sstr;
    std::atomic<bool> do_it(true);

    //store future so that async returns immediately
    //see Notes paragraph on https://en.cppreference.com/w/cpp/thread/async
    auto fut = std::async(std::launch::async, [&do_it]() {
                                                        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
                                                        do_it = false;
                                                    });

    //Preemtion could steal some time here...

    while ( do_it )
    {
        sstr << "Iteration: " << ++i << "\n";
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }

    std::cout << sstr.str() << "\n" << std::flush;

    std::cout << "Bye\n" << std::flush;
}

Результат (вы можете попробовать его на онлайн-компиляторе С++, например колиру)

Iteration: 1
...
Iteration: 95
Iteration: 96
Iteration: 97
Iteration: 98

Bye

Надеюсь, поможет

Вот самый простой ответ:

#include <chrono>
#include <iostream>

int
main()
{
    using namespace std;
    using namespace std::chrono;
    auto finish = system_clock::now() + 1min;
    do
    {
        cout << "stuff\n";
    } while (system_clock::now() < finish);
}

Для этого требуется C++14 или C++17. Если вы используете C++11, замените minutes{1} на 1min. Если вы используете C++03, <chrono> недоступен, и вам придется использовать C API для синхронизации, что значительно сложнее в использовании.

Вот видеоурок по <chrono>.

Другим ответом может быть использование условной переменной, чтобы справиться с уродливой спать_для(...), часто используемой, как в моем первом ответе, что приводит только к 98 итерациям вместо 100 из-за времени, затрачиваемого приложением/вычислениями (здесь печатается некоторый номер цикла внутри строковый поток).

Переменные условия могут быть нацелены более чем на 1 поток

#include <iostream>
#include <thread>
#include <condition_variable>
#include <atomic>
#include <chrono>
#include <sstream>

//From https://en.cppreference.com/w/cpp/thread/condition_variable/wait_until

int index[2] = { 0 };
std::stringstream sstr;
std::condition_variable cv;
std::mutex cv_m;
std::atomic<bool> do_it(true);

std::mutex mut_print;

void foo(char id, int * index)
{ 
    if ( ! index ) return;

    auto new_tp = std::chrono::system_clock::now();

    while ( do_it )
    {   
        {
            std::lock_guard<std::mutex> lock(mut_print);
            sstr << "Iteration of "<< id << ": " << ++(*index) << "\n";
        }

        new_tp += std::chrono::milliseconds(10);

        while ( do_it )
        {   
            std::unique_lock<std::mutex> lk(cv_m);
            if (std::cv_status::timeout == cv.wait_until(lk,new_tp ) ) {
                break;
            }
        }
    }
}

void signals()
{
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    do_it = false;
    cv.notify_all();
}

int main()
{   
    std::thread t1(foo,'A',&index[0]),t2(foo,'B',&index[1]),ts(signals);

    t1.join();
    t2.join();
    ts.join();

    std::cout << sstr.str() << "\n" << std::flush;

    std::cout << "Bye\n" << std::flush;
}

колиру

Результат

Iteration of A: 1
Iteration of B: 1
Iteration of A: 2
Iteration of B: 2
...
Iteration of A: 100
Iteration of B: 100
Iteration of A: 101
Iteration of B: 101

Bye

На этот раз мы зашли слишком далеко со 101 итерацией, но этот пример не претендует на выполнение ограниченного/заданного количества раз.