C++开发简单日志记录工具实例-C++-PHP中文网

答案：文章介绍了一个轻量级C++日志工具的设计与实现，涵盖日志级别、线程安全、时间戳、输出格式等核心功能，采用单例模式和std::mutex保证多线程安全，通过宏简化调用接口，并探讨了自研日志在学习、轻量和定制化方面的优势，适用于小型项目或特定环境。

c++开发简单日志记录工具实例

在C++开发中，一个简单但可靠的日志记录工具是调试和理解程序行为的关键。它不是为了替代那些功能强大的第三方库，更多时候，是为了在轻量级项目、特定嵌入式环境，或者仅仅是为了深入理解日志系统原理时，提供一个快速、可控的解决方案。核心在于，我们希望有一个机制，能以可配置的级别，将带有时间戳和上下文的信息，写入文件或控制台，帮助我们追踪代码的执行路径和潜在问题。

解决方案

要构建一个简单的C++日志记录工具，我们可以从一个核心的

Logger

登录后复制

类开始。这个类需要处理日志消息的接收、格式化、写入目标以及线程安全。

一个基本的实现思路是：

定义日志级别：使用枚举类型来区分不同重要程度的日志，例如
```
DEBUG
```
登录后复制
,
```
INFO
```
登录后复制
,
```
WARN
```
登录后复制
,
```
ERROR
```
登录后复制
,
```
FATAL
```
登录后复制
。
日志输出目标：通常是文件和/或控制台。我们需要一个
```
std::ofstream
```
登录后复制
来写入文件，而
```
std::cout
```
登录后复制
或
```
std::cerr
```
登录后复制
用于控制台。
线程安全：在多线程环境中，多个线程可能同时尝试写入日志，这会引发数据竞争。
```
std::mutex
```
登录后复制
是解决这个问题的直接方式。
时间戳：每条日志都应该包含一个时间戳，以便追溯事件发生的时间。
```
std::chrono
```
登录后复制
库是获取当前时间的好选择。
格式化：日志消息需要被格式化成易读的字符串，包含时间、级别和实际消息。

这是一个简化的

Logger

登录后复制

类结构：

立即学习“C++免费学习笔记（深入）”；

#include <iostream>
#include <fstream>
#include <string>
#include <chrono>
#include <ctime>
#include <iomanip>
#include <mutex>
#include <sstream>

enum LogLevel {
    DEBUG,
    INFO,
    WARN,
    ERROR,
    FATAL
};

class Logger {
public:
    static Logger& getInstance() {
        static Logger instance;
        return instance;
    }

    void setLogFile(const std::string& filename) {
        std::lock_guard<std::mutex> lock(mtx_);
        if (logFile_.is_open()) {
            logFile_.close();
        }
        logFile_.open(filename, std::ios_base::app); // Append mode
        if (!logFile_.is_open()) {
            std::cerr << "Error: Could not open log file " << filename << std::endl;
        }
    }

    void setLogLevel(LogLevel level) {
        currentLogLevel_ = level;
    }

    void log(LogLevel level, const std::string& message) {
        if (level < currentLogLevel_) {
            return; // Filter out messages below current log level
        }

        std::lock_guard<std::mutex> lock(mtx_); // Ensure thread safety for writing

        std::string formattedMessage = formatLogMessage(level, message);

        // Write to console
        std::cout << formattedMessage << std::endl;

        // Write to file if open
        if (logFile_.is_open()) {
            logFile_ << formattedMessage << std::endl;
        }
    }

private:
    Logger() : currentLogLevel_(INFO) {} // Default log level
    ~Logger() {
        if (logFile_.is_open()) {
            logFile_.close();
        }
    }

    // Prevent copy and assignment
    Logger(const Logger&) = delete;
    Logger& operator=(const Logger&) = delete;

    std::string formatLogMessage(LogLevel level, const std::string& message) {
        auto now = std::chrono::system_clock::now();
        auto in_time_t = std::chrono::system_clock::to_time_t(now);

        std::stringstream ss;
        ss << std::put_time(std::localtime(&in_time_t), "%Y-%m-%d %H:%M:%S")
           << " [" << logLevelToString(level) << "] "
           << message;
        return ss.str();
    }

    std::string logLevelToString(LogLevel level) {
        switch (level) {
            case DEBUG: return "DEBUG";
            case INFO:  return "INFO ";
            case WARN:  return "WARN ";
            case ERROR: return "ERROR";
            case FATAL: return "FATAL";
            default:    return "UNKNOWN";
        }
    }

    std::ofstream logFile_;
    LogLevel currentLogLevel_;
    std::mutex mtx_;
};

// Convenience macros for logging
#define LOG_DEBUG(msg) Logger::getInstance().log(DEBUG, msg)
#define LOG_INFO(msg)  Logger::getInstance().log(INFO, msg)
#define LOG_WARN(msg)  Logger::getInstance().log(WARN, msg)
#define LOG_ERROR(msg) Logger::getInstance().log(ERROR, msg)
#define LOG_FATAL(msg) Logger::getInstance().log(FATAL, msg)

// Example usage:
// int main() {
//     Logger::getInstance().setLogFile("app.log");
//     Logger::getInstance().setLogLevel(DEBUG);
//
//     LOG_INFO("Application started.");
//     LOG_DEBUG("This is a debug message.");
//     LOG_WARN("Something might be wrong here.");
//     LOG_ERROR("An error occurred!");
//
//     // Simulate a fatal error
//     // LOG_FATAL("Critical system failure, shutting down.");
//     return 0;
// }

登录后复制

这个

Logger

登录后复制

类采用了单例模式，确保全局只有一个日志实例，方便在程序任何地方调用。通过

setLogFile

登录后复制

设置日志文件，

setLogLevel

登录后复制

控制输出的详细程度。宏定义则提供了更简洁的日志接口。

自己开发日志工具的优势与适用场景

很多人会问，市面上已经有Log4cpp、spdlog这些成熟且功能强大的日志库，为什么我们还要花时间“造轮子”呢？这确实是个好问题，答案往往不在于“更好”，而在于“更适合”和“学习价值”。

从我个人的经验来看，自己开发一个简单的日志工具，有几个明显的优势：

首先，学习和理解。日志系统本身就是一个涉及文件IO、多线程同步、时间处理、字符串格式化等多个C++核心知识点的综合实践。亲手实现一遍，能让你对这些底层机制有更深刻的理解，这远比直接调用API来得扎实。这种“造轮子”的过程，其实是最好的学习过程。

其次，轻量级和无依赖。对于一些小型项目、嵌入式系统或者对第三方库依赖有严格限制的场景，引入一个庞大的日志框架可能显得过于沉重。那些框架往往带有复杂的配置、大量的模板代码和潜在的性能开销。而一个自己编写的简单日志工具，可以做到极致的轻量，只包含核心功能，没有外部依赖，编译体积小，启动速度快。我曾在一个资源受限的IoT设备上，就是用这种方式实现了日志记录，效果非常好。

再者，高度定制化。虽然成熟库提供了丰富的配置选项，但在某些极端特殊的需求下，它们可能仍然无法完全满足。例如，你可能需要一个非常独特的日志格式，或者需要将日志输出到某个特定的自定义存储介质（比如内存环形缓冲区、网络接口），甚至需要根据运行时环境动态调整日志行为。自己编写的工具，可以完全按照项目需求进行定制，拥有绝对的控制权。

当然，这并不意味着要完全抛弃现有库。对于大型、复杂的项目，追求极致性能、丰富功能（如异步日志、日志轮转、多种Sink）和经过充分测试的稳定性时，选择一个成熟的第三方库无疑是更明智的选择。自己造轮子，更像是一种特定场景下的优化选择，或者是一种提升自身技术能力的手段。

多线程环境下日志记录的线程安全保障

在多线程应用程序中，日志记录的线程安全是一个不可忽视的关键点。如果多个线程同时尝试向同一个日志文件或控制台写入数据，很可能会导致输出混乱、日志消息交错，甚至程序崩溃。这就像多个人同时往一个本子上写字，结果就是一团糟。

解决这个问题，最直接也是最常用的方法就是使用互斥锁（

std::mutex

登录后复制

）。

其核心思想是：在任何线程尝试写入日志之前，它必须先获得一个全局的互斥锁。如果锁已经被其他线程持有，当前线程就会被阻塞，直到锁被释放。一旦当前线程获得了锁，它就可以安全地执行日志写入操作。完成写入后，线程会释放锁，允许其他等待的线程继续。

简单听记

百度网盘推出的一款AI语音转文字工具

269

查看详情

在C++中，

std::mutex

登录后复制

配合

std::lock_guard

登录后复制

或

std::unique_lock

登录后复制

是实现这一机制的推荐方式：

#include <mutex> // Include for std::mutex and std::lock_guard

class Logger {
    // ... other members ...
private:
    std::ofstream logFile_;
    std::mutex mtx_; // Declare a mutex member
    // ... other members ...

public:
    void log(LogLevel level, const std::string& message) {
        // ... log level filtering ...

        // Use std::lock_guard to automatically acquire and release the mutex
        // The lock is acquired when lock_guard is constructed, and released when it goes out of scope
        std::lock_guard<std::mutex> lock(mtx_); 

        std::string formattedMessage = formatLogMessage(level, message);

        // Safe to write to console and file now
        std::cout << formattedMessage << std::endl;
        if (logFile_.is_open()) {
            logFile_ << formattedMessage << std::endl;
        }
    }
    // ... rest of the class ...
};

登录后复制

std::lock_guard<std::mutex> lock(mtx_);

登录后复制

这一行代码是关键。它在构造时会自动锁定

mtx_

登录后复制

，并在

log

登录后复制

函数退出（无论是正常返回还是抛出异常）时，通过析构函数自动解锁

mtx_

登录后复制

。这大大简化了错误处理，避免了忘记解锁导致死锁的问题。

当然，这种基于互斥锁的同步方式会引入一定的性能开销，尤其是在日志量非常大、且多线程竞争激烈的情况下，锁的争用可能会成为瓶颈。在这种情况下，可以考虑更高级的异步日志方案。异步日志通常会将日志消息先写入一个线程安全的队列，然后由一个独立的日志线程从队列中取出消息并写入文件。这样，应用程序的主线程可以快速地将日志消息放入队列后继续执行，而不会被文件I/O操作阻塞。不过，对于一个“简单”的日志工具而言，

std::mutex

登录后复制

提供的同步方案已经足够有效和易于实现了。

日志级别与输出格式的设计考量

在设计日志工具时，日志级别和输出格式的选择并非随意，它们直接影响到日志的可用性、可读性和排查问题的效率。这需要我们在信息量、易读性和解析便利性之间找到一个平衡点。

日志级别：精细化与实用性的平衡

日志级别旨在区分日志消息的重要性或详细程度。一个设计得当的日志级别系统，能够帮助开发者快速筛选出关注的信息。

我通常会采用以下标准级别：

DEBUG (调试)：最详细的日志信息，通常只在开发和调试阶段开启。它记录了程序执行的每一步细节，变量值等。生产环境中一般会关闭。
INFO (信息)：程序运行的关键节点信息，例如服务启动、关键操作完成、用户登录等。这些信息通常是程序正常运行的指示。
WARN (警告)：可能存在潜在问题，但程序仍能继续运行的情况。例如，配置文件缺失（但有默认值）、资源即将耗尽等。这些往往是需要关注和排查的信号。
ERROR (错误)：程序执行过程中发生的错误，导致某个功能无法正常完成，但程序整体可能仍在运行。例如，文件读写失败、数据库连接中断。
FATAL (致命)：非常严重的错误，导致程序无法继续运行，必须立即终止。例如，内存分配失败、核心组件初始化失败。

在设计时，一个常见的陷阱是定义过多的级别，导致开发者在选择时感到困惑。5到7个级别通常是比较理想的范围，既能满足精细化需求，又不会过于复杂。同时，日志工具应支持配置最低输出级别，例如在生产环境中只输出

INFO

登录后复制

、

WARN

登录后复制

、

ERROR

登录后复制

和

FATAL

登录后复制

，而在开发环境中可以开启

DEBUG

登录后复制

。

输出格式：可读性与解析性的权衡

日志的输出格式决定了我们如何“消费”这些信息。一个好的格式应该兼顾人类阅读的便利性和机器解析的可能性。

对于一个“简单”的日志工具，我倾向于优先考虑人类可读性，因为它的主要用途是快速定位问题。一个典型的、易于阅读的格式通常包含以下元素：

时间戳：精确到秒或毫秒，这是日志的“时间轴”。例如：
```
2023-10-27 14:35:01.234
```
登录后复制
日志级别：明确指出消息的重要性。例如：
```
[INFO]
```
登录后复制
线程ID（可选）：在多线程应用中，了解是哪个线程产生的日志非常有用。例如：
```
[Thread-0x1234]
```
登录后复制
源文件/行号（可选）：直接指向代码中的日志点，极大地加速问题定位。例如：
```
(main.cpp:42)
```
登录后复制
日志消息：实际的描述性文本。

将这些元素组合起来，一个典型的日志行可能看起来像这样：

2023-10-27 14:35:01.234 [INFO ] [Thread-0x1234] (main.cpp:42) Application started successfully.

登录后复制

在实现格式化时，可以使用

std::stringstream

登录后复制

和

std::put_time

登录后复制

来构建字符串。

#include <chrono>
#include <ctime>
#include <iomanip> // For std::put_time
#include <sstream>

std::string formatLogMessage(LogLevel level, const std::string& message) {
    auto now = std::chrono::system_clock::now();
    auto in_time_t = std::chrono::system_clock::to_time_t(now);

    std::stringstream ss;
    ss << std::put_time(std::localtime(&in_time_t), "%Y-%m-%d %H:%M:%S") // Year-Month-Day Hour:Minute:Second
       << " [" << logLevelToString(level) << "] " // Log Level
       // For source file/line, you'd typically use __FILE__ and __LINE__ macros
       // << "(" << file << ":" << line << ") " 
       << message; // The actual message
    return ss.str();
}

登录后复制

如果需要包含源文件和行号，通常需要在宏定义中传递

__FILE__

登录后复制

和

__LINE__

登录后复制

：

#define LOG_INFO(msg) Logger::getInstance().log(INFO, __FILE__, __LINE__, msg)
// Then modify the log method to accept file and line
// void log(LogLevel level, const char* file, int line, const std::string& message);

登录后复制

对于更高级的场景，例如需要日志被日志分析工具（如ELK Stack）解析，可能会考虑JSON或其他结构化格式。但对于“简单”工具，这种需求通常不是首要考虑。在设计日志格式时，始终记住其最终目的是为了帮助开发者更快、更准确地理解程序行为，并解决问题。

以上就是C++开发简单日志记录工具实例的详细内容，更多请关注php中文网其它相关文章！