Jak dodać opóźnienie czasowe do programu C++?

Zaktualizowana odpowiedź do C++11:

Użyj funkcji sleep_for i 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));
}

Dzięki tym funkcjom nie ma już potrzeby ciągłego dodawania nowych funkcji dla lepszej rozdzielczości: sleep, usleep, nanosleep, itd. sleep_for i sleep_until są funkcjami szablonowymi, które mogą przyjmować wartości dowolnej rozdzielczości za pomocą typów chrono; godzin, sekund, femtosekund itp.

W C++14 można dodatkowo uprościć kod za pomocą literalnych przyrostków dla nanoseconds i 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);
}

Uwaga rzeczywisty czas snu zależy od implementacji: możesz poprosić o sen przez 10 nanosekund, ale implementacja może spać przez milisekundę, jeśli jest to najkrótsze, co może zrobić.

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

To również będzie spać przez trzy sekundy. Możesz jednak Dopracować liczby trochę bardziej.

Zauważ, że nie gwarantuje to, że czas uśpienia wątku będzie zbliżony do okresu uśpienia, tylko gwarantuje, że czas, zanim wątek kontynuuje wykonywanie, będzie co najmniej pożądaną ilością. Rzeczywiste opóźnienie będzie się różnić w zależności od okoliczności (w szczególności obciążenie danej maszyny) i może być o rząd wielkości wyższe niż pożądany czas snu.

Poza tym nie podajesz powodów, dla których musisz spać, ale generalnie powinieneś unikać wykorzystanie opóźnień jako metody synchronizacji.

Czy chcesz czegoś tak prostego jak

sleep(3);

Możesz również użyć select(2), jeśli chcesz uzyskać precyzję mikrosekund(działa to na platformach, które nie mają usleep (3))

Następujący kod będzie czekał na 1,5 sekundy:

#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);
}

`

Tak, sen jest prawdopodobnie funkcją wyboru tutaj. Należy zauważyć, że czas przekazany do funkcji jest najmniejszą ilością czasu, przez który wątek wywołujący będzie nieaktywny. Na przykład, jeśli wywołasz sleep z 5 sekundami, masz gwarancję, że Twój wątek będzie spał przez co najmniej 5 sekund. Może być 6, lub 8 lub 50, w zależności od tego, co robi SYSTEM OPERACYJNY. (Podczas optymalnej realizacji OS, będzie to bardzo blisko 5.)
kolejną użyteczną cechą funkcji sleep jest Przejście W 0. To wymusi przełączanie kontekstu z wątku.

Kilka dodatkowych informacji:
http://www.opengroup.org/onlinepubs/000095399/functions/sleep.html

Odkryłem, że "_sleep(milliseconds);" (bez cudzysłowów) działa dobrze dla Win32, jeśli dołączysz bibliotekę chrono

Np:

#include <chrono>

using namespace std;

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

Możesz wypróbować ten fragment kodu:

#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));
}

Aby opóźnić wyjście w cpp przez określony czas, możesz użyć funkcji Sleep() włączając windows.plik nagłówka h składnia funkcji Sleep () to Sleep (time_in_ms) as

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

Wyjście. powyższy kod wydrukuje Apple i odczekuje 3 sekundy przed wydrukowaniem Mango.

Składnia:

Void sleep (unsigned seconds);

Sleep () zawiesza wykonanie na interwał (sekundy). Po wywołaniu sleep, bieżący program jest zawieszony w wykonaniu na liczbę sekund określoną przez argument seconds. Interwał jest dokładny tylko z dokładnością do najbliższej setnej sekundy lub do dokładności zegara systemu operacyjnego, w zależności od tego, która z tych wartości jest mniej dokładna.

Wiele innych dostarczyło dobrych informacji do spania. Zgadzam się z Wedge, że sen rzadko jest najodpowiedniejszym rozwiązaniem.

Jeśli śpisz, czekając na coś, to lepiej jest czekać na to coś/wydarzenie. Spójrz na zmienne warunkowe dla tego.

Nie wiem, na jakim systemie operacyjnym próbujesz to zrobić, ale dla threadingu i synchronizacji możesz spojrzeć na Boost Threading libraries (Boost Condition Varriable ).

Przejście teraz do drugiej skrajności jeśli próbujesz czekać na wyjątkowo krótkie okresy, to istnieje kilka opcji stylu hack. Jeśli pracujesz na jakiejś wbudowanej platformie, gdzie 'sleep' nie jest zaimplementowany, możesz wypróbować prostą pętlę (for / while itp.) z pustym ciałem(uważaj, aby kompilator jej nie zoptymalizował). Oczywiście czas oczekiwania zależy w tym przypadku od konkretnego sprzętu. Na naprawdę krótkie "oczekiwanie" można spróbować montażu "nop". Szczerze wątpię, że to jest to, czego szukasz, ale nie wiedząc, dlaczego musisz czekać, trudno być bardziej szczegółowym.

W systemie Windows możesz dołączyć bibliotekę windows i użyć " Sleep (0);", aby uśpić program. Przyjmuje wartość, która reprezentuje milisekundy.