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 usleep
of nanosleep
beschikbaar. usleep
is verouderd en is verwijderd uit de meest recente POSIX-standaard; nanosleep
heeft 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%
nanosleep
is 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.