Как добавить задержку по времени в программу на C ++?

Я пытаюсь добавить задержку по времени в программу на C ++, и мне было интересно, есть ли у кого-нибудь предложения о том, что я могу попробовать, или информацию, которую я могу посмотреть?

Мне жаль, что у меня не было более подробной информации о том, как я реализую эту временную задержку, но пока у меня не будет дополнительной информации о том, как добавить временную задержку, я не уверен, как мне даже попытаться реализовать это.

Win32: Sleep(milliseconds)это то, что ты, что

unix: usleep(microseconds)это то, что вы хотите.

sleep () занимает всего несколько секунд, что часто бывает слишком долго.

Обновленный ответ для C ++ 11:

Используйте sleep_forи sleep_untilфункции:

#include <chrono>
#include <thread>

int main() {
    using namespace std::this_thread; // sleep_for, sleep_until
    using namespace std::chrono; // nanoseconds, system_clock, seconds

    sleep_for(nanoseconds(10));
    sleep_until(system_clock::now() + seconds(1));
}

Не С помощью этих функций больше нет необходимости постоянно добавлять новые функции для лучшего разрешения: sleep, usleep, nanosleepи т.д. , sleep_forи sleep_untilявляются функциями шаблонов , которые могут принимать значение любого разрешения по chronoтипам; часы, секунды, фемтосекунды и т. д.

В C ++ 14 вы можете еще больше упростить код с помощью буквальных суффиксов для nanosecondsи seconds:

#include <chrono>
#include <thread>

int main() {
    using namespace std::this_thread;     // sleep_for, sleep_until
    using namespace std::chrono_literals; // ns, us, ms, s, h, etc.
    using std::chrono::system_clock;

    sleep_for(10ns);
    sleep_until(system_clock::now() + 1s);
}

Обратите внимание, что фактическая продолжительность сна зависит от реализации: вы можете запросить сон на 10 наносекунд, но реализация может вместо этого спать на миллисекунду, если это самое короткое из возможных значений.

#include <unistd.h>
usleep(3000000);

Он также будет спать на три секунды. Однако вы можете уточнить числа еще немного.

Вы хотите что-то настолько простое, как

sleep(3);

Обратите внимание, что это не гарантирует, что количество времени, в течение которого поток находится в спящем режиме, будет где-то близко к периоду ожидания, это только гарантирует, что количество времени до того, как поток продолжит выполнение, будет по крайней мере желаемым. Фактическая задержка будет варьироваться в зависимости от обстоятельств (особенно нагрузки на рассматриваемую машину) и может быть на несколько порядков больше, чем желаемое время ожидания.

Кроме того, вы не указываете, почему вам нужно спать, но вам следует избегать использования задержек в качестве метода синхронизации.

Вы можете попробовать этот фрагмент кода:

#include<chrono>
#include<thread>

int main(){
    std::this_thread::sleep_for(std::chrono::nanoseconds(10));
    std::this_thread::sleep_until(std::chrono::system_clock::now() + std::chrono::seconds(1));
}

Вы также можете использовать select (2), если вам нужна микросекундная точность (это работает на платформе, у которой нет usleep (3))

Следующий код будет ждать 1,5 секунды:

#include <sys/select.h>
#include <sys/time.h>
#include <unistd.h>`

int main() {
    struct timeval t;
    t.tv_sec = 1;
    t.tv_usec = 500000;
    select(0, NULL, NULL, NULL, &t);
}

`

Да, сон, вероятно, является здесь предпочтительной функцией. Обратите внимание, что время, переданное функции, - это наименьшее время, в течение которого вызывающий поток будет неактивен. Так, например, если вы вызываете режим сна с 5 секундами, вам гарантируется, что ваш поток будет спать не менее 5 секунд. Может быть 6, 8 или 50, в зависимости от того, что делает ОС. (При оптимальном выполнении ОС это будет очень близко к 5.)
Еще одна полезная особенность функции сна - передать 0. Это вызовет переключение контекста из вашего потока.

Дополнительная информация:
http://www.opengroup.org/onlinepubs/000095399/functions/sleep.html

Я обнаружил, что "_sleep(milliseconds);"(без кавычек) хорошо работает для Win32, если вы включите chronoбиблиотеку

Например:

#include <chrono>

using namespace std;

main
{
    cout << "text" << endl;
    _sleep(10000); // pauses for 10 seconds
}

Убедитесь, что вы добавили подчеркивание перед сном.

для задержки вывода в cpp на фиксированное время вы можете использовать функцию Sleep (), включив синтаксис файла заголовка windows.h для функции Sleep (): Sleep (time_in_ms) как

cout<<"Apple\n";
Sleep(3000);
cout<<"Mango";

ВЫХОД. Приведенный выше код распечатает Apple и подождет 3 секунды перед печатью Mango.

Главный ответ здесь, кажется, зависит от ОС; для более портативного решения вы можете написать функцию быстрого сна, используя файл заголовка ctime (хотя это может быть плохой реализацией с моей стороны).

#include <iostream>
#include <ctime>

using namespace std;

void sleep(float seconds){
    clock_t startClock = clock();
    float secondsAhead = seconds * CLOCKS_PER_SEC;
    // do nothing until the elapsed time has passed.
    while(clock() < startClock+secondsAhead);
    return;
}
int main(){

    cout << "Next string coming up in one second!" << endl;
    sleep(1.0);
    cout << "Hey, what did I miss?" << endl;

    return 0;
}

Синтаксис:

недействительный сон (беззнаковые секунды);

sleep () приостанавливает выполнение на интервал (секунды). При вызове перехода в спящий режим выполнение текущей программы приостанавливается на количество секунд, указанное в аргументе секунды. Интервал имеет точность до ближайшей сотой доли секунды или до точности часов операционной системы, в зависимости от того, что менее точно.

Многие другие предоставили полезную информацию для сна. Я согласен с Веджем в том, что сон редко бывает самым подходящим решением.

Если вы спите, ожидая чего-то, тогда вам лучше на самом деле дождаться этого события / события. Посмотрите на переменные условия для этого.

Я не знаю, на какой ОС вы пытаетесь это сделать, но для потоковой передачи и синхронизации вы можете обратиться к библиотекам Boost Threading ( Boost Condition Varriable ).

Переходя к другой крайности, если вы пытаетесь выжидать исключительно короткие периоды времени, есть несколько вариантов стиля взлома. Если вы работаете на какой-то встроенной платформе, где «сон» не реализован, вы можете попробовать простой цикл (for / while и т. Д.) С пустым телом (будьте осторожны, компилятор не оптимизирует его). Конечно, в этом случае время ожидания зависит от конкретного оборудования. Для действительно коротких "ожиданий" вы можете попробовать сборку "nop". Я очень сомневаюсь, что это именно то, что вам нужно, но, не зная, почему вам нужно ждать, трудно быть более конкретным.

В Windows вы можете включить библиотеку Windows и использовать "Sleep (0);" чтобы спать прогу. Он принимает значение, представляющее миллисекунды.