C++ 手写高性能日志模块采用策略模式设计，支持控制台与文件两种输出方式。通过枚举定义日志等级，利用 C++17 filesystem 管理日志目录，结合 localtime_r 获取时间戳。内部类 LogMessage 封装日志拼接逻辑，析构时触发刷新，实现 RAII 风格。提供宏定义简化调用，确保多线程安全。
池化技术可以减少很多的底层重复工作，例如创建进程、线程、申请内存空间时的系统调用和初始化工作。例如线程池，先预先创建好一些线程，当任务到来时直接将预先创建好的线程唤醒去处理任务，效率会远远高于任务到来时临时创建线程。例如内存池，但我们要用 1mb 空间时内存池会一次性申请 20mb 空间，效率会远远高于用多少空间申请多少空间（申请空间会调用系统调用）。 线程池是执行流级别的池化技术，STL 中的空间配置器和内存池是内存块管理级别的池化技术。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online
将JSON字符串修饰为友好的可读格式。 在线工具，JSON美化和格式化在线工具，online
下面开始，我们结合之前所做的所有封装，进行一个线程池的设计。在写之前，我们要做如下准备。
什么是设计模式 IT 行业这么火，涌入的人很多。俗话说林子大了啥鸟都有。大佬和菜鸡们两极分化的越来越严重。为了让菜鸡们不太拖大佬的后腿，于是大佬们针对一些经典的常见场景，给定了一些对应的解决方案，这个就是设计模式。
什么是日志 计算机中的日志是记录系统和软件运行中发生事件的文件，主要作用是监控运行状态、记录异常信息，帮助快速定位问题并支持程序员进行问题修复。它是系统维护、故障排查和安全管理的重要工具。 日志格式以下几个指标是必须得有的 时间戳 日志等级（严重程度） 日志内容 以下儿个指标是可选的 文件名行号 进程，线程相关 id 信息等 日志有现成的解决方案，如：spdlog、glog、Boost.Log、Log4cxx 等等，我们依旧采用自定义日志的方式。 这里我们采用设计模式中的策略模式来进行日志的设计，具体策略模式介绍，详情看下文。 我们想要的日志格式如下：
我们知道枚举类型中的枚举值（编译期常量）的底层存储是整数，所以我们需要把它们转换成字符串输出。（补充：枚举值的类型就是枚举类本身）
//Logger.hpp
// C++11 支持的强枚举，访问成员需指定作用域，不易出现命名冲突
enum class LogLevel {
DEBUG,
INFO, // 正常消息
WARNING, // 出现错误，但不影响程序运行
ERROR, // 导致程序退出的错误
FATAL // 重大错误
};
std::string Level_to_string(LogLevel level) {
switch(level) {
case LogLevel::DEBUG: return "DEBUG";
case LogLevel::INFO: return "INFO";
case LogLevel::WARNING: return "WARNING";
case LogLevel::ERROR: return "ERROR";
case LogLevel::FATAL: return "FATAL";
default: return "Unknown";
}
}
日志的刷新策略我们打算用策略模式来设计，策略模式其实就是利用 C++ 的多态特性，先创建一个日志刷新基类，然后根据日志具体往哪刷新写具体的派生类函数，例如往显示器中写、往文件中写、往网络中写等等。
重点讲一下往文件中写，具体实现注意事项及步骤如下：
下面是源码及测试代码：
//logger.hpp
// 策略模式，策略接口
class LogStrategy {
public:
virtual ~LogStrategy() = default;
// 纯虚函数，强制派生类重写该函数
virtual void SyncLog(const std::string &logmessage) = 0;
};
// 控制台日志策略，就是日志只向显示器打印，方便我们 debug
class ConsoleLogStrategy : public LogStrategy {
public:
~ConsoleLogStrategy() {}
void SyncLog(const std::string &logmessage) override {
// 显示器是共享资源，需要加锁保护
{
LockGuard lockguard(&_lock);
std::cout << logmessage << std::endl;
}
}
private:
Mutex _lock;
};
// 日志向文件打印
const std::string logdefaultpath = "log";
const static std::string logdefaultfilename = "test.log";
class FileLogStrategy : public LogStrategy {
public:
FileLogStrategy(const std::string &dir = logdefaultpath, const std::string &filename = logdefaultfilename)
: _dir_path_name(dir), _filename(filename) {
// 有可能多个线程都在新建目录，所以最好对新建目录也进行加锁
{
LockGuard lockguard(&_lock);
if(std::filesystem::exists(_dir_path_name)) {
// 当前工作路径下目录存在，不用新建目录，直接返回
return;
}
try {
std::filesystem::create_directories(_dir_path_name);
} catch(const std::filesystem::filesystem_error &e) {
std::cerr << e.what() << '\n';
}
}
}
void SyncLog(const std::string &logmessage) override {
// 显示器是共享资源，需要加锁保护
{
LockGuard lockguard(&_lock);
// 拼接目标文件路径
std::string target = _dir_path_name;
target += "/";
target += _filename;
std::ofstream out(target.c_str(), std::ios::app); // app
if(!out.is_open()) {
// 打开文件失败
return;
}
out << logmessage << "\n"; // 等价于 out.write()
out.close();
}
}
~FileLogStrategy() {}
private:
std::string _dir_path_name; // 要写入的目录路径名 // log
std::string _filename; // 形成日志文件的文件名 // hello.log
// 例子：先创建一个 log 目录，再在 log 路径下形成 hello.log 文件，并把日志内容写到该文件中
Mutex _lock;
};
//main.cc
#include "Logger.hpp"
int main() {
std::string test = "hello logger";
// 测试策略 2，文件写入
// 智能指针，本质就是对 LogStrategy * 原生指针做了封装
std::unique_ptr<LogStrategy> logger_ptr = std::make_unique<FileLogStrategy>();
logger_ptr->SyncLog(test);
logger_ptr->SyncLog(test);
logger_ptr->SyncLog(test);
logger_ptr->SyncLog(test);
logger_ptr->SyncLog(test);
return 0;
}
// 根据时间戳，获取可读性较强的时间信息
std::string GetCurrentTime() {
// 1、获取时间戳
time_t curtime = time(nullptr);
// 2、把时间戳转化为年月日时分秒
struct tm currtm;
localtime_r(&curtime, &currtm);
// 3、把年月日时分秒转化为字符串
char timebuffer[64];
snprintf(timebuffer, sizeof(timebuffer), "%4d-%02d-%02d %02d:%02d:%02d",
currtm.tm_year + 1900, currtm.tm_mon + 1, currtm.tm_mday,
currtm.tm_hour, currtm.tm_min, currtm.tm_sec);
return timebuffer;
}
现在所有零件都已加工完成，接下来需要把它们拼接成一个完整的日志类，供我们使用。
首先需要激活策略，要开启什么策略，就把策略对应的派生类对象创建出来，并把派生类成员指针变量指向该对象。
class Logger {
public:
Logger() {}
// 激活策略
void EnableConsoleLogStrategy() { _strategy = std::make_unique<ConsoleLogStrategy>(); }
void EnableFileLogStrategy() { _strategy = std::make_unique<FileLogStrategy>(); }
~Logger() {}
private:
std::unique_ptr<LogStrategy> _strategy;
};
现在我们还缺形成一条完整日志的方式，这里利用内部类来实现，在 logger 内部定义一个 LogMessage 的内部类，利用 LogMessage 将各种日志信息拼接成一个字符串，在 LogMessage 的析构函数中调用 logger 成员变量_strategy 的刷新函数将字符串刷新出去，这也是 RAII 风格的设计思路，所以内部类还需要定义一个对外部类引用的成员变量。
形成一条完整日志后就需要将日志信息信息刷新出去，这里我们通过重载括号运算符实现，比定义一个具体 writelog 函数更优雅。
LogMessage 的构造函数： 首先将成员变量利用初始化列表初始化，然后用 stringstream 类对象 ss 将各种类型的成员变量格式化为字符串，接着调用对象 ss 的 str 接口，将其赋给_loginfo，构成日志信息的左半部分。 stringstream 需要包 头文件，它是 C++ 提供的格式化方案，前面我们用的 snprintf 是 C 语言提供的方案。
LogMessage 的 operator<<： 然后拼接_loginfo 右半部分，首先我们先大致看一下未来的日志输出方式：
LOG(LogLevel::FATAL) << "hello world" << 1234 << ", 3.14" << 'c';
我们可以看到右半部分是参数是可变的，并且参数类型也不确定，所以处理思路是在内部类中对输出运算符做重载，并且参数类型设置成模板，这样任意类型参数都可以输出。
LogMessage 的析构函数： 当 LogMessage 调用 operator<<完毕后，_loginfo 也就拼接完毕了，此时 LogMessage 要析构了，我们就可以在 LogMessage 的析构函数中将_loginfo 的日志信息刷新出去。
//logger.hpp
#pragma once
#include <iostream>
#include <filesystem> // C++17
#include <fstream>
#include <string>
#include <sstream>
#include <ctime>
#include <memory>
#include <unistd.h>
#include "Mutex.hpp"
// C++11 支持的强枚举，访问成员需指定作用域，不易出现命名冲突
enum class LogLevel {
DEBUG,
INFO, // 正常消息
WARNING, // 出现错误，但不影响程序运行
ERROR, // 导致程序退出的错误
FATAL // 重大错误
};
std::string Level_to_string(LogLevel level) {
switch(level) {
case LogLevel::DEBUG: return "DEBUG";
case LogLevel::INFO: return "INFO";
case LogLevel::WARNING: return "WARNING";
case LogLevel::ERROR: return "ERROR";
case LogLevel::FATAL: return "FATAL";
default: return "Unknown";
}
}
// 根据时间戳，获取可读性较强的时间信息
std::string GetCurrentTime() {
// 1、获取时间戳
time_t curtime = time(nullptr);
// 2、把时间戳转化为年月日时分秒
struct tm currtm;
localtime_r(&curtime, &currtm);
// 3、把年月日时分秒转化为字符串
char timebuffer[64];
snprintf(timebuffer, sizeof(timebuffer), "%4d-%02d-%02d %02d:%02d:%02d",
currtm.tm_year + 1900, currtm.tm_mon + 1, currtm.tm_mday,
currtm.tm_hour, currtm.tm_min, currtm.tm_sec);
return timebuffer;
}
///////////////////////////////////////////////////////////////
// 策略模式，策略接口
class LogStrategy {
public:
virtual ~LogStrategy() = default;
// 纯虚函数，强制派生类重写该函数
virtual void SyncLog(const std::string &logmessage) = 0;
};
// 控制台日志策略，就是日志只向显示器打印，方便我们 debug
class ConsoleLogStrategy : public LogStrategy {
public:
~ConsoleLogStrategy() {}
void SyncLog(const std::string &logmessage) override {
// 显示器是共享资源，需要加锁保护
{
LockGuard lockguard(&_lock);
std::cout << logmessage << std::endl;
}
}
private:
Mutex _lock;
};
// 日志向文件打印
const std::string logdefaultpath = "log";
const static std::string logdefaultfilename = "test.log";
class FileLogStrategy : public LogStrategy {
public:
FileLogStrategy(const std::string &dir = logdefaultpath, const std::string &filename = logdefaultfilename)
: _dir_path_name(dir), _filename(filename) {
// 有可能多个线程都在新建目录，所以最好对新建目录也进行加锁
{
LockGuard lockguard(&_lock);
if(std::filesystem::exists(_dir_path_name)) {
// 当前工作路径下目录存在，不用新建目录，直接返回
return;
}
try {
std::filesystem::create_directories(_dir_path_name);
} catch(const std::filesystem::filesystem_error &e) {
std::cerr << e.what() << '\n';
}
}
}
void SyncLog(const std::string &logmessage) override {
// 显示器是共享资源，需要加锁保护
{
LockGuard lockguard(&_lock);
// 拼接目标文件路径
std::string target = _dir_path_name;
target += "/";
target += _filename;
std::ofstream out(target.c_str(), std::ios::app); // app
if(!out.is_open()) {
// 打开文件失败
return;
}
out << logmessage << "\n"; // 等价于 out.write()
out.close();
}
}
~FileLogStrategy() {}
private:
std::string _dir_path_name; // 要写入的目录路径名 // log
std::string _filename; // 形成日志文件的文件名 // hello.log
// 例子：先创建一个 log 目录，再在 log 路径下形成 hello.log 文件，并把日志内容写到该文件中
Mutex _lock;
};
////////////////////////////////////////////////////////////
class Logger {
public:
Logger() {}
// 激活策略
void EnableConsoleLogStrategy() { _strategy = std::make_unique<ConsoleLogStrategy>(); }
void EnableFileLogStrategy() { _strategy = std::make_unique<FileLogStrategy>(); }
// 形成一条完整的日志信息，利用内部类 LogMessage
class LogMessage {
public:
LogMessage(LogLevel level, std::string filename, int line, Logger &logger)
: _curr_time(GetCurrentTime()), _level(level), _pid(getpid()),
_filename(filename), _line(line), _logger(logger) {
std::stringstream ss;
ss << "[" << _curr_time << "] "
<< "[" << Level_to_string(_level) << "] "
<< "[" << _pid << "] "
<< "[" << _filename << "] "
<< "[" << _line << "] ";
_loginfo = ss.str();
}
template<typename T>
LogMessage &operator<<(const T &info) {
std::stringstream ss;
ss << info;
_loginfo += ss.str();
return *this;
}
~LogMessage() {
// 如果外部类的_strategy 的成员变量不为空，
// 就可以将_loginfo 的内容通过_strategy 刷新出去
if(_logger._strategy) {
_logger._strategy->SyncLog(_loginfo);
}
}
private:
std::string _curr_time; // 日志时间
LogLevel _level; // 日志等级
pid_t _pid; // 进程 pid
std::string _filename; // 对应的文件名
int _line; // 对应的文件行号
std::string _loginfo; // 一条合并完成的，完整的日志信息
Logger &_logger; // 对外部类引用，利用 Logger 为 LogMessage 提供刷新策略
};
// Logger 提供的写日志方法
LogMessage operator()(LogLevel level, std::string filename, int line) {
// 返回 LogMessage 的匿名对象
return LogMessage(level, filename, line, *this);
}
// 上面 LogMessage operator() 实现引出的一些知识点：
// 1、直接返回 LogMessage 临时对象，和先显式创建对象再返回的写法
// 在绝大多数场景下效果完全一致，返回临时对象的写法
// 编译器会直接在'接收返回值的位置'构造 LogMessage 对象，无任何拷贝/移动
// 先显式创建对象再返回的写法编译器会触发 RVO 优化，同样省略 log_msg 的拷贝 / 移动，
// 最终效果和写法 1 完全一致；即使关闭优化，C++11 也会通过移动构造函数
// （LogMessage 无自定义移动构造时，编译器自动生成）完成返回，性能损耗可忽略。
// 2、的生命周期并非简单的'只有一行'，它的存活时间会根据上下文被编译器延长，
// 尤其是在函数返回的场景中，例如上面代码的 LogMessage 匿名对象
// 3、这里写日志方法完全可以不重载括号运算符，而是写成一个具体函数如 WriteLog，
// 这样就只在：#define LOG(level) logger.WriteLog(level, __FILE__, __LINE__)
// 需要修改一下调用方法，而重载括号运算符的会更优雅，推荐~
~Logger() {}
private:
std::unique_ptr<LogStrategy> _strategy;
};
// 先定义一个 Logger 对象，后面定义宏会用到
Logger logger;
// 定义调用日志的宏
#define LOG(level) logger(level, __FILE__, __LINE__)
// 定义选择日志模式的宏（也就是选择日志刷新策略）
#define EnableConsoleLogStrategy() logger.EnableConsoleLogStrategy()
#define EnableFileLogStrategy() logger.EnableFileLogStrategy()
//main.cc
#include "Logger.hpp"
#include <unistd.h>
int main() {
// 预处理阶段时 EnableConsoleLogStrategy() 会被宏替换为 logger.EnableConsoleLogStrategy()
EnableConsoleLogStrategy();
// EnableFileLogStrategy();
LOG(LogLevel::ERROR) << "hello world" << 1234 << ", 3.14 " << 'c';
LOG(LogLevel::WARNING) << "hello world" << 1234 << ", 3.14 " << 'c';
LOG(LogLevel::ERROR) << "hello world" << 1234 << ", 3.14 " << 'c';
LOG(LogLevel::ERROR) << "hello world" << 1234 << ", 3.14 " << 'c';
// std::string test = "hello logger";
// // 测试策略 1，显示器写入
// // 智能指针，本质就是对 LogStrategy * 原生指针做了封装
// std::unique_ptr<LogStrategy> logger_ptr = std::make_unique<ConsoleLogStrategy>();
// logger_ptr->SyncLog(GetCurrentTime());
// sleep(1);
// logger_ptr->SyncLog(GetCurrentTime());
// sleep(1);
// logger_ptr->SyncLog(GetCurrentTime());
// sleep(1);
// logger_ptr->SyncLog(GetCurrentTime());
// sleep(1);
// logger_ptr->SyncLog(GetCurrentTime());
// sleep(1);
// // 测试策略 2，文件写入
// // 智能指针，本质就是对 LogStrategy * 原生指针做了封装
// std::unique_ptr<LogStrategy> logger_ptr = std::make_unique<FileLogStrategy>();
// logger_ptr->SyncLog(test);
// logger_ptr->SyncLog(test);
// logger_ptr->SyncLog(test);
// logger_ptr->SyncLog(test);
// logger_ptr->SyncLog(test);
return 0;
}