CODEWITHSUNDEEP
c++c++11visual-c++
sumit kang
sumit kang

Reputation: 476

How to delay a function without stopping the application

void sendCommand(float t,char* cmd)
{

  std::clock_t endwait; 
  double endwait = clock () + t * CLOCKS_PER_SEC ; 
  while (clock() < endwait) {} 
  if( clock() < endwait)
  printf("\nThe waited command is =%s",cmd);

}

void Main()
{
 sendCommand(3.0,"Command1");
 sendCommand(2.0,"Command2");
 printf("\nThe first value")
 return 0;
}

i want to delay a function but my application should keep on running.

In the above code i want The first value to be printed first. than i want Command2 to be printed and Command1 should be the last to be printed.

Upvotes: 5

Views: 6574

Answers (4)

Galik
Galik

Reputation: 48605

I think you need threads. You can do it like this:

#include <thread>
#include <chrono>
#include <iostream>

void sendCommand(float t, char const* cmd)
{
    std::this_thread::sleep_for(std::chrono::milliseconds(int(t * 1000)));
    std::cout << "\nThe waited command is = " << cmd << '\n';
}

int main()
{
    // each function call on a new thread
    std::thread t1(sendCommand, 3.0, "Command1");
    std::thread t2(sendCommand, 2.0, "Command2");

    // join the threads so we don't exit before they finish.
    t1.join();
    t2.join();
}

Upvotes: 3

Jens
Jens

Reputation: 9406

I prefer std::async for this.

#include <chrono>
#include <thread>
#include <future>
#include <iostream>

void sendCommand(std::chrono::seconds delay, std::string cmd)
{
     std::this_thread::sleep_for( delay );
     std::cout << "\nThe waited command is =" << cmd;
}

int main()
{
 auto s1 = std::async(std::launch::async, sendCommand, std::chrono::seconds(3),"Command1");
 auto s2 = std::async(std::launch::async, sendCommand, std::chrono::seconds(2),"Command2");

 std::cout << "\nThe first value" << std::flush;    
 s1.wait();
 s2.wait();


 return 0;
}

However, for a real design, I would create a scheduler (or preferably use an existing one) which manages a priority queue sorted by the delay time. Spawning a new thread for every command will quickly become a problem. Since you flagged the question for MS VIsual C++, take a look the PPL which implements task-based parallelism.

And as it a C++ question, I would stay away from the C stuff and not use printf, CLOCK_PER_SEC, char*, clock etc. You will quickly get into problems even with this simple example when you start using strings instead of the "Command1" literals. std::string will help you here.

Upvotes: 9

Chad
Chad

Reputation: 19022

boost::asio is nice because it doesn't require the overhead of multiple threads.

#include <iostream>
#include <boost/asio.hpp>

using namespace std;

int main()
{
    boost::asio::io_service svc;

    boost::asio::deadline_timer t0{svc};
    boost::asio::deadline_timer t1{svc};
    boost::asio::deadline_timer t2{svc};

    t0.expires_from_now(boost::posix_time::seconds{1});
    t1.expires_from_now(boost::posix_time::seconds{2});
    t2.expires_from_now(boost::posix_time::seconds{3});

    t2.async_wait([] (const boost::system::error_code& ec) { if(!ec) std::cout << "Greetings from t2!\n";});
    t1.async_wait([] (const boost::system::error_code& ec) { if(!ec) std::cout << "Greetings from t1!\n";});
    t0.async_wait([] (const boost::system::error_code& ec) { if(!ec) std::cout << "Greetings from t0!\n";});

    svc.post([] () { std::cout << "I'm number one!\n";});

    svc.run();

    return 0;
}

Gives the output:

I'm number one!
Greetings from t0!
Greetings from t1!
Greetings from t2!

Upvotes: 0

RBanerjee
RBanerjee

Reputation: 947

You can do it in many ways depending upon your actual logic. Examles;:

1.you can you a global flag variable and check its state , when third print will complete you can set flag to 1,so next call will execute.

2.you can use a STACK .push all the function pointers in a STACK . and after that pop and execute.

3.MultiThreading. You can use it with proper synchronized way, but it will be complex. It depends upon your requirement.

Thanks !!!

Upvotes: 0

Related Questions