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

Próbuję dodać opóźnienie czasowe w programie C ++ i zastanawiałem się, czy ktoś ma jakieś sugestie dotyczące tego, czego mogę spróbować, lub informacje, na które mogę spojrzeć?

Żałuję, że nie mam więcej szczegółów na temat tego, jak wdrażam to opóźnienie czasowe, ale dopóki nie będę mieć więcej informacji o tym, jak dodać opóźnienie czasowe, nie jestem pewien, jak powinienem próbować to wdrożyć.

Win32: Sleep(milliseconds)jest tym, czym jesteś

unix: usleep(microseconds)jest tym, czego chcesz.

Funkcja sleep () zajmuje tylko kilka sekund, co często jest zbyt długie.

Zaktualizowana odpowiedź dla C ++ 11:

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

Z tych funkcji nie ma już potrzeby, aby nieustannie dodawać nowe funkcje dla lepszej rozdzielczości: sleep,usleep , nanosleep, itd. sleep_forI sleep_untilsą funkcje szablonów, które mogą przyjmować wartości z dowolnej rozdzielczości poprzez chronorodzajów; godziny, sekundy, femtosekundy itp.

W C ++ 14 możesz dodatkowo uprościć kod za pomocą literałów sufiksó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);
}

Zwróć uwagę, że rzeczywisty czas snu zależy od implementacji: możesz poprosić o spanie na 10 nanosekund, ale implementacja może zamiast tego spać przez milisekundę, jeśli to najkrótszy możliwy czas.

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

To również będzie spać przez trzy sekundy. Możesz jednak nieco bardziej zawęzić liczby.

Chcesz czegoś tak prostego jak

sleep(3);

Należy pamiętać, że nie gwarantuje to, że czas, przez jaki wątek będzie spał, będzie zbliżony do okresu uśpienia, a jedynie gwarantuje, że czas, po którym wątek będzie kontynuował wykonywanie, będzie co najmniej żądany. Rzeczywiste opóźnienie będzie się różnić w zależności od okoliczności (zwłaszcza obciążenia danej maszyny) i może być o rząd wielkości wyższe niż pożądany czas uśpienia.

Ponadto nie wymieniasz powodów, dla których musisz spać, ale generalnie powinieneś unikać używania opóźnień jako metody synchronizacji.

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

Możesz także użyć select (2), jeśli chcesz dokładności mikrosekundowej (działa to na platformach, które nie mają usleep (3))

Poniższy kod będzie czekał 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 tu prawdopodobnie funkcją z wyboru. Zauważ, że czas przekazany do funkcji to najmniejszy czas, przez który wątek wywołujący będzie nieaktywny. Na przykład, jeśli zadzwonisz do snu z 5 sekundami, masz gwarancję, że Twój wątek będzie spał przez co najmniej 5 sekund. Może to być 6, 8 lub 50, w zależności od tego, co robi system operacyjny. (Podczas optymalnego wykonywania systemu operacyjnego będzie to bardzo blisko 5).
Inną użyteczną cechą funkcji uśpienia jest przekazywanie wartości 0. Wymusi to zmianę kontekstu z wątku.

Dodatkowe informacje:
http://www.opengroup.org/onlinepubs/000095399/functions/sleep.html

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

Na przykład:

#include <chrono>

using namespace std;

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

Pamiętaj, aby przed snem dołączyć podkreślenie.

aby opóźnić wyjście w cpp o ustalony czas, możesz użyć funkcji Sleep (), włączając składnię pliku nagłówkowego windows.h dla funkcji Sleep () to Sleep (time_in_ms) jako

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

WYNIK. powyższy kod wydrukuje Apple i odczeka 3 sekundy przed wydrukowaniem Mango.

Najważniejsza odpowiedź wydaje się być odpowiedzią zależną od systemu operacyjnego; aby uzyskać bardziej przenośne rozwiązanie, możesz napisać funkcję szybkiego uśpienia za pomocą pliku nagłówkowego ctime (chociaż może to być kiepska implementacja z mojej strony).

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

Składnia:

pusty sen (sekundy bez znaku);

sleep () zawiesza wykonywanie na pewien czas (w sekundach). W przypadku wywołania uśpienia bieżący program zostaje zawieszony przed wykonaniem na liczbę sekund określoną przez argument sekundy. Interwał jest dokładny tylko 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.

Wielu innych dostarczyło dobrych informacji na temat spania. Zgadzam się z Wedge, że sen rzadko jest najbardziej odpowiednim rozwiązaniem.

Jeśli śpisz, czekając na coś, lepiej poczekaj na tę rzecz / wydarzenie. Spójrz na zmienne warunkowe dla tego.

Nie wiem, na jakim systemie operacyjnym próbujesz to zrobić, ale w przypadku wątków i synchronizacji możesz zajrzeć do bibliotek Boost Threading ( Boost Condition Varriable ).

Przechodząc teraz do drugiej skrajności, jeśli próbujesz czekać na wyjątkowo krótkie okresy, istnieje kilka opcji stylu hakerskiego. Jeśli pracujesz na jakiejś wbudowanej platformie, na której 'uśpienie' nie jest zaimplementowane, możesz wypróbować prostą pętlę (for / while itp.) Z pustą treścią (uważaj, kompilator nie optymalizuje go). Oczywiście w tym przypadku czas oczekiwania zależy od konkretnego sprzętu. Na naprawdę krótkie „czekanie” możesz spróbować asemblacji „nop”. Bardzo wątpię, że tego szukasz, ale nie wiedząc, dlaczego musisz czekać, trudno jest być bardziej szczegółowym.

W systemie Windows można dołączyć bibliotekę systemu Windows i użyć polecenia „Uśpij (0)”; spać program. Przyjmuje wartość reprezentującą milisekundy.