के लिए सी ++

Question

window.setTimeout() के बराबर जावास्क्रिप्ट में इस मिठाई, मिठाई समारोह window.setTimeout(func, 1000) ; जो एसिंक्रोनस रूपfunc 1000 के बाद एमएस लागू करेगा नहीं है।

मैं ( multithreading बिना ) सी ++ में इसी तरह कुछ करना चाहता हूँ, तो मैं एक साथ की तरह एक नमूना पाश डाल:

 
    #include <stdio.h> 

    struct Callback 
    { 
     // The _time_ this function will be executed. 
     double execTime ; 

     // The function to execute after execTime has passed 
     void* func ; 
    } ; 

    // Sample function to execute 
    void go() 
    { 
     puts("GO") ; 
    } 

    // Global program-wide sense of time 
    double time ; 

    int main() 
    { 
     // start the timer 
     time = 0 ; 

     // Make a sample callback 
     Callback c1 ; 
     c1.execTime = 10000 ; 
     c1.func = go ; 

     while(1) 
     { 
     // its time to execute it 
     if(time > c1.execTime) 
     { 
      c1.func ; // !! doesn't work! 
     } 

     time++; 
     } 
    } 

मैं इस काम की तरह कुछ कैसे कर सकते हैं?

Answer 1

, प्रकार void (*)() की Callback::func बनाने अर्थात

struct Callback 
{ 
    double execTime; 
    void (*func)(); 
}; 

आप समारोह इस तरह से कॉल कर सकते हैं:,

c1.func(); 

भी व्यस्त प्रतीक्षा न करें। विंडोज पर ualarm या विंडोज पर CreateWaitableTimer का उपयोग करें।

Answer 2

स्वयं में सी ++ में, आप बहुत सीमित हैं। आपको या तो मल्टीथ्रेडेड ओएस की आवश्यकता है, जहां आप नींद फ़ंक्शन का उपयोग कर सकते हैं (आप अभी भी प्रोग्राम को एक अलग थ्रेड के साथ चलाना जारी रख सकते हैं), या आपको विंडोज जैसे मैसेजिंग सिस्टम की आवश्यकता है।

एकमात्र अन्य तरीका जो मैं देखता हूं कि आप कुछ कर सकते हैं, उस कोड में बिखरे हुए बहुत सारे कॉल हैं जो सही या गलत लौटने वाले फ़ंक्शन को कॉल करते हैं, इस पर निर्भर करता है कि समय बीत चुका है या नहीं। फ़ंक्शन निश्चित रूप से कॉलबैक हो सकता है, लेकिन आपको इसे समय-समय पर कॉल करने की आवश्यकता होगी।

Answer 3

मैं केवल बॉक्स को बाहर नहीं सोच रहा हूं, बस अपना कोड ठीक कर रहा हूं। अन्य उत्तरों ने इसके लिए पहले ही कुछ पॉइंटर्स दिए हैं। तब

// The function to execute after execTime has passed 
    void (*func)() ; 

, के रूप में यह फोन:

बेहतर प्रकार सुरक्षा के लिए, आप इस प्रकार अपने कॉलबैक सूचक की घोषणा करनी चाहिए

c1.func() ; 

Answer 4

एक और (बेहतर) जवाब <functional> शीर्ष लेख का उपयोग करने के लिए किया जाएगा सी ++ में, और इस तरह की फ़ंक्शन घोषित करें:

#include <functional> 

function<void()> func ; 

// assign like 
func = go ; //go is a function name that accepts 0 parameters 
// and has return type void 

// exec like 
func() ; 

Answer 5

सी ++ 11 बाहर आने के बाद, और यदि आपका C++ 11 समर्थित संकलक का उपयोग कर रहे हैं, तो आप लैम्ब्डा, variadic टेम्पलेट समारोह और अतुल्यकालिक धागा का उपयोग आसानी से ग में जावास्क्रिप्ट समारोह ++ अनुकरण करने के लिए कर सकते हैं।

यहाँ, कोड मैं setTimeOut के लिए लिखा है यह पूरी तरह से परीक्षण किया जाता है

setTimeOut funtion की परिभाषा:

#include <windows.h>//different header file in linux 
    #include <future> 
    using namespace std; 

    template <typename... ParamTypes> 
    void setTimeOut(int milliseconds,std::function<void(ParamTypes...)> func,ParamTypes... parames) 
    { 
     std::async(std::launch::async,[=]() 
     {  
      Sleep(milliseconds); 
      func(parames...); 
     }); 
    }; 

इस समारोह सी + 11 की variadic टेम्पलेट का उपयोग करके चर तर्क स्वीकार करता है, कोड कर सकते हैं आपको इसका उपयोग कैसे करें:

#include <iostream> 
    #include <thread> 
    #include <string> 
    #include <functional> 
    #include <windows.h> 

    #include <future> 
    using namespace std; 
    int main() 
    { 
     std::mutex locker; 
     std::function<void()> func1 = [&]() 
     { 
      std::unique_lock<std::mutex> lk(locker); 
      std::cout << "func 1 is trigged:" << " no parameter" << std::endl; 
      lk.unlock(); 
     };  
     std::function<void(int)> func2 = [&](int param) 
     { 
      std::unique_lock<std::mutex> lk(locker); 
      std::cout << "func 2 is trigged:" << " int: " << param <<std::endl; 
      lk.unlock(); 
     }; 
     std::function<void(int,std::string)> func3 = [&](int param1,std::string param2) 
     { 
      std::unique_lock<std::mutex> lk(locker); 
      std::cout << "func 3 is trigged:" << " int: " << param1 << "; string: " << param2 << std::endl; 
      lk.unlock(); 
     }; 

     for(int index=0;index<100;index++) 
     { 
      std::unique_lock<std::mutex> lk1(locker); 
      std::cout << "set timer for func 1" << std::endl; 
      lk1.unlock(); 
      setTimeOut<>(1000,func1); 

      std::unique_lock<std::mutex> lk2(locker); 
      std::cout << "set timer for func 2" << std::endl; 
      lk2.unlock(); 
      setTimeOut<int>(2000,func2,10000); 

      std::unique_lock<std::mutex> lk3(locker); 
      std::cout << "set timer for func 3" << std::endl; 
      lk3.unlock(); 
      setTimeOut<int,std::string>(5000,func3,10000,"ddddd"); 
     } 
     Sleep(10000000); 
    }