Hoe voeg je een getimede vertraging toe aan een C++-programma?

Ik probeer een getimede vertraging toe te voegen aan een C++-programma en vroeg me af of iemand suggesties heeft over wat ik kan proberen of informatie waar ik naar kan kijken?

Ik wou dat ik meer details had over hoe ik deze getimede vertraging implementeer, maar totdat ik meer informatie heb over hoe ik een getimede vertraging kan toevoegen, weet ik niet zeker hoe ik moet proberen om dit te implementeren.

Antwoord 1, autoriteit 100%

In Win32:

#include<windows.h>
Sleep(milliseconds);

In Unix:

#include<unistd.h>
unsigned int microsecond = 1000000;
usleep(3 * microsecond);//sleeps for 3 second

sleep()duurt maar een aantal seconden, wat vaak te lang is.

Antwoord 2, autoriteit 94%

Een bijgewerkt antwoord voor C++11:

Gebruik de functies sleep_foren 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));
}

Met deze functies is er niet langer nodig om nieuwe functies voortdurend toe te voegen voor een betere resolutie: sleep, usleep, nanosleep, enz. sleep_forEN sleep_untilzijn sjabloonfuncties die waarden van elke resolutie kunnen accepteren via chronoTypen; uren, seconden, femtoseconden, enz.

In C++ 14 kunt u de code verder vereenvoudigen met de letterlijke achtervoegsels voor nanosecondsen 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);
}

Merk op dat de werkelijke duur van een slaap afhangt van de implementatie: u kunt vragen om 10 nanoseconden te slapen, maar een implementatie kan in plaats daarvan een implementatie slapen voor een milliseconde, als dat het kortst is.

Antwoord 3, Autoriteit 37%

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

Hiermee slaapt u ook drie seconden. U kunt de nummers een beetje meer verfijnen.

Antwoord 4, Autoriteit 21%

Wilt u iets zo eenvoudig:

#include <unistd.h>
sleep(3);//sleeps for 3 second

Antwoord 5, Autoriteit 8%

Merk op dat dit niet garandeert dat de hoeveelheid tijd dat de thread slaapt ergens in de buurt van de slaapperiode zal zijn, het garandeert alleen dat de hoeveelheid tijd voordat de thread doorgaat met uitvoeren, ten minste de gewenste hoeveelheid zal zijn. De werkelijke vertraging is afhankelijk van de omstandigheden (met name de belasting van de machine in kwestie) en kan orden van grootte hoger zijn dan de gewenste slaaptijd.

Je vermeldt ook niet waarom je moet slapen, maar je moet over het algemeen vermijden om vertragingen te gebruiken als synchronisatiemethode.

Antwoord 6, autoriteit 5%

U kunt dit codefragment proberen:

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

Antwoord 7, autoriteit 4%

Ik ontdekte dat "_sleep(milliseconds);"(zonder de aanhalingstekens) goed werkt voor Win32 als je de chronobibliotheek

opneemt

Bijvoorbeeld:

#include <chrono>
using namespace std;
main
{
    cout << "text" << endl;
    _sleep(10000); // pauses for 10 seconds
}

Zorg ervoor dat u het onderstrepingsteken opneemt voordat u gaat slapen.

Antwoord 8, autoriteit 3%

Je kunt ook select(2) gebruiken als je een precisie van microseconden wilt (dit werkt op een platform dat geen usleep(3) heeft)

De volgende code wacht 1,5 seconde:

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

`

Antwoord 9, autoriteit 3%

Ja, slapen is hier waarschijnlijk de favoriete functie. Merk op dat de tijd die in de functie is verstreken de kleinste hoeveelheid tijd is dat de aanroepende thread inactief is. Dus als u bijvoorbeeld slaap oproept met 5 seconden, weet u zeker dat uw draad minstens 5 seconden slaapt. Kan 6, of 8 of 50 zijn, afhankelijk van wat het besturingssysteem doet. (Tijdens optimale uitvoering van het besturingssysteem zal dit zeer dicht bij 5 liggen.)
Een andere handige functie van de slaapfunctie is om 0 door te geven. Dit dwingt een contextwisseling van uw thread af.

Enkele aanvullende informatie:
http://www.opengroup.org/onlinepubs/000095399/functions/sleep. html

Antwoord 10, autoriteit 3%

om de uitvoer in cpp voor een vaste tijd uit te stellen, kunt u de functie Sleep() gebruiken door het windows.h-headerbestand op te nemen
syntaxis voor de functie Sleep() is Sleep(time_in_ms)
als

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

UITGANG. bovenstaande code zal Apple afdrukken en 3 seconden wachten voordat Mango wordt afgedrukt.

Antwoord 11, autoriteit 3%

Het beste antwoord hier lijkt een OS-afhankelijk antwoord te zijn; voor een meer draagbare oplossing kun je een snelle slaapfunctie schrijven met behulp van het ctime-headerbestand (hoewel dit een slechte implementatie van mijn kant kan zijn).

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

Antwoord 12

SYNTAX:

Void-slaap (niet-ondertekende seconden);

Slaap () schort de uitvoering voor een interval (seconden) op.
Met een oproep om te slapen, wordt het huidige programma gesuspendeerd van uitvoering voor het aantal seconden gespecificeerd door het argument. Het interval is alleen nauwkeurig op de dichtstbijzijnde honderdste van een seconde of aan de nauwkeurigheid van de klok van het besturingssysteem, afhankelijk van welke minder nauwkeurig is.

Antwoord 13

Veel anderen hebben goede informatie verstrekt om te slapen. Ik ben het eens met wig die een slaap zelden de meest geschikte oplossing.

Als je slaapt terwijl je op iets wacht, dan ben je beter af, daadwerkelijk wachten op dat ding / evenement. Kijk hiervoor om voorwaarde variabelen.

Ik weet niet welk besturingssysteem u dit probeert te doen, maar voor draad en synchronisatie kunt u naar de Boost threading bibliotheken (boost conditie varriatial ).

Nu naar het andere extreme bewegen Als u probeert te wachten op uitzonderlijk korte perioden, dan zijn er een paar hack-stijlopties. Als u werkt aan een soort van ingesloten platform waarbij een ‘slaap’ niet wordt geïmplementeerd, kunt u een eenvoudige lus (voor / while etc) met een leeg lichaam proberen (voorzichtig zijn dat de compiler het niet optimaliseert). Natuurlijk is de wachttijd afhankelijk van de specifieke hardware in dit geval.
Voor heel kort ‘wacht’ kun je een montage “NOP” proberen. Ik betwijfel ten zeerste of dit is wat je bent na, maar zonder te weten waarom je moet wachten, is het moeilijk om specifieker te zijn.

Antwoord 14

Op Windows kunt u de Windows-bibliotheek opnemen en “Slaap (0) gebruiken;” om het programma te slapen. Het duurt een waarde die milliseconden vertegenwoordigt.