सी ++

Question

के लिए क्रॉस प्लेटफार्म स्लीप फ़ंक्शन मैक्रोज़ क्रॉस प्लेटफ़ॉर्म स्लीप कोड बनाने के साथ संभव है? उदाहरण

#ifdef LINUX 
#include <header_for_linux_sleep_function.h> 
#endif 
#ifdef WINDOWS 
#include <header_for_windows_sleep_function.h> 
#endif 
... 
Sleep(miliseconds); 
... 

Answer 1

हां वहाँ है।

#ifdef LINUX 
#include <unistd.h> 
#endif 
#ifdef WINDOWS 
#include <windows.h> 
#endif 

void mySleep(int sleepMs) 
{ 
#ifdef LINUX 
    usleep(sleepMs * 1000); // usleep takes sleep time in us (1 millionth of a second) 
#endif 
#ifdef WINDOWS 
    Sleep(sleepMs); 
#endif 
} 

फिर अपने कोड कॉल mySleep प्रत्यक्ष प्रणाली में कॉल करने के बजाय सोने के लिए: तुम क्या लपेट अलग प्रणाली अपने स्वयं के समारोह में कॉल करने के साथ ही नीचे की तरह शामिल बयान सोती है।

Answer 2

लिए Boost प्राप्त करें।

#include <boost/thread/thread.hpp> 
#include <boost/date_time/posix_time/posix_time.hpp> 
... 
boost::this_thread::sleep(boost::posix_time::millisec(milliseconds)); 

Answer 3

स्टॉक समाधान चुनिंदा() कॉल (विंसॉक की आवश्यकता है) है। यह विशेष कॉल लिनक्स और विंडोज पर बिल्कुल वही व्यवहार है।

long value; /* time in microseconds */ 

struct timeval tv; 
tv.tv_sec = value/1000000; 
tv.tv_usec = value % 1000000; 
select(0, NULL, NULL, NULL, &tf); 

Answer 4

लिनक्स में याद रखें कि नींद की सीमा है। आप 1000 सेकंड से अधिक 'सो' नहीं कर सकते हैं।

मैं इस

struct timespec req={0},rem={0}; 
req.tv_sec=(milisec/1000); 
req.tv_nsec=(milisec - req.tv_sec*1000)*1000000; 
nanosleep(&req,&rem); 

Answer 5

तरह लिखते थे हाँ। लेकिन यह केवल C++11 और later में काम करता है।

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

जहां ms समय की राशि है जो आप मिलीसेकेंड में सोना चाहता हूँ है।

तुम भी nanoseconds, microseconds, seconds, minutes, या hours साथ milliseconds बदल सकते हैं। (इन प्रकार std::chrono::duration की विशेषज्ञताओं हैं।)

अद्यतन:C++14 में, यदि आप समय का एक सेट राशि के लिए सो रहे हैं, उदाहरण के 100 मिलीसेकंड के लिए, std::chrono::milliseconds(100)100ms के रूप में लिखा जा सकता है। यह user defined literals के कारण है, जो C++11 में पेश किए गए थे।

• std::literals::chrono_literals::operator""h
• std::literals::chrono_literals::operator""min
• std::literals::chrono_literals::operator""s
• std::literals::chrono_literals::operator""ms
• std::literals::chrono_literals::operator""us
• std::literals::chrono_literals::operator""ns

01: C++14 में chrono पुस्तकालय निम्नलिखित उपयोगकर्ता परिभाषित शाब्दिक शामिल करने के लिए बढ़ा दिया गया है

प्रभावी रूप से इसका मतलब है कि आप इस तरह कुछ लिख सकते हैं।

#include <chrono> 
#include <thread> 
using namespace std::literals::chrono_literals; 

std::this_thread::sleep_for(100ms); 

ध्यान दें कि, जबकि using namespace std::literals::chrono_literalsnamespace pollution के कम से कम राशि प्रदान करता है, इन ऑपरेटर भी उपलब्ध जब using namespace std::literals, या using namespace std::chrono हैं।

Answer 6

shf301 एक अच्छा विचार था, लेकिन इस तरह से है बेहतर:

#ifdef _WINDOWS 
#include <windows.h> 
#else 
#include <unistd.h> 
#define Sleep(x) usleep((x)*1000) 
#endif 

फिर इस तरह का उपयोग करें:

Sleep(how_many_milliseconds); 

Answer 7

बस कर

#include <ctime> 
int Sleep(int ms) 
{ 
    clock_t starting = clock(); 
    while(clock() - starting < ms) {} 
    return 0; 
} 

वर्तमान समय की जाँच करता है कि (मिलीसेकंड में), इससे प्रारंभिक समय घटाता है, जो फ़ंक्शन द्वारा उपयोग किए जाने वाले समय की मात्रा उत्पन्न करता है। यदि वह संख्या कम है तो महत्वपूर्ण मूल्य (लक्ष्य समय की लंबाई), तो यह कुछ भी नहीं करता है, थोड़ी सी समय की हत्या करता है। यह तब तक दोहराता है जब तक कि महत्वपूर्ण मूल्य से अधिक न हो, तब यह बंद हो जाता है।

संपादित करें: निर्धारित कोड गलतियों