Slaap voor milliseconden

Ik ken de POSIX sleep(x)FUNCTION MAAKT het programma voor x seconden. Is er een functie om het programma te laten slapen voor X Milliseconden in C++?


Antwoord 1, Autoriteit 100%

Merk op dat er geen standaard C API is voor milliseconden, dus (op UNIX) moet u genoegen nemen met usleep, die Microseconds accepteert:

#include <unistd.h>
unsigned int microseconds;
...
usleep(microseconds);

Antwoord 2, Autoriteit 289%

In C++ 11, kunt u dit doen met standaard bibliotheekfaciliteiten:

#include <chrono>
#include <thread>
std::this_thread::sleep_for(std::chrono::milliseconds(x));

Duidelijk en leesbaar, niet meer nodig om te raden in welke eenheden de sleep()-functie neemt.


Antwoord 3, Autoriteit 17%

Om draagbaar te blijven, kunt u boost :: thread om te slapen:

#include <boost/thread/thread.hpp>
int main()
{
    //waits 2 seconds
    boost::this_thread::sleep( boost::posix_time::seconds(1) );
    boost::this_thread::sleep( boost::posix_time::milliseconds(1000) );
    return 0;
}

Dit antwoord is een duplicaat en is gepost in deze vraag eerder. Misschien kun je daar ook wat bruikbare antwoorden vinden.


Antwoord 4, Autoriteit 8%

In Unix kun je usleepgebruiken.

In Windows is er Slaap.


Antwoord 5, autoriteit 7%

Afhankelijk van uw platform heeft u mogelijk usleepof nanosleepbeschikbaar. usleepis verouderd en is verwijderd uit de meest recente POSIX-standaard; nanosleepheeft de voorkeur.


Antwoord 6, autoriteit 5%

Waarom gebruik je de time.h-bibliotheek niet? Draait op Windows- en POSIX-systemen (gebruik deze code niet in productie!):

#include <iostream>
#include <time.h>
using namespace std;
void sleepcp(int milliseconds);
void sleepcp(int milliseconds) // Cross-platform sleep function
{
    clock_t time_end;
    time_end = clock() + milliseconds * CLOCKS_PER_SEC/1000;
    while (clock() < time_end)
    {
    }
}
int main()
{
    cout << "Hi! At the count to 3, I'll die! :)" << endl;
    sleepcp(3000);
    cout << "urrrrggghhhh!" << endl;
}

Gecorrigeerde code – nu blijft de CPU in de IDLE-status [2014.05.24]:

#include <iostream>
#ifdef _WIN32
    #include <windows.h>
#else
    #include <unistd.h>
#endif // _WIN32
using namespace std;
void sleepcp(int milliseconds);
void sleepcp(int milliseconds) // Cross-platform sleep function
{
    #ifdef _WIN32
        Sleep(milliseconds);
    #else
        usleep(milliseconds * 1000);
    #endif // _WIN32
}
int main()
{
    cout << "Hi! At the count to 3, I'll die! :)" << endl;
    sleepcp(3000);
    cout << "urrrrggghhhh!" << endl;
}

Antwoord 7, autoriteit 4%

nanosleepis een betere keuze dan usleep– het is beter bestand tegen onderbrekingen.


Antwoord 8, autoriteit 3%

#include <windows.h>

Syntaxis:

Sleep (  __in DWORD dwMilliseconds   );

Gebruik:

Sleep (1000); //Sleeps for 1000 ms or 1 sec

Antwoord 9, autoriteit 3%

#include <chrono>
#include <thread>
std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // sleep for 1 second

Vergeet niet om de twee koppen te importeren.


Antwoord 10, autoriteit 2%

Vanuit C++14 met std en ook de numerieke letterlijke waarden:

#include <chrono>
#include <thread>
using namespace std::chrono;
std::this_thread::sleep_for(123ms);

Antwoord 11

Als u MS Visual C++ 10.0 gebruikt, kunt u dit doen met standaard bibliotheekfaciliteiten:

Concurrency::wait(milliseconds);

je hebt nodig:

#include <concrt.h>

Antwoord 12

Op platforms met de functie select(POSIX, Linux en Windows) kunt u het volgende doen:

void sleep(unsigned long msec) {
    timeval delay = {msec / 1000, msec % 1000 * 1000};
    int rc = ::select(0, NULL, NULL, NULL, &delay);
    if(-1 == rc) {
        // Handle signals by continuing to sleep or return immediately.
    }
}

Er zijn tegenwoordig betere alternatieven beschikbaar.


Antwoord 13

De manier om uw programma in C++ te slapen, is de Sleep(int)-methode. Het koptekstbestand voor het is #include "windows.h."

Bijvoorbeeld:

#include "stdafx.h"
#include "windows.h"
#include "iostream"
using namespace std;
int main()
{
    int x = 6000;
    Sleep(x);
    cout << "6 seconds have passed" << endl;
    return 0;
}

De tijd die het slaapt wordt gemeten in milliseconden en heeft geen limiet.

Second = 1000 milliseconds
Minute = 60000 milliseconds
Hour = 3600000 milliseconds

Antwoord 14

Selecteer Call is een manier om meer precisie te hebben (slaaptijd kan worden gespecificeerd in Nanoseconden).


Antwoord 15

Gebruik Boost Asynchrone Input / Output Threads, Slaap voor X Milliseconden;

#include <boost/thread.hpp>
#include <boost/asio.hpp>
boost::thread::sleep(boost::get_system_time() + boost::posix_time::millisec(1000));

Antwoord 16

Als een Win32-vervanging voor POSIX-systemen:

void Sleep(unsigned int milliseconds) {
    usleep(milliseconds * 1000);
}
while (1) {
    printf(".");
    Sleep((unsigned int)(1000.0f/20.0f)); // 20 fps
}

Antwoord 17

De vraag is oud, maar ik heb erin geslaagd een eenvoudige manier te vinden om dit in mijn app te hebben. U kunt een C / C++-macro maken, zoals hieronder wordt weergegeven, gebruikt u het:

#ifndef MACROS_H
#define MACROS_H
#include <unistd.h>
#define msleep(X) usleep(X * 1000)
#endif // MACROS_H

Antwoord 18

gebruik voor C /// in gcc.

#include <windows.h>

gebruik dan Slaap(); /// Sleep() met hoofdletter S. niet sleep() met s .

//Sleep(1000) is 1 sec /// misschien.

clang ondersteunt sleep(), sleep(1) is voor 1 sec vertraging/wacht.

Other episodes