Я пытаюсь добавить временную задержку в программе на С++ и задавался вопросом, есть ли у кого-нибудь какие-либо предложения о том, что я могу попробовать или информацию, на которую я могу смотреть?
Мне хотелось бы получить более подробную информацию о том, как я выполняю эту задержку по времени, но пока у меня не будет дополнительной информации о том, как добавить задержку с задержкой, я не уверен, как я должен попытаться реализовать это.
Win32: Sleep(milliseconds) - это то, что вы
unix: usleep(microseconds) - это то, что вы хотите.
sleep() занимает только несколько секунд, которые часто слишком длинные.
Обновленный ответ для С++ 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; часы, секунды, фемтосекунды и т.д.
В С++ 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);
Вы также можете использовать 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
}
Удостоверьтесь, что вы включили подчеркивание перед сном.
Вы можете попробовать этот фрагмент кода:
#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));
}
для задержки вывода в cpp в течение фиксированного времени, вы можете использовать функцию Sleep(), включив заголовочный файл windows.h синтаксис функции Sleep() - Sleep (time_in_ms) а
cout<<"Apple\n";
Sleep(3000);
cout<<"Mango";
OUTPUT. над кодом будет печатать Apple и ждать 3 секунды перед печатью манго.
Синтаксис:
void sleep (беззнаковые секунды);
sleep() приостанавливает выполнение для интервала (в секундах). При вызове спать текущая программа приостанавливается от выполнения в течение секунд, заданных секундой аргумента. Интервал является точным только до ближайшей сотой секунды или точности часов операционной системы, в зависимости от того, что менее точно.
Многие другие предоставили хорошую информацию для сна. Я согласен с Клин в том, что сна редко является наиболее подходящим решением.
Если вы спите, когда вы чего-то ждали, тогда вам лучше всего ждать эту вещь/событие. Посмотрите на переменные состояния для этого.
Я не знаю, на какой ОС вы пытаетесь это сделать, но для потоковой передачи и синхронизации вы можете посмотреть Boost Threading библиотеки (Boost Condition Varriable).
Перемещение теперь в другую крайность, если вы пытаетесь подождать исключительно короткие периоды, тогда есть несколько вариантов стиля взлома. Если вы работаете над какой-то встроенной платформой, где "sleep" не реализован, вы можете попробовать простой цикл (для/while и т.д.) С пустым телом (будьте осторожны, чтобы компилятор не оптимизировал его). Конечно, время ожидания зависит от конкретного оборудования в этом случае. Для действительно коротких "ожиданий" вы можете попробовать сборку "nop". Я очень сомневаюсь, что это то, что вам нужно, но не зная, почему вам нужно ждать, чтобы это было более конкретным.
В Windows вы можете включить библиотеку окон и использовать "Сон (0)"; для сна. Он принимает значение, представляющее миллисекунды.