Po co obciążać ciągłym odpytywaniem o czas gdy dokładność do 1s wydaje się wystarczająca? W rozwiązaniu z ciągłym uzupełnianiem bufora, obciążony jest stale najprawdopodobniej jakiś rdzeń procesora.
Dostęp do bufora powinien być także synchronizowany. Wystarczy mutex.
Dodatkowo warto takie narzędzia projektować w trybie RAII.
Taka prosta przymiarka. Jeszcze wiele można poprawiać ale przedstawia tok myślenia:
#include <iostream>
#include <cstring>
#include <thread>
#include <mutex>
#include <atomic>
struct TimeTool {
constexpr static size_t BUFFER_SIZE{10};
TimeTool(): stop{false}, buffer{}, thr{&TimeTool::updateTime, this} {
}
void fillBuffer(char * buff) const {
std::lock_guard<std::mutex> l(mtx);
strncpy(buff, buffer, BUFFER_SIZE);
}
~TimeTool() {
stop.store(true);
thr.join();
}
private:
void updateTime() {
auto t = std::chrono::system_clock::now();
auto tp = t + std::chrono::seconds(1);
while(!stop) {
auto currTime = std::chrono::system_clock::to_time_t(tp);
{
std::lock_guard<std::mutex> l(mtx);
strftime(buffer, BUFFER_SIZE, "%H:%M:%S", std::localtime(&currTime));
}
std::this_thread::sleep_until(tp);
tp += std::chrono::seconds(1);
}
}
char buffer[BUFFER_SIZE];
mutable std::mutex mtx;
std::atomic_bool stop;
std::thread thr;
};
int main() {
// Jakiś naiwny test...
TimeTool timeTool;
char buffer[TimeTool::BUFFER_SIZE];
for(auto i = 0U; i < 10; ++i) {
timeTool.fillBuffer(buffer);
std::cout << buffer << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(500));
}
}