C++ 断言与日志

在C++程序开发中，断言和日志记录是两种强大的调试和错误处理工具。它们可以帮助你检测程序中的错误、追踪程序执行流程，以及在出现问题时收集有用的信息。本文将详细介绍如何在C++程序中有效地使用断言和日志。

断言(Assertions)的基础知识

断言是一种运行时检查，用于验证程序中的假设是否成立。如果断言条件为假，程序通常会终止并显示错误信息。

什么是断言？

断言是一种防御性编程的技术，它允许程序员在代码中表达"在这一点上，这个条件必须为真"的思想。如果条件不为真，说明程序中存在bug。

备注

断言通常用于检查那些"绝对不应该发生"的情况，而不是处理正常的错误条件（如文件不存在、网络连接失败等）。

C++ 中的断言类型

C++中有几种不同类型的断言：

静态断言(static_assert)：在编译时检查
运行时断言(assert)：在运行时检查

运行时断言

运行时断言是通过assert宏实现的，它在<cassert>头文件中定义。

基本用法

cpp
#include <cassert>
#include <iostream>

int main() {
    int x = 5;
    
    // 断言 x 是正数
    assert(x > 0);
    std::cout << "x是正数，程序继续执行\n";
    
    x = -1;
    
    // 这个断言会失败
    assert(x > 0);  // 程序将在此处终止
    
    std::cout << "这行代码永远不会执行\n";
    
    return 0;
}

输出：

x是正数，程序继续执行
Assertion failed: (x > 0), function main, file example.cpp, line 13.

当断言失败时，程序会终止，并显示失败的断言条件、函数名、文件名和行号。

禁用断言

在发布版本中，你可能希望禁用断言以提高性能。可以在包含<cassert>之前定义NDEBUG宏来实现这一点：

cpp
#define NDEBUG  // 禁用断言
#include <cassert>

int main() {
    int x = -1;
    assert(x > 0);  // 在NDEBUG模式下，这个断言会被忽略
    return 0;
}

警告

禁用断言会使程序在遇到错误时继续执行，这可能会导致更严重的问题。请谨慎使用此选项。

静态断言

C++11引入了静态断言，它在编译时进行检查，而不是运行时。

cpp
#include <iostream>
#include <type_traits>

template <typename T>
void process(T value) {
    // 编译时检查T是否为整数类型
    static_assert(std::is_integral<T>::value, "T must be an integral type");
    std::cout << "Processing integer: " << value << std::endl;
}

int main() {
    process(42);      // 正常编译
    // process(3.14); // 编译错误：静态断言失败
    return 0;
}

静态断言的优点是它们在编译时就能发现问题，而不需要等到运行时。

C++ 日志

日志记录是捕获程序执行信息的重要手段。它可以帮助你了解程序的执行流程、诊断问题，以及监控程序的行为。

基本日志记录

最简单的日志记录方式是使用std::cout和std::cerr：

cpp
#include <iostream>

int divide(int a, int b) {
    std::cout << "函数 divide 被调用，参数：a=" << a << ", b=" << b << std::endl;
    
    if (b == 0) {
        std::cerr << "错误：除数不能为零！" << std::endl;
        return 0;
    }
    
    int result = a / b;
    std::cout << "计算结果：" << result << std::endl;
    return result;
}

int main() {
    divide(10, 2);
    divide(5, 0);
    return 0;
}

输出：

函数 divide 被调用，参数：a=10, b=2
计算结果：5
函数 divide 被调用，参数：a=5, b=0
错误：除数不能为零！

日志级别

在实际应用中，通常需要不同级别的日志，如调试信息、警告、错误等。可以创建一个简单的日志系统：

cpp
#include <iostream>
#include <string>
#include <ctime>

enum LogLevel {
    DEBUG,
    INFO,
    WARNING,
    ERROR,
    CRITICAL
};

LogLevel currentLogLevel = INFO; // 当前日志级别

void log(LogLevel level, const std::string& message) {
    // 只有当消息级别高于或等于当前设置的级别时才输出
    if (level < currentLogLevel)
        return;
    
    // 获取当前时间
    time_t now = time(0);
    char* dt = ctime(&now);
    dt[strlen(dt) - 1] = '\0'; // 移除换行符
    
    // 级别对应的字符串
    const char* levelStr[] = {"DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"};
    
    // 输出日志
    std::cout << "[" << dt << "] [" << levelStr[level] << "] " << message << std::endl;
}

int main() {
    log(DEBUG, "这是一条调试信息"); // 不会显示，因为级别低于INFO
    log(INFO, "程序已启动");
    log(WARNING, "配置文件未找到，使用默认配置");
    log(ERROR, "无法连接到数据库");
    
    // 改变日志级别
    currentLogLevel = DEBUG;
    log(DEBUG, "现在可以看到调试信息了");
    
    return 0;
}

输出：

[Wed Nov 8 12:34:56 2023] [INFO] 程序已启动
[Wed Nov 8 12:34:56 2023] [WARNING] 配置文件未找到，使用默认配置
[Wed Nov 8 12:34:56 2023] [ERROR] 无法连接到数据库
[Wed Nov 8 12:34:56 2023] [DEBUG] 现在可以看到调试信息了

使用第三方日志库

对于更复杂的需求，可以考虑使用第三方日志库，如spdlog、log4cpp、Boost.Log等。以spdlog为例：

cpp
#include <spdlog/spdlog.h>
#include <spdlog/sinks/basic_file_sink.h>

int main() {
    try {
        // 创建一个基本的文件日志记录器
        auto logger = spdlog::basic_logger_mt("file_logger", "logs/app.log");
        
        // 设置默认记录器
        spdlog::set_default_logger(logger);
        
        // 设置日志级别
        spdlog::set_level(spdlog::level::debug);
        
        // 记录不同级别的消息
        spdlog::debug("这是一条调试消息");
        spdlog::info("这是一条信息消息");
        spdlog::warn("这是一条警告消息");
        spdlog::error("这是一条错误消息");
        spdlog::critical("这是一条严重错误消息");
        
        // 使用格式化（类似printf）
        spdlog::info("用户 {} 登录，IP: {}", "admin", "192.168.1.1");
        
    } catch (const spdlog::spdlog_ex& ex) {
        std::cerr << "日志初始化失败: " << ex.what() << std::endl;
    }
    
    return 0;
}

断言与日志的最佳实践

何时使用断言

检查前置条件：在函数开始处验证参数是否有效
检查后置条件：在函数返回前验证结果是否正确
验证不变量：确保某些属性在整个操作过程中保持不变

cpp
double calculateSquareRoot(double number) {
    // 前置条件
    assert(number >= 0 && "无法计算负数的平方根");
    
    double result = std::sqrt(number);
    
    // 后置条件
    assert((result * result - number) < 0.00001 && "计算结果不准确");
    
    return result;
}

何时使用日志

记录程序流程：启动、关闭、主要步骤完成等
跟踪性能：记录操作耗时
记录错误和异常：包括足够的上下文信息以便调试
记录安全相关事件：登录尝试、权限变更等

cpp
bool processUserLogin(const std::string& username, const std::string& password) {
    log(INFO, "用户 " + username + " 尝试登录");
    
    auto startTime = std::chrono::high_resolution_clock::now();
    bool success = validateCredentials(username, password);
    auto endTime = std::chrono::high_resolution_clock::now();
    
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime);
    
    if (success) {
        log(INFO, "用户 " + username + " 登录成功，耗时 " + 
            std::to_string(duration.count()) + " 毫秒");
    } else {
        log(WARNING, "用户 " + username + " 登录失败，耗时 " + 
            std::to_string(duration.count()) + " 毫秒");
    }
    
    return success;
}

实际案例：使用断言和日志改进程序质量

假设我们正在开发一个简单的银行账户管理系统：

cpp
#include <iostream>
#include <string>
#include <vector>
#include <cassert>

// 简单的日志函数
void log(const std::string& level, const std::string& message) {
    std::cout << "[" << level << "] " << message << std::endl;
}

class BankAccount {
private:
    std::string accountNumber;
    std::string ownerName;
    double balance;
    
public:
    BankAccount(const std::string& accNum, const std::string& name, double initialBalance) 
        : accountNumber(accNum), ownerName(name), balance(initialBalance) {
        // 使用断言验证初始条件
        assert(!accountNumber.empty() && "账号不能为空");
        assert(!ownerName.empty() && "用户名不能为空");
        assert(balance >= 0 && "初始余额不能为负");
        
        log("INFO", "创建账户: " + accountNumber + ", 所有者: " + ownerName + 
                  ", 初始余额: " + std::to_string(balance));
    }
    
    bool deposit(double amount) {
        // 前置条件检查
        if (amount <= 0) {
            log("ERROR", "存款金额必须为正数: " + std::to_string(amount));
            return false;
        }
        
        // 记录操作前的状态
        double oldBalance = balance;
        
        balance += amount;
        
        // 后置条件验证
        assert(balance > oldBalance && "存款后余额应增加");
        
        log("INFO", "账户 " + accountNumber + " 存款: " + std::to_string(amount) + 
                  ", 新余额: " + std::to_string(balance));
        return true;
    }
    
    bool withdraw(double amount) {
        // 前置条件检查
        if (amount <= 0) {
            log("ERROR", "取款金额必须为正数: " + std::to_string(amount));
            return false;
        }
        
        if (amount > balance) {
            log("WARNING", "账户 " + accountNumber + " 余额不足: 请求 " + 
                       std::to_string(amount) + ", 可用 " + std::to_string(balance));
            return false;
        }
        
        // 记录操作前的状态
        double oldBalance = balance;
        
        balance -= amount;
        
        // 后置条件验证
        assert(balance < oldBalance && "取款后余额应减少");
        assert(balance >= 0 && "余额不应为负");
        
        log("INFO", "账户 " + accountNumber + " 取款: " + std::to_string(amount) + 
                  ", 新余额: " + std::to_string(balance));
        return true;
    }
    
    double getBalance() const {
        return balance;
    }
};

int main() {
    try {
        BankAccount account("12345", "张三", 1000);
        
        account.deposit(500);    // 成功
        account.deposit(-100);   // 失败：金额为负
        account.withdraw(300);   // 成功
        account.withdraw(2000);  // 失败：余额不足
        
        log("INFO", "最终余额: " + std::to_string(account.getBalance()));
        
    } catch (const std::exception& e) {
        log("CRITICAL", std::string("发生异常: ") + e.what());
    }
    
    return 0;
}

输出：

[INFO] 创建账户: 12345, 所有者: 张三, 初始余额: 1000.000000
[INFO] 账户 12345 存款: 500.000000, 新余额: 1500.000000
[ERROR] 存款金额必须为正数: -100.000000
[INFO] 账户 12345 取款: 300.000000, 新余额: 1200.000000
[WARNING] 账户 12345 余额不足: 请求 2000.000000, 可用 1200.000000
[INFO] 最终余额: 1200.000000

在这个例子中：

我们使用断言来验证账户创建时的初始条件
使用断言来检查存款和取款操作的后置条件
使用日志记录所有重要操作和错误情况
日志中包含足够的上下文信息，如果出现问题，可以轻松追踪

总结

断言和日志是C++程序开发中不可或缺的调试和错误处理工具：

断言帮助你在开发阶段捕获逻辑错误，确保程序的正确性。
日志帮助你记录程序的执行流程，收集错误信息，方便后期分析和调试。

正确使用这两种工具可以显著提高代码质量和可维护性。记住，断言主要用于开发阶段检查"绝对不应该发生"的情况，而日志则贯穿于程序的整个生命周期。

练习

创建一个简单的矩阵类，使用断言来验证矩阵乘法的前置条件（矩阵维度匹配）。
为一个文件读写程序添加日志系统，记录文件操作的细节和可能出现的错误。
设计一个堆栈数据结构，使用断言来确保pop操作在堆栈非空时才能执行，使用日志记录push和pop操作。
实现一个简单的日志系统，支持不同级别的日志并能将日志写入文件。

断言(Assertions)的基础知识​

什么是断言？​

C++ 中的断言类型​

运行时断言​

基本用法​

禁用断言​

静态断言​

C++ 日志​

基本日志记录​

日志级别​

使用第三方日志库​

断言与日志的最佳实践​

何时使用断言​

何时使用日志​

实际案例：使用断言和日志改进程序质量​

总结​

练习​

延伸阅读​