C++ Keeping track of how many seconds has passed since start of program

Question

I am writing a program that will be used on a Solaris machine. I need a way of keeping track of how many seconds has passed since the start of the program. I\'m talking very sim

Answer 1

You just need to store the date/time when application started. Whenever you need to display for how long your program is running get current date/time and subtract the when application started.

Answer 2

A very simple method:

#include <time.h>
time_t start = time(0);

double seconds_since_start = difftime( time(0), start);

The main drawback to this is that you have to poll for the updates. You'll need platform support or some other lib/framework to do this on an event basis.

Answer 3

Use std::chrono.

#include <chrono>
#include <iostream>

int main(int argc, char *argv[])
{
   auto start_time = std::chrono::high_resolution_clock::now();
   auto current_time = std::chrono::high_resolution_clock::now();

   std::cout << "Program has been running for " << std::chrono::duration_cast<std::chrono::seconds>(current_time - start_time).count() << " seconds" << std::endl;

   return 0;
}

If you only need a resolution of seconds, then std::steady_clock should be sufficient.

Answer 4

#include <stdio.h>
#include <time.h>
#include <windows.h>
using namespace std;
void wait ( int seconds );
int main ()
{
  time_t start, end;
  double diff;
  time (&start); //useful call
  for (int i=0;i<10;i++) //this loop is useless, just to pass some time.
  {
  printf ("%s\n", ctime(&start));
  wait(1);
  }
  time (&end);//useful call

  diff = difftime(end,start);//this will give you time spent between those two calls.
  printf("difference in seconds=%f",diff); //convert secs as u like
  system("pause");
  return 0;
}
void wait ( int seconds )
{
  clock_t endwait;
  endwait = clock () + seconds * CLOCKS_PER_SEC ;
  while (clock() < endwait) {}
}

this should work fine on solaris/unix also, just remove win refs

Answer 5

You are approaching it backwards. Instead of having a variable you have to worry about updating every second, just initialize a variable on program start with the current time, and then whenever you need to know how many seconds have elapsed, you subtract the now current time from that initial time. Much less overhead that way, and no need to nurse some timing related variable update.