blocks|key|96252|text|全局变量保证在main运行之前被初始化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|96253|因此，首先创建一个用值初始化的全局const变量app_start_time|offset|length|style|CODE|96254|+const+auto+app_start_time+=+std::chrono::system_clock::now();|code-block|syntax|javascript|96255|然后在log函数中使用以下代码来计算秒：|96256|auto+time_since_start+=+std::chrono::system_clock::now()+-+app_start_time;
auto+seconds_since_start=+std::chrono::seconds(time_since_start).count();|96257|entityMap^0|0|H|5|O|E|0|0|3|3|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]|$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|Z|8|@$D|10|E|11|F|G]]|9|@]|A|$]]|$1|O|3|P|5|J|7|12|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|R|$]]

Global variables are guaranteed to be initialized before main is run.

So first create a global <code>const</code> variable <code>app_start_time</code> initialized with the value

<pre><code> const auto app_start_time = std::chrono::system_clock::now();
</code></pre>

Then in the <code>log</code> function use following code to calculate seconds :

<pre><code>auto time_since_start = std::chrono::system_clock::now() - app_start_time;
auto seconds_since_start= std::chrono::seconds(time_since_start).count();
</code></pre>

blocks|key|2839404|text|您可以将std::chrono库用于时间用途。您基本上获取了代码开头的时间，并将其保存在一个变量中。之后，当你需要时间间隔时，你可以得到当前时间，并找出之前和当前时间之间的差值，如下所示。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2839405|#include+<iostream>
#include+<chrono>
#include+<ctime>


int+main()
{
++++auto+start+=+std::chrono::system_clock::now();

++++//+Some+time+consuming+operations+...+

++++auto+end+=+std::chrono::system_clock::now();
++++std::chrono::duration<double>+elapsed_seconds+=+end-start;+++
++++std::cout+<<+"elapsed+time:+"+<<+elapsed_seconds.count()+<<+"s\n";

++++//+Some+another+time+consuming+operations+...+

++++auto+end+=+std::chrono::system_clock::now();
++++std::chrono::duration<double>+elapsed_seconds+=+end-start;+++
++++std::cout+<<+"elapsed+time:+"+<<+elapsed_seconds.count()+<<+"s\n";

}|code-block|syntax|javascript|2839406|对于日志消息，它只是写到一个文件。因此，您可以创建自定义Logger类并编写特定于它的解析器，以便以特定的时间间隔读取消息。另一种选择是像你说的那样使用easyloggingcpp。您可以找到特定的示例here|offset|length|2839407|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/muflihun/easyloggingpp|1|https://stackoverflow.com/a/32262143/4735781^0|0|0|24|E|0|2T|4|1|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@$I|X|J|Y|1|Z]|$I|10|J|11|1|12]]|A|$]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]|S|$5|N|O|P|A|$Q|T]]]]

You can use std::chrono library for time purpose. You basically get the time at the beginning of the code and save it in a variable. After that, you can get the current time when ever you need the time interval and find the difference between previous and current time like following.

<pre><code>#include &lt;iostream&gt;
#include &lt;chrono&gt;
#include &lt;ctime&gt;


int main()
{
 auto start = std::chrono::system_clock::now();

 // Some time consuming operations ... 

 auto end = std::chrono::system_clock::now();
 std::chrono::duration&lt;double&gt; elapsed_seconds = end-start; 
 std::cout &lt;&lt; "elapsed time: " &lt;&lt; elapsed_seconds.count() &lt;&lt; "s\n";

 // Some another time consuming operations ... 

 auto end = std::chrono::system_clock::now();
 std::chrono::duration&lt;double&gt; elapsed_seconds = end-start; 
 std::cout &lt;&lt; "elapsed time: " &lt;&lt; elapsed_seconds.count() &lt;&lt; "s\n";

}
</code></pre>

For the log messaging, it is just about writing to a file. So you can create your custom Logger class and write a parser specific to it in order to read messages on specific time interval. Another option would be using <a href="https://github.com/muflihun/easyloggingpp" rel="nofollow noreferrer">easyloggingcpp</a> as you said. You can find specific example <a href="https://stackoverflow.com/a/32262143/4735781">here</a>

blocks|key|98944|text|我有一个简单的演示应用程序。我使用ctime获取时间戳std::time(0)。这段代码不应该被重用，它使用简单队列(不是线程安全的)只是为了让它变得简单演示。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|BOLD|entityRanges|data|98945|#include+<iostream>+++++//+std::cout
#include+<thread>+++++++//+std::thread
#include+<cstdio>+++++++//+printf,+scanf,+puts,+NULL
#include+<cstdlib>++++++//+srand,+rand
#include+<ctime>++++++++//+time
#include+<chrono>+++++++//+std::chrono::seconds,+std::this_thread::sleep_for
#include+<queue>++++++++//+std::ueue

std::queue<int>+queue;

void+producer()+{
++srand(time(NULL));

++while+(1)+{
++++int+message+=+rand();
++++queue.push(message);

++++int+sleep+=+rand()+%25+5;
++++std::this_thread::sleep_for(std::chrono::seconds(sleep));
++}
}

void+consumer()
{
++int+start_time+=+std::time(0);

++while(1)+{

++++printf("waiting\n");

++++while+(queue.empty());+//+busy+waiting

++++int+timestamp+=+std::time(0);
++++int+message+=+queue.front();
++++int+arrival_time_from_start+=+(timestamp+-+start_time);

++++queue.pop();
++++printf("message+%25d+arrive+at+%25d+(unix+timestamp),+%25d+second+after+app+start.\n",+message,+timestamp,+arrival_time_from_start);

++}++
}

int+main()+
{
++std::thread+first(producer);
++std::thread+second(consumer);

++first.join();++++++++++++++++//+pauses+until+first+finishes
++second.join();+++++++++++++++//+pauses+until+second+finishes

++return+0;
}|code-block|syntax|javascript|98946|生产者线程产生一些整数到queue，然后等待随机秒0-5。然后消费者线程，等待queue被填满。当queue被填满时，它将消耗(queue.pop())并打印到屏幕上，并带有其unix时间戳(自1970年1月1日以来的秒数)。|98947|它将产生类似如下的结果：|98948|waiting
message+1611033160+arrive+at+1527496314+(unix+timestamp),+0+second+after+app+start.
waiting
message+1055908354+arrive+at+1527496318+(unix+timestamp),+4+second+after+app+start.
waiting
message+788236843+arrive+at+1527496320+(unix+timestamp),+6+second+after+app+start.
waiting
message+1849353197+arrive+at+1527496323+(unix+timestamp),+9+second+after+app+start.
waiting
message+62004690+arrive+at+1527496326+(unix+timestamp),+12+second+after+app+start.
waiting
message+1668815337+arrive+at+1527496326+(unix+timestamp),+12+second+after+app+start.
waiting
message+533376047+arrive+at+1527496330+(unix+timestamp),+16+second+after+app+start.|98949|entityMap^0|H|5|R|C|14|14|0|0|C|5|13|5|1D|5|1S|B|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|D]]|E|@]|F|$]]|$1|G|3|H|5|I|7|10|8|@]|E|@]|F|$J|K]]|$1|L|3|M|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]]|E|@]|F|$]]|$1|N|3|O|5|6|7|1A|8|@]|E|@]|F|$]]|$1|P|3|Q|5|I|7|1B|8|@]|E|@]|F|$J|K]]|$1|R|3|-4|5|6|7|1C|8|@]|E|@]|F|$]]]|S|$]]

I have simple demo app for this. I use <code>ctime</code> for get timestamp <code>std::time(0)</code>. this code should not be reused, it use simple queue (not thread-safe) just for make it simple demo.

<pre><code>#include &lt;iostream&gt; // std::cout
#include &lt;thread&gt; // std::thread
#include &lt;cstdio&gt; // printf, scanf, puts, NULL
#include &lt;cstdlib&gt; // srand, rand
#include &lt;ctime&gt; // time
#include &lt;chrono&gt; // std::chrono::seconds, std::this_thread::sleep_for
#include &lt;queue&gt; // std::ueue

std::queue&lt;int&gt; queue;

void producer() {
 srand(time(NULL));

 while (1) {
 int message = rand();
 queue.push(message);

 int sleep = rand() % 5;
 std::this_thread::sleep_for(std::chrono::seconds(sleep));
 }
}

void consumer()
{
 int start_time = std::time(0);

 while(1) {

 printf("waiting\n");

 while (queue.empty()); // busy waiting

 int timestamp = std::time(0);
 int message = queue.front();
 int arrival_time_from_start = (timestamp - start_time);

 queue.pop();
 printf("message %d arrive at %d (unix timestamp), %d second after app start.\n", message, timestamp, arrival_time_from_start);

 } 
}

int main() 
{
 std::thread first(producer);
 std::thread second(consumer);

 first.join(); // pauses until first finishes
 second.join(); // pauses until second finishes

 return 0;
}
</code></pre>

Producer thread produce some integer to <code>queue</code>, then wait for random second [0-5]. Then the consumer thread, wait for <code>queue</code> filled. When <code>queue</code> filled, it consume (<code>queue.pop()</code>) and print to screen with its unix timestamp (seconds since 01-Jan-1970).

it will produce something like this:

<pre><code>waiting
message 1611033160 arrive at 1527496314 (unix timestamp), 0 second after app start.
waiting
message 1055908354 arrive at 1527496318 (unix timestamp), 4 second after app start.
waiting
message 788236843 arrive at 1527496320 (unix timestamp), 6 second after app start.
waiting
message 1849353197 arrive at 1527496323 (unix timestamp), 9 second after app start.
waiting
message 62004690 arrive at 1527496326 (unix timestamp), 12 second after app start.
waiting
message 1668815337 arrive at 1527496326 (unix timestamp), 12 second after app start.
waiting
message 533376047 arrive at 1527496330 (unix timestamp), 16 second after app start.
</code></pre>

blocks|key|96286|text|因此，在producer中需要一个能够感知应用程序启动时间的日志记录类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|96287|class+Logger+{
++++static+std::chrono::steady_clock::time_point+start;+//+program+start
++++std::ofstream+out;++++++++++++++++++++++++++++++++++//+log+file+stream
public:
++++Logger(const+char+*filename):+out(filename)+{}
++++void+log(const+char+*msg)+{+++++++++++++++++++++++++//+log+function
++++++++std::chrono::steady_clock::time_point+cur+=+std::chrono::steady_clock::now();
++++++++std::chrono::duration<double>+d+=+cur+-+start;++//+delta+time+since+program+start
++++++++//+prepend+text+message+with+delta+time
++++++++out+<<+int(d.count())+<<+"+-+"+<<+msg+<<+std::endl;
++++}
++++~Logger()+{
++++++++out.close();
++++}
};|code-block|syntax|javascript|96288|下面的部分是一个定义规则的定义，它应该在你的程序中只出现一次。即使类的定义位于包含文件中，也应将其写入主源文件中|96289|//+definition+of+static+member
std::chrono::steady_clock::time_point+Logger::start+=+std::chrono::steady_clock::now();|96290|你可以在生产者程序中简单地使用它：|96291|int+main()+{
++++Logger+log("foo.log");
++++std::chrono::duration<int>+d+=+std::chrono::duration<int>(1);
++++//+sleep+for+1+second
++++std::this_thread::sleep_for(d);
++++log.log("After+1s");
++++//+sleep+for+4+seconds+more
++++d+=+std::chrono::duration<int>(4);
++++std::this_thread::sleep_for(d);
++++log.log("After+5s");
++++return+0;
}|96292|然后，您需要一个读取器，它从日志文件中读取每一行，从开始提取延迟，并从最后一条消息计算延迟(从开始开始的延迟随着构造的增加而增加)，并在该时间休眠：|96293|int+main()+{
++++std::ifstream+in("foo.log");+++++++++++//+log+file+input+stream
++++//+store+program+start+time
++++std::chrono::steady_clock::time_point+start+=+std::chrono::steady_clock::now();
++++std::string+line;
++++while+(std::getline(in,+line))+{+++++++//+read+log+file+one+line+at+a+time
++++++++std::stringstream+ss(line);++++++++//+parse+line+to+extract+delay
++++++++int+delay;
++++++++if+(!+(ss+>>+delay))+break;
++++++++std::chrono::duration<int>+d(delay);
++++++++std::this_thread::sleep_until(start+%2B+d);+//+wait+until+approriate+time
++++++++//+message+processing+(here+simple+display+on+stdout)
++++++++std::cout+<<+line+<<+std::endl;
++++}
++++return+0;
}|96294|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

So you need a logging class in producer that will be aware of application start time.

<pre><code>class Logger {
 static std::chrono::steady_clock::time_point start; // program start
 std::ofstream out; // log file stream
public:
 Logger(const char *filename): out(filename) {}
 void log(const char *msg) { // log function
 std::chrono::steady_clock::time_point cur = std::chrono::steady_clock::now();
 std::chrono::duration&lt;double&gt; d = cur - start; // delta time since program start
 // prepend text message with delta time
 out &lt;&lt; int(d.count()) &lt;&lt; " - " &lt;&lt; msg &lt;&lt; std::endl;
 }
 ~Logger() {
 out.close();
 }
};
</code></pre>

The following part is a One Definition Rule definition that shall occur exactly once in your program. You should write it in the main source even if the definition of the class is in an include file

<pre><code>// definition of static member
std::chrono::steady_clock::time_point Logger::start = std::chrono::steady_clock::now();
</code></pre>

You can use it simply in producer program:

<pre><code>int main() {
 Logger log("foo.log");
 std::chrono::duration&lt;int&gt; d = std::chrono::duration&lt;int&gt;(1);
 // sleep for 1 second
 std::this_thread::sleep_for(d);
 log.log("After 1s");
 // sleep for 4 seconds more
 d = std::chrono::duration&lt;int&gt;(4);
 std::this_thread::sleep_for(d);
 log.log("After 5s");
 return 0;
}
</code></pre>

Then you need a reader that reads each line from the log file, extracts the delay from beginning and computes a delay from the last message (the delays from beginning are increasing by construction), and sleeps for that time:

<pre><code>int main() {
 std::ifstream in("foo.log"); // log file input stream
 // store program start time
 std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
 std::string line;
 while (std::getline(in, line)) { // read log file one line at a time
 std::stringstream ss(line); // parse line to extract delay
 int delay;
 if (! (ss &gt;&gt; delay)) break;
 std::chrono::duration&lt;int&gt; d(delay);
 std::this_thread::sleep_until(start + d); // wait until approriate time
 // message processing (here simple display on stdout)
 std::cout &lt;&lt; line &lt;&lt; std::endl;
 }
 return 0;
}
</code></pre>

I want to write to log file with timestamp. The timestamp should represent the time interval from beginning of the application like below:
<blockquote>
1: This log message arrived after 1s of starting the application
5: This log message arrived after 5s of starting the application
</blockquote>
Then i want to read the log message in that exact time interval. Like after 1s i will read the first message then when 5s is passed i will read the second message.
Is there any library by which i can do that? I have found some library like <a href="https://github.com/muflihun/easyloggingpp" rel="nofollow noreferrer">easyloggingcpp</a> which can save log file using timestamp. But the timestamp is the corresponding time. Also i have not found any way how to read the message on specific time interval.
Is there any way i can do it?

Read & write log on specific time interval c++

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想写入带有时间戳的日志文件。时间戳应表示从应用程序开始起的时间间隔，如下所示： 1:此日志消息在应用程序启动1秒后到达5:此日志消息在应用程序启动5秒后到达然后我想在那个确切的时间间隔内读取日志消息。就像在1之后，我将阅读第一条消息，然后当5秒过去时，我将阅读第二条消息。有没有什么库可以让我这么做的？我找到了一些像这...

问特定时间间隔c++上的读写日志
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问特定时间间隔c++上的读写日志EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问特定时间间隔c++上的读写日志
EN