How to declare a std::chrono::duration<double> variable in c++ - c++

Question

I am working on a code where I am calculating the duration of time and then saving it in list.
auto start_time = std::chrono::high_resolution_clock::now();
/*
*some code here
*/
auto finish_time = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> time_duration = finish_time - start_time ;
Now here I need to save time_duration in a list at a given index. If that given index, already contains a value, I need to add time_duration with the current value of that index and save it. For this I have below list and code:
list <std::chrono::duration<double>> dTimeList;
auto iter = dTimeList.begin();
advance(iter, 0);
*iter+= time_duration; //Error at this line
But running above code I get below error:
Most probably this error is coming because I have empty list with no items in it. This is why I thought of adding a item at 0th index like below:
auto itr = dTimeList.begin();
advance(itr, 0);
std::chrono::duration<double> t = 0.0;
dTimeList.insert(itr, t);
but again above is also giving below error. How can I resolve this issue. Thanks
No suitable constructor available to convert double to std::chrono::duration<double>

Answer 1

Probably you should not use list to store data at index. Try to use std::unordered_map instead.
#include <unordered_map>
auto start_time = std::chrono::high_resolution_clock::now();
/*
*some code here
*/
auto finish_time = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> time_duration = finish_time - start_time ;
typedef int YourObjectIdType;
std::unordered_map<YourObjectIdType, std::chrono::duration<double>> dTimes;
and now insert or update item like this:
dTimes[objectId] += time_duration;
or like this:
auto it = dTimes.find(objectId);
if (it != dTimes.end()) {
*it += time_duration;
} else {
dTimes.insert(std::make_pair(objectId, time_duration));
}
also, you can use std::map the same way, it slightly slower, but [begin(), end()) range is sorted.

Answer 2

You're trying to write to the end iterator. When the list is empty, dTimeList.begin() == dTimeList.end(), so you can't write to it.
You need to check if the index exists first, and extend the list otherwise:
void add_time_to_list(
std::list<std::chrono::duration<double>>& l,
const std::chrono::duration<double>& t,
std::size_t index = 0
) {
if (index < l.size()) {
*std::next(l.begin(), index) += t;
} else if (index == l.size()) {
// New element; add to back
l.push_back(t);
} else {
// Here you can throw an error that index is too big
// or append 0 until it gets to the desired size or something
}
}
Note that accessing arbitrary indexes like this could mean that you don't want a std::list. This would be easier with a std::vector (*std::next(l.begin(), index) becomes l[index]). I would also suggest a std::map, where the function can just be written as:
void add_time_to_list(
std::map<std::size_t, std::chrono::duration<double>>& m,
const std::chrono::duration<double>& t,
std::size_t index = 0
) {
m[index] += t; // if m[index] doesn't exist, it is default constructed.
}

Answer 3

No suitable constructor available to convert double to std::chrono::duration
I dare to suggest dealing with std::list is far from a core issue here.
Dealing with std::chrono, one should know the foundation concepts of it. For what is not explained here please look it up on cppreference.com
Step one. You decide which Clock you need/want to use.
using Clock = typename std::chrono::high_resolution_clock ;
Step two. You use the duration nested type, declared in it. In your use-case you would like to have a sequence of durations.
using time_durations_sequence_type = std::vector<Clock::duration> ;
type naming is very important. I deliberately use the generic term 'sequence'. You might push the idea of std::list to implement it, but I fail to see why. Thus I am using std::vector above.
Also notice, I do not use double or long int as the "duration" type. Firstly std::duration is a "time taken for event to happen". Second, it is not a scalar it is a class type. Traditionaly, from C years, time concept was based just on ticks.
So, to cut the long story short we use the std::duration concept , concretized as a nested type in the "clock" we have selected to use here.
// not a point in time
Clock::duration
//
// there is no guarantee above
// is the same type as
// std::chrono::duration<double>
// and we do not need one
And above is all we need to proceed to implement the functionality you require.
// two points in time
auto start_time = Clock::now();
auto finish_time = Clock::now();
// the duration
Clock::duration time_duration = finish_time - start_time ;
Now we store the duration in our sequence type.
time_durations_sequence_type tdst{ time_duration } ;
And elsewhere we use the sequence of stored durations we have accumulated.
// time_durations_sequence_type tdst
for (auto duration : tdst ) {
std::cout << std::endl
<< duration.count() << " nano seconds"
<< std::endl;
}
Notice how above we used the count() method to get to the actual ticks, which by std::chrono default, do represent nanoseconds.
Working code is here .