手写一个线程安全的 C++ 日志库

文件输出策略

文件写入同样需要互斥，同时要注意目录创建和文件追加模式。这里用到了 C++17 的 <filesystem> 特性来处理路径。

#include <fstream>
#include <filesystem>

namespace log_lib {

const std::string Default_Path = "./log/";
const std::string Default_Name = "Log.txt";

class Refresh_to_file : public Strategy_Pattern {
public:
    Refresh_to_file(const std::string &Path = Default_Path,
                    const std::string &Name = Default_Name)
        : _Default_Path(Path), _Default_Name(Name) {
        pthread_mutex_init(&_mutex, nullptr);
        pthread_mutex_lock(&_mutex);
        if (std::filesystem::exists(_Default_Path)) {
            pthread_mutex_unlock(&_mutex);
            return;
        }
        try {
            std::filesystem::create_directories(_Default_Path);
        } catch (std::filesystem::filesystem_error &e) {
            std::cerr << e.what() << "\n";
        }
        pthread_mutex_unlock(&_mutex);
    }

    void Log_refresh_mode(const std::string &message) override {
        pthread_mutex_lock(&_mutex);
        std::string log = _Default_Path + _Default_Name;
        std::ofstream out(log, std::ios::app);
        if (!out.is_open()) {
            pthread_mutex_unlock(&_mutex);
            return;
        }
        out << message << std::endl;
        out.close();
        pthread_mutex_unlock(&_mutex);
    }

    ~Refresh_to_file() {
        pthread_mutex_destroy(&_mutex);
    }

private:
    pthread_mutex_t _mutex;
    std::string _Default_Path;
    std::string _Default_Name;
};
}

日志类封装与宏定义

有了具体的输出策略，接下来就是核心的 Log 类。它负责管理当前使用的策略指针，并提供便捷的接口。

#include <memory>
#include <sstream>
#include <chrono>
#include <unistd.h>

namespace log_lib {

enum class LogLevel { DEBUG, INFO, WARNING, ERROR, FATAL };

// 辅助函数：将等级转为字符串（实际项目中可完善）
inline const char* LogLevelToStr(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";
    }
}

// 获取当前时间字符串
inline std::string GetCurrtime() {
    auto now = std::chrono::system_clock::now();
    auto time = std::chrono::system_clock::to_time_t(now);
    char buf[32];
    strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", localtime(&time));
    return std::string(buf);
}

class Log {
public:
    class LogMessage {
    public:
        LogMessage(std::string filename, LogLevel level, int line, Log &logger)
            : _filename(filename), _line(line), _loglevel(level),
              _currtime(GetCurrtime()), _pid(getpid()), _logger(logger) {
            std::stringstream ssbuffer;
            ssbuffer << "[" << _currtime << "] [" << LogLevelToStr(_loglevel) << "]"
                     << "[" << _pid << "][" << _filename << "][" << _line << "] - ";
            _loginfo = ssbuffer.str();
        }

        template<class T>
        LogMessage& operator<<(const T& data) {
            std::stringstream ss;
            ss << data;
            _loginfo += ss.str();
            return *this;
        }

        ~LogMessage() {
            if (_logger._Strategy) {
                _logger._Strategy->Log_refresh_mode(_loginfo);
            }
        }

    private:
        std::string _filename;
        LogLevel _loglevel;
        std::string _currtime;
        pid_t _pid;
        int _line;
        std::string _loginfo;
        Log &_logger;
    };

    // 默认构造函数，初始化屏幕输出策略
    Log() {
        _Strategy = std::make_shared<Refresh_to_screen>();
    }

    // 重载 () 运算符，构建临时 LogMessage 对象
    LogMessage operator()(LogLevel level, const std::string filename, int line) {
        return LogMessage(filename, level, line, *this);
    }

    // 切换输出到文件
    void RefreshToFile() {
        _Strategy = std::make_shared<Refresh_to_file>();
    }

    // 切换输出到屏幕
    void RefreshToScreen() {
        _Strategy = std::make_shared<Refresh_to_screen>();
    }

private:
    std::shared_ptr<Strategy_Pattern> _Strategy;
};

} // namespace log_lib

// 全局日志实例
log_lib::Log logger;

// 定义宏，简化调用
#define LOG(Level) logger(Level, __FILE__, __LINE__)

使用示例

通过宏定义，我们可以像写普通语句一样记录日志，既保留了流式操作的灵活性，又自动注入了时间、文件、行号等关键信息。

int main() {
    // 默认输出到屏幕
    LOG(log_lib::LogLevel::INFO) << "程序启动成功";
    LOG(log_lib::LogLevel::DEBUG) << "变量值：" << 42;

    // 切换到文件输出
    logger.RefreshToFile();
    LOG(log_lib::LogLevel::ERROR) << "发生严重错误，请检查配置";

    return 0;
}

运行后，你会看到类似这样的输出格式：

[2024-08-04 12:27:03][DEBUG][202938][main.cc][16]- hello world

这种结构化的日志不仅方便人类阅读，也更容易被自动化监控工具解析。通过这种方式，我们不仅摆脱了 printf 的局限，还获得了一个可扩展、线程安全的基础日志框架。