三种在C++中高效获取日志文件最后10行的方法

大风吹浪 發表於 2026-1-7 10:02:03

三种在C++中高效获取日志文件最后10行的方法

<div id="navCategory"><h5 class="catalogue">目录</h5><ul class="first_class_ul"><li>准备工作：创建一个测试文件testlog.txt</li><li>第一部分：方法 1 (“天真”法) —— 读取所有行</li><li>第二部分：方法 2 (“折中”法) —— 循环缓冲区</li><li>第三部分：方法 3 (“专业”法) ——seekg反向读取</li><li>第四部分：“X光透视”——亲眼目睹“反向搜寻”</li><ul class="second_class_ul"><li>“X光”实战（基于seekg_pro.cpp）</li></ul><li>动手试试！(终极挑战：你的“可配置tail”)</li><ul class="second_class_ul"></ul></ul></div>在C++编程中，你经常需要处理文件，尤其是日志文件。一个非常常见的任务是：“我不想看整个10GB的日志文件，我只想看最后 10 行，看看最近发生了什么。”
这就像 Linux/macOS 上的 <code>tail -n 10</code> 命令。
一个简单的比喻：“读一本厚书的最后一章”
<ul><li>问题： 你想读一本 1000 页巨著的最后一章（最后10行）。</li><li>“天真”的办法 (Naive Method)：你从第 1 页开始，一页一页地读并记住（存入内存）所有 1000 页内容，最后再翻到你记住的第 990 页开始看。<ul><li>缺点： 极度浪费内存（O(N) 空间）和时间（O(N) 时间）。</li></ul></li><li>“折中”的办法 (Circular Buffer)：你只拿 10 张便签。你从第 1 页开始读，第 1 页内容写在便签1，…，第 10 页写在便签10。当你读第 11 页时，你擦掉便签1，写上第 11 页的内容。读第 12 页时，擦掉便签2…<ul><li>缺点： 你仍然需要从头到尾读完 1000 页（O(N) 时间）。</li><li>优点： 你只需要 10 张便签的内存（O(k) 空间）。</li></ul></li><li>“专业”的办法 (Seek from End)：你直接把书翻到最后一页（<code>seekg(0, ios::end)</code>）。然后，你开始一页一页往前翻，一边翻一边数你翻过了多少个“章节末尾”（<code>\n</code> 换行符）。当你数到 10 个时，你就停下，然后从这里往后读到结尾。<ul><li>优点： 速度极快（只读文件尾部，O(k*L) 时间，L为行长），几乎不占内存（O(1) 空间）。</li><li>缺点： 逻辑最复杂。</li></ul></li></ul>
在本教程中，你将学会：
<ul><li>文件输入流 <code>ifstream</code>：如何打开和读取文件。</li><li>方法 1 (“天真”法)：读取所有行到 <code>vector</code>。</li><li>方法 2 (“折中”法)：使用 <code>deque</code> (双端队列) 作为“循环缓冲区”。</li><li>方法 3 (“专业”法)：使用 <code>seekg</code> 和 <code>tellg</code> 从文件末尾反向读取。</li><li>文件指针 (<code>seekg</code>)：<code>ios::end</code>, <code>ios::cur</code> 的含义。</li><li>“X光透视”：用调试器“亲眼目睹” <code>seekg</code> 是如何反向计数的。</li></ul>
前置知识说明 (100% 自洽)：
<ul><li>变量 (Variable)：理解存储数据的“盒子”，如 <code>int n = 10;</code>。</li><li><code>string</code> (字符串)：C++标准库提供的“魔法弹性盒子”，用于处理文本。你需要 <code>#include <string></code>。</li><li><code>vector</code> (向量)：C++标准库提供的一种“动态数组”（“魔法弹性盒子列表”）。你需要 <code>#include <vector></code>。</li><li><code>deque</code> (双端队列)：类似 <code>vector</code>，但支持高效地在头部和尾部添加/删除元素。你需要 <code>#include <deque></code>。</li><li><code>ifstream</code> (文件输入流)：C++ 用于读取文件的工具。你需要 <code>#include <fstream></code>。</li><li><code>seekg</code> / <code>tellg</code>：<code>ifstream</code> 的成员函数，用于“Seek Get” (移动读取指针) 和 “Tell Get” (告知读取指针位置)。</li><li>编译 (Compile)：C++代码（“食谱”）必须被“编译”（“烘焙”），才能变成电脑可执行的程序（“蛋糕”）。</li></ul>
<h2>准备工作：创建一个测试文件testlog.txt</h2>
在运行代码前，请在你的 <code>.cpp</code> 文件相同的目录下，创建一个名为 <code>testlog.txt</code> 的文件，并填入以下内容（确保最后一行有换行）：
<div class="jb51code"><pre class="brush:cpp;">Line 1: The quick brown fox
Line 2: jumps over
Line 3: the lazy dog.
Line 4: ---
Line 5: C++ File I/O
Line 6: is powerful.
Line 7: ---
Line 8: Testing line 8.
Line 9: Testing line 9.
Line 10: Testing line 10.
Line 11: Testing line 11.
Line 12: Testing line 12.
Line 13: This is the final line.
</pre></div>
<h2>第一部分：方法 1 (“天真”法) —— 读取所有行</h2>
逻辑： 把文件的每一行都读入一个 <code>vector<string></code>，然后只打印这个 <code>vector</code> 的最后 10 个元素。
<code>naive_tail.cpp</code>
<div class="jb51code"><pre class="brush:cpp;">#include <iostream>
#include <fstream>
#include <string>
#include <vector>
using namespace std;

void printLast10_Naive(const string& filename) {
ifstream file(filename);
if (!file.is_open()) {
 cerr << "错误: 无法打开文件 " << filename << endl;
 return;
}

vector<string> allLines;
string line;

// 1. “天真”地读取 *所有* 行
while (getline(file, line)) {
 allLines.push_back(line);
}
file.close();

// 2. 计算从哪里开始打印
int totalLines = allLines.size();
int start_index = 0;
if (totalLines > 10) {
 start_index = totalLines - 10;
}

// 3. 打印最后 10 (或更少) 行
cout << "--- 方法 1 (Naive) ---" << endl;
for (int i = start_index; i < totalLines; ++i) {
 cout << allLines << endl;
}
}

int main() {
printLast10_Naive("testlog.txt");
return 0;
}
</pre></div>
<ul><li>优点： 逻辑最简单，易于理解。</li><li>缺点： 极度浪费内存。如果 <code>testlog.txt</code> 是 10GB，你的程序会尝试申请 10GB 内存！</li></ul>
<h2>第二部分：方法 2 (“折中”法) —— 循环缓冲区</h2>
逻辑： 我们只保留一个固定大小（10）的“缓冲区”（使用 <code>deque</code>）。从头到尾读取文件，每读一行，就把它塞进缓冲区，如果缓冲区“满了”（超过10），就从前面“挤掉”最旧的那一行。
<code>circular_buffer.cpp</code>
<div class="jb51code"><pre class="brush:cpp;">#include <iostream>
#include <fstream>
#include <string>
#include <deque> // 需要双端队列
using namespace std;

void printLast10_Circular(const string& filename, int N = 10) {
ifstream file(filename);
if (!file.is_open()) {
 cerr << "错误: 无法打开文件 " << filename << endl;
 return;
}

deque<string> buffer;
string line;

// 1. 仍然读取 *所有* 行
while (getline(file, line)) {
 // 2. 添加到“队尾”
 buffer.push_back(line);

 // 3. 如果缓冲区“超载”，从“队首”挤掉
 if (buffer.size() > N) {
 buffer.pop_front();
 }
}
file.close();

// 4. 打印缓冲区中剩下的 N 行
cout << "--- 方法 2 (Circular Buffer) ---" << endl;
for (const string& s : buffer) {
 cout << s << endl;
}
}

int main() {
printLast10_Circular("testlog.txt");
return 0;
}
</pre></div>
<ul><li>优点： 内存效率极高（O(k) 空间）。</li><li>缺点： 仍然需要从头到尾读取整个文件（O(N) 时间），对于 10GB 的文件，这仍然很慢。</li></ul>
<h2>第三部分：方法 3 (“专业”法) ——seekg反向读取</h2>
逻辑： 像“<code>tail</code> 命令”一样，直接跳到文件末尾，然后一个字节一个字节地往前“挪”，同时**“数”**换行符 <code>\n</code>。当我们数到 10 个换行符时，我们就找到了第 10 行的开头。
<code>seekg_pro.cpp</code> (推荐的方式)
<div class="jb51code"><pre class="brush:cpp;">#include <iostream>
#include <fstream>
#include <string>
using namespace std;

void printLast10_Pro(const string& filename, int N = 10) {
ifstream file(filename);
if (!file.is_open()) {
 cerr << "错误: 无法打开文件 " << filename << endl;
 return;
}

// 1. 跳转到文件末尾
// (ios::ate 模式可以打开文件并立即定位到末尾)
// 或者使用 seekg:
file.seekg(0, ios::end);

// 2. 获取当前位置（即文件总大小）
long long pos = file.tellg();

// 如果文件为空
if (pos == 0) {
 cout << "文件为空。" << endl;
 return;
}

int newlineCount = 0;
string lineBuffer; // 用于读取最后的残行

// 3. “行内预警”：我们从 *最后一个字符* 开始往前“跳”
// (pos 是文件大小，最后一个字符的索引是 pos - 1)
for (long long i = pos - 1; i >= 0; i--) {
 file.seekg(i); // “跳”到第 i 个字节

 char c = file.get(); // 读取那 1 个字节

 if (c == '\n') {
 newlineCount++;
 }

 // 4. “刹车”：当我们找到 N 个换行符时
 // (注意：GFG的例子是 == N，但 >= N 更健壮)
 if (newlineCount >= N) {
 // “行内预警”：我们需要跳到 *这个换行符之后* 的位置
 file.seekg(i + 1);
 break; // 停止“回溯”
 }
}

// 5. 如果文件行数不足 N，我们最终会跳到开头
if (newlineCount < N) {
 file.seekg(0); // 重置到文件开头
}

// 6. 现在，从我们“停下”的位置，*顺序* 读到文件末尾
cout << "--- 方法 3 (Seek from End) ---" << endl;
string line;
while (getline(file, line)) {
 cout << line << endl;
}

file.close();
}

int main() {
printLast10_Pro("testlog.txt");
return 0;
}
</pre></div>
“手把手”终端模拟 (所有方法)：
<div class="jb51code"><pre class="brush:cpp;">PS C:\MyCode> g++ ... # 编译所有 .cpp 文件
PS C:\MyCode> .\naive_tail.exe
--- 方法 1 (Naive) ---
Line 4: ---
Line 5: C++ File I/O
Line 6: is powerful.
Line 7: ---
Line 8: Testing line 8.
Line 9: Testing line 9.
Line 10: Testing line 10.
Line 11: Testing line 11.
Line 12: Testing line 12.
Line 13: This is the final line.

PS C:\MyCode> .\circular_buffer.exe
--- 方法 2 (Circular Buffer) ---
Line 4: ---
... (输出同上) ...
Line 13: This is the final line.

PS C:\MyCode> .\seekg_pro.exe
--- 方法 3 (Seek from End) ---
Line 4: ---
... (输出同上) ...
Line 13: This is the final line.
</pre></div>
顿悟时刻： 三种方法结果相同，但效率（尤其是内存和I/O）天差地别！<code>seekg</code> 是处理大文件的“专业”选择。
<h2>第四部分：“X光透视”——亲眼目睹“反向搜寻”</h2>
让我们用“X光眼镜”（调试器）来观察 <code>seekg_pro.cpp</code> 是如何工作的。
<h3>“X光”实战（基于seekg_pro.cpp）</h3>
设置断点：
<ul><li>动作： 在VS Code中，把你的鼠标移动到第32行（<code>if (c == '\n')</code> 那一行）的行号左边。</li><li>点击那个小 red dot，设置一个断点。</li></ul>
启动“子弹时间”（F5）：
<ul><li>动作： 按下 <code>F5</code> 键。</li><li>你会看到： <code>file</code> 被打开，<code>seekg(0, ios::end)</code> 被执行，<code>pos</code> 被设为文件大小（例如 250 字节）。</li></ul>
第一次“冻结” (i = 249, 假设)：
<ul><li><code>for</code> 循环开始。<code>i</code> 是 249 (文件的最后一个字符)。</li><li><code>file.seekg(249)</code> 执行。</li><li><code>file.get()</code> 读取 <code>testlog.txt</code> 的最后一个字符（假设是 <code>\n</code>）。</li><li>程序“冻结”在第32行。</li><li>开启“X光”（观察变量）：<ul><li><code>pos: 250</code></li><li><code>i: 249</code></li><li><code>newlineCount: 0</code></li><li><code>c: '\n'</code></li></ul></li><li>动作： 按下 <code>F10</code> 键（“Step Over”，步过）。</li><li>你会看到： <code>newlineCount</code> 变成了 <code>1</code>。</li></ul>
继续执行 (F5)：
<ul><li>动作： 连续按下 <code>F5</code> 键（“Continue”，让程序在断点处循环）。</li><li>你会看到： 调试器会一次又一次地停在第32行。</li><li>观察 <code>i</code> 和 <code>newlineCount</code> 的变化：<ul><li><code>i</code> 在递减 (248, 247, …)。</li><li>只有当 <code>c</code> 恰好是 <code>\n</code> 时，<code>newlineCount</code> 才会增加。</li></ul></li><li>…</li><li>第十次“冻结”在 <code>\n</code>：<ul><li>假设 <code>i</code> 此时是 60。</li><li><code>c: '\n'</code>。</li><li><code>newlineCount</code> 变成了 <code>9</code>。</li></ul></li><li>动作： 按下 <code>F10</code> 键，<code>newlineCount</code> 变为 <code>10</code>。</li><li>动作： 再按 <code>F10</code> 键，<code>if (newlineCount >= 10)</code> 为 <code>true</code>！</li><li>动作： 按下 <code>F11</code> 键（“Step Into”） 进入 <code>if</code> 块。</li><li>你会看到： 高亮条移动到 <code>file.seekg(i + 1);</code> (即 <code>file.seekg(61);</code>)。</li><li>动作： 按 <code>F10</code> 执行 <code>break;</code>。</li><li>顿悟时刻： 循环终止！程序“定位”到了第10个换行符（索引60）。</li></ul>
（程序继续） <code>file.seekg(61)</code> 将指针设置到“第4行”的开头，<code>while (getline(...))</code> 开始顺序打印，直到文件末尾。
<h2>动手试试！(终极挑战：你的“可配置tail”)</h2>
现在，你来当一次“工具开发者”。
任务：
<ol><li>复制本教程“方法 2 (循环缓冲区)”的代码（<code>printLast10_Circular</code>）。</li><li>修改这个函数，使其能够返回一个 <code>vector<string></code>，而不是 <code>void</code>（打印）。</li><li>在 <code>main</code> 函数中，调用这个新函数（比如 <code>vector<string> lastLines = getLastNLines("testlog.txt", 5);</code>），并自己遍历打印这个返回的 <code>vector</code>。</li><li>（进阶） 复制本教程“方法 3 (专业 <code>seekg</code>)”的代码，并同样将其修改为返回 <code>vector<string></code>，而不是 <code>void</code>（打印）。（提示：在 <code>file.seekg(pos);</code> 之后，你需要使用 <code>getline</code> 循环把剩余的行读入一个新的 <code>vector</code> 并返回）。</li></ol>
<code>flexible_tail.cpp</code> (你的 TODO - 挑战方法 2):
<div class="jb51code"><pre class="brush:cpp;">#include <iostream>
#include <fstream>
#include <string>
#include <deque>
#include <vector>
using namespace std;

// --- TODO 1 & 2: 修改函数，使其返回 vector<string> ---
vector<string> getLastNLines_Circular(const string& filename, int N = 10) {
ifstream file(filename);
deque<string> buffer;

// （如果打开失败，返回一个空 vector）
if (!file.is_open()) {
 cerr << "错误: 无法打开文件 " << filename << endl;
 return vector<string>();
}

string line;
while (getline(file, line)) {
 buffer.push_back(line);
 if (buffer.size() > N) {
 buffer.pop_front();
 }
}
file.close();

// --- TODO 2: 将 deque 转换为 vector 并返回 ---
// (提示：vector 有一个构造函数可以直接接收两个迭代器)
// return vector<string>(buffer.begin(), buffer.end());
}

int main() {
// --- TODO 3: 调用新函数并打印 ---
cout << "--- 测试 getLastNLines (N=5) ---" << endl;

// vector<string> last5Lines = getLastNLines_Circular("testlog.txt", 5);

// for (const string& s : last5Lines) {
// cout << s << endl;
// }

return 0;
}
</pre></div>
<blockquote>这个挑战让你把“打印”逻辑和“数据获取”逻辑分离开，这是更健壮的函数设计。如果你能进一步挑战并修改 seekg 版本，你就能完全掌握C++中高效文件读取的精髓！</blockquote>
以上就是三种在C++中高效获取日志文件最后10行的方法的详细内容，更多关于C++获取日志文件最后10行的资料请关注琼殿技术社区其它相关文章！

 <div class="art_xg">
 您可能感兴趣的文章:<ul><li>C++简单日志系统实现代码示例</li><li>c++日志库log4cplus快速入门小结</li><li>C++ Log4cpp跨平台日志库的使用小结</li><li>C++多进程环境下的日志管理策略和最佳实践</li><li>C++中实现调试日志输出</li></ul>
 </div>

 </div>

頁: [1]

琼殿技术论坛's Archiver

三种在C++中高效获取日志文件最后10行的方法