C++ 中的 std::clog() 函数

2025 年 5 月 14 日 | 阅读 15 分钟

引言

在 C++ 标准库中，std::clog 是一个预定义的输出流，专门用于记录诊断和信息性消息。它是 I/O 流家族的一部分，该家族还包括 std::cin、std::cout 和 std::cerr 等常用流。std::clog 声明在 <iostream> 头文件中，是一种将消息写入标准错误流 (stderr) 或任何其他位置（如另一个文件或网络套接字）的便捷方式。

与 std::cout 不同，std::clog 是一个缓冲流，输出到控制台。std::cerr 是非缓冲的，立即将输出发送到控制台。它会将输出收集并存储在缓冲区中，并以块而不是逐个字符的方式进行输出，从而减少 I/O 操作。这种缓冲机制使得 std::clog 在性能关键型应用程序中更有效，特别是在记录大量数据或在需要减少系统调用的环境中。

std::clog 的主要用例是在应用程序运行时记录事件、错误、警告和状态消息。开发人员通常在调试阶段使用它来跟踪程序流程、检查变量值或找出任何问题。在生产环境中，std::clog 用于实时系统监控，管理员可以在不干扰主输出的情况下查看程序的运行情况。

std::clog 的一个显著特点是其灵活性。默认情况下，它会写入标准错误流，但使用 rdbuf() 可以轻松重定向。例如，日志消息可以写入文件，这样您就可以将消息定向到执行的持久记录，就像在需要大量运行的应用程序（如服务器应用程序或长时间运行的进程）中一样。

目的和用例

std::clog 的主要目的是设计一个健壮、高效的机制，用于在程序运行时记录事件、错误、警告和诊断信息。日志记录是一项重要的程序，用于跟踪程序行为，而开发人员和管理员则致力于记录问题并维护系统健康。

开发人员可以通过输出信息（例如变量值、执行流程和系统状态）来逐步跟踪程序的运行情况。这使您能够找出程序中可能存在的错误、性能瓶颈或未被发现的异常行为。例如，std::cout 用于面向用户的消息，而 std::clog 可用于非最终用户评估的后端日志，这使其成为内部诊断非常有用的工具。

在生产环境中，std::clog 是系统监控和活动跟踪的关键组成部分。您可以使用它来记录实时系统事件、状态更新和错误报告。例如，在大型应用程序（如 Web 服务器、数据库或企业软件）中，管理员可以使用 std::clog 跟踪导致系统崩溃或行为异常的事件序列。他们可以检查日志，了解问题发生的时间和地点，从而确保快速解决问题和减少停机时间。

好处

std::clog 的一个关键特性是它使用缓冲输出，通过在写入数据之前对数据进行分组来提高效率。与 std::clog 不同，它有一个缓冲区，并将每个字符成批写入，而 std::cerr 是非缓冲的，立即将每个字符写入输出设备。通过这种缓冲，I/O 操作的频率显著减少，这在生成大量日志数据时可能成为性能瓶颈。

通过最小化系统调用，std::clog 提高了整体性能，使其适用于高频率日志记录场景。这对于监视大规模系统或高效捕获详细跟踪日志等任务尤其有用。默认情况下，std::clog 写入标准错误流 (stderr)，通常是控制台。然而，它最强大的特性之一是其重定向的灵活性。可以使用 rdbuf() 方法将输出流引导到其他输出设备。例如，重定向 std::clog 允许开发人员保留程序执行的永久记录，用于审计、调试或生产系统的长期监控。

这种性能、灵活性以及与常规输出分离的结合，使得 std::clog 成为一个用途广泛、应用广泛的日志记录工具，从简单的调试到复杂的系统监控。

方法 1：基本控制台日志记录

使用 std::clog 进行基本控制台日志记录是一种简单而强大的技术，用于在程序运行时将诊断消息实时写入控制台。此方法在开发和调试阶段特别有用，因为它允许开发人员快速验证程序流程、监视变量值和跟踪执行状态，而不会弄乱标准输出 (std::cout)。

与 std::clog 不同，它是内部消息流，并且由于是 std 命名空间的一部分，因此通常不会与用于面向用户消息的典型 std::cout 流冲突。它允许您将操作日志与用户交互分开，使日志更具可读性和可维护性。此外，由于 std::clog 是缓冲的，但它比非缓冲流更适合频繁日志记录，并减少了不必要的 I/O 操作。

对于需要实时反馈的项目，例如新代码测试和中小型项目的操作跟踪，这是一个好方法。

程序

让我们以一个例子来说明 C++ 中 std::clog() 函数。

 
#include <iostream>
#include <vector>
#include <string>
#include <map>
// A structure to hold user information
struct User {
    std::string name;
    std::string accountNumber;
    double balance;
};
// A class to simulate a simple banking system
class BankingSystem {
private:
    std::map<std::string, User> users;
public:
    // Register a new user
    bool registerUser(const std::string& name, const std::string& accountNumber, double initialDeposit) {
        std::clog << "[INFO] Registering new user: " << name << " with account number: " << accountNumber << std::endl;
        if (users.find(accountNumber) != users.end()) {
            std::clog << "[ERROR] Account number already exists: " << accountNumber << std::endl;
            return false;
        }
        if (initialDeposit < 0) {
            std::clog << "[WARNING] Initial deposit is negative: " << initialDeposit << std::endl;
            return false;
        }
        User newUser{name, accountNumber, initialDeposit};
        users[accountNumber] = newUser;
        std::clog << "[SUCCESS] User registered successfully: " << name << std::endl;
        return true;
    }
    // Display user details
    void displayUserDetails(const std::string& accountNumber) {
        std::clog << "[INFO] Retrieving details for account: " << accountNumber << std::endl;
        if (users.find(accountNumber) == users.end()) {
            std::clog << "[ERROR] Account not found: " << accountNumber << std::endl;
            return;
        }
        User user = users[accountNumber];
        std::cout << "User: " << user.name << ", Account Number: " << user.accountNumber << ", Balance: $" << user.balance << std::endl;
    }
    // Deposit money into an account
    bool deposit(const std::string& accountNumber, double amount) {
        std::clog << "[INFO] Processing deposit for account: " << accountNumber << std::endl;
        if (amount <= 0) {
            std::clog << "[WARNING] Invalid deposit amount: " << amount << std::endl;
            return false;
        }
        if (users.find(accountNumber) == users.end()) {
            std::clog << "[ERROR] Account not found for deposit: " << accountNumber << std::endl;
            return false;
        }
        users[accountNumber].balance += amount;
        std::clog << "[SUCCESS] Deposit successful. New balance: $" << users[accountNumber].balance << std::endl;
        return true;
    }
    // Withdraw money from an account
    bool withdraw(const std::string& accountNumber, double amount) {
        std::clog << "[INFO] Processing withdrawal for account: " << accountNumber << std::endl;
        if (amount <= 0) {
            std::clog << "[WARNING] Invalid withdrawal amount: " << amount << std::endl;
            return false;
        }
        if (users.find(accountNumber) == users.end()) {
            std::clog << "[ERROR] Account not found for withdrawal: " << accountNumber << std::endl;
            return false;
        }
        if (users[accountNumber].balance < amount) {
            std::clog << "[ERROR] Insufficient balance for account: " << accountNumber << std::endl;
            return false;
        }
        users[accountNumber].balance -= amount;
        std::clog << "[SUCCESS] Withdrawal successful. New balance: $" << users[accountNumber].balance << std::endl;
        return true;
    }
    // Transfer money between two accounts
    bool transfer(const std::string& fromAccount, const std::string& toAccount, double amount) {
        std::clog << "[INFO] Initiating transfer from " << fromAccount << " to " << toAccount << " for $" << amount << std::endl;
        if (fromAccount == toAccount) {
            std::clog << "[WARNING] Transfer to the same account is not allowed: " << fromAccount << std::endl;
            return false;
        }
        if (!withdraw(fromAccount, amount)) {
            std::clog << "[ERROR] Transfer failed during withdrawal phase." << std::endl;
            return false;
        }
        if (!deposit(toAccount, amount)) {
            std::clog << "[ERROR] Transfer failed during deposit phase. Rolling back withdrawal." << std::endl;
            deposit(fromAccount, amount);  // Rollback
            return false;
        }
        std::clog << "[SUCCESS] Transfer completed successfully." << std::endl;
        return true;
    }
};
int main() {
    std::clog << "[INFO] Banking system started." << std::endl;
    BankingSystem bank;
    // Registering users
    bank.registerUser("Alice", "ACC123", 1000.0);
    bank.registerUser("Bob", "ACC124", 500.0);
    bank.registerUser("Charlie", "ACC125", 300.0);
    // Display user details
    bank.displayUserDetails("ACC123");
    bank.displayUserDetails("ACC124");
    // Depositing money
    bank.deposit("ACC123", 200);
    bank.deposit("ACC126", 100);  // Invalid account
    // Withdrawing money
    bank.withdraw("ACC123", 500);
    bank.withdraw("ACC123", 1000);  // Insufficient balance
    // Transferring money
    bank.transfer("ACC123", "ACC124", 300);
    bank.transfer("ACC124", "ACC125", 700);  // Insufficient balance
    bank.transfer("ACC124", "ACC124", 100);  // Same account transfer
    // Displaying final details
    bank.displayUserDetails("ACC123");
    bank.displayUserDetails("ACC124");
    bank.displayUserDetails("ACC125");
    std::clog << "[INFO] Banking system terminated." << std::endl;
    return 0;
}   

输出

 
[INFO] Banking system started.
[INFO] Registering new user: Alice with account number: ACC123
[SUCCESS] User registered successfully: Alice
[INFO] Registering new user: Bob with account number: ACC124
[SUCCESS] User registered successfully: Bob
[INFO] Registering new user: Charlie with account number: ACC125
[SUCCESS] User registered successfully: Charlie
[INFO] Retrieving details for account: ACC123
User: Alice, Account Number: ACC123, Balance: $1000
[INFO] Retrieving details for account: ACC124
User: Bob, Account Number: ACC124, Balance: $500
[INFO] Processing deposit for account: ACC123
[SUCCESS] Deposit successful. New balance: $1200
[INFO] Processing deposit for account: ACC126
[ERROR] Account not found for deposit: ACC126
[INFO] Processing withdrawal for account: ACC123
[SUCCESS] Withdrawal successful. New balance: $700
[INFO] Processing withdrawal for account: ACC123
[ERROR] Insufficient balance for account: ACC123
[INFO] Initiating transfer from ACC123 to ACC124 for $300
[INFO] Processing withdrawal for account: ACC123
[SUCCESS] Withdrawal successful. New balance: $400
[INFO] Processing deposit for account: ACC124
[SUCCESS] Deposit successful. New balance: $800
[SUCCESS] Transfer completed successfully.
[INFO] Initiating transfer from ACC124 to ACC125 for $700
[INFO] Processing withdrawal for account: ACC124
[SUCCESS] Withdrawal successful. New balance: $100
[INFO] Processing deposit for account: ACC125
[SUCCESS] Deposit successful. New balance: $1000
[SUCCESS] Transfer completed successfully.
[INFO] Initiating transfer from ACC124 to ACC124 for $100
[WARNING] Transfer to the same account is not allowed: ACC124
[INFO] Retrieving details for account: ACC123
User: Alice, Account Number: ACC123, Balance: $400
[INFO] Retrieving details for account: ACC124
User: Bob, Account Number: ACC124, Balance: $100
[INFO] Retrieving details for account: ACC125
User: Charlie, Account Number: ACC125, Balance: $1000
[INFO] Banking system terminated.

解释

用户结构

User 结构保存每个用户的基本信息：姓名、账号和余额。

BankingSystem 类

此类使用 std::map 管理用户，其中 accountNumber 是键，User 对象是值。并将其作为键提供。

方法

registerUser：它将简单地注册一个新用户，验证是否可以创建该账号以及初始存款是否为非负数。
displayUserDetails：它通过按账号过滤来显示用户的姓名、账号和余额。
deposit：它允许通过接受有效存款金额的检查以及用户账户的存在来向用户账户存款。
withdraw：它通过检查账户内的资金可用性以及提款金额大于零来允许取款。
transfer：它有助于将资金从一个账户转移到另一个账户（检查账户是否有效、是否有足够的资金进行转账以及不在同一个账户中）。

主函数

模拟与银行系统的交互。它注册 3 个用户，显示他们的详细信息，进行存款和转账，以及失败场景（无效账户或余额不足），包括成功和失败的案例。

日志记录：虽然代码中提供了对注册、错误、存款、提款和转账等操作的扩展反馈，但这主要是通过使用 std::clog 来实现的。

错误处理

它处理错误，例如重复的账号、无效的存款/提款金额、资金不足以及在处理事务时无效的账户。

复杂度分析

时间复杂度

registerUser：对于将用户插入 std::map，时间复杂度为 O(1)（平均情况）。在最坏的情况下，由于 std::map 的平衡树结构，时间复杂度可能为 O(log N)，其中 N 是用户数。
displayUserDetails：时间复杂度为 O(1)，因为它只是直接在 map 中查找账号。
deposit：时间复杂度为 O(1)，它搜索 map 然后进行简单的加法。
Withdraw：操作也为 O(1)，因为它执行 map 查找以找到账户并在减去金额之前检查余额是否足够。
transfer：检查和执行提款和存款操作都需要 O(1) 的时间。但是，如果提款或存款失败，操作也将花费 O(1) 的时间。
最坏情况复杂度：在 std::map 操作由于底层树结构而更复杂的情况下，复杂度为 O(log N)。

空间复杂度

它的运行时间为 O(N)，其中 N 是系统中的用户数。这是因为 std::map 存储用户数据，并且消耗的空间与用户数量成线性关系。
我们为每个用户支付的费用与 User 结构的大小（存储姓名、账号和余额）成正比，这是恒定的。由于我们在 map 中存储的用户数量决定了空间复杂度，因此空间复杂度主要由用户数量决定。

方法 2：错误和警告的条件日志记录

错误和警告的条件日志记录是提高程序的可观测性和可调试性的绝佳方法。在运行软件时，可能会出现多种情况，软件需要应对，特别是无效的用户输入、资源限制、系统意外行为和网络故障。在这种情况下，记录错误和警告有助于开发人员更有效地跟踪问题并快速修复。

使用 std::clog 是一种简单有效的方法，因为它允许程序将消息发送到标准错误输出流。但是，为了避免日志充斥不必要的消息，应有条件地进行日志记录。这意味着日志应仅在特定情况下生成，例如遇到错误、无效数据、无法交付资源或无法从现有文件中读取。

这样，开发人员就能看到有价值的反馈，而不会收到大量无用信息的垃圾邮件。通过条件日志记录，我们可以跟踪代码中更可能出现的问题，例如用户输入验证、分配资源、与系统级交互。此外，它还有助于生成在屏幕上显示良好并且包含有价值信息的日志，用于调试或在生产环境中优化程序性能。

程序

让我们再举一个例子来说明 C++ 中 std::clog() 函数。

 
#include <iostream>
#include <string>
#include <limits>
#include <cstdlib>
#include <ctime>
// Function to log error messages with conditional checks
void logError(const std::string& message) {
    std::clog << "[ERROR] " << message << std::endl;
}
// Function to log warning messages with conditional checks
void logWarning(const std::string& message) {
    std::clog << "[WARNING] " << message << std::endl;
}
// Function to log informational messages
void logInfo(const std::string& message) {
    std::clog << "[INFO] " << message << std::endl;
}
// Function to simulate user input validation
bool validateUserInput(int input) {
    if (input < 0) {
        logError("Invalid input: negative values are not allowed.");
        return false;
    }
    if (input == 0) {
        logWarning("Input is zero, this may cause issues later.");
    }
    return true;
}
// Function to simulate resource constraints (e.g., memory)
bool checkResources() {
    // Randomly simulate low memory condition
    srand(time(0));
    int resourceStatus = rand() % 2;  // 0 or 1 (randomly simulate resource availability)
    if (resourceStatus == 0) {
        logError("System resources are low. Operation cannot proceed.");
        return false;
    }
    logInfo("System resources are sufficient.");
    return true;
}
// Function to perform some action, demonstrating conditional logging
void performAction(int userInput) {
    logInfo("Starting action...");

    // Validate user input
    if (!validateUserInput(userInput)) {
        return;  // Abort action if input is invalid
    }
    // Check system resources before proceeding
    if (!checkResources()) {
        return;  // Abort action if resources are insufficient
    }
    // Simulate performing the action
    logInfo("Action performed successfully.");
}
// Main function to simulate various operations
int main() {
    // Start of the program
    logInfo("Program started.");
    int userInput;
    // Example: Get user input with conditional logging
    std::cout << "Enter a positive integer: ";
    std::cin >> userInput;
    // Handle invalid input (non-numeric entries)
    if (std::cin.fail()) {
        logError("Invalid input: non-numeric value entered.");
        std::cin.clear();  // Clear the error flag
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');  // Ignore bad input
        return 1;  // Exit program due to invalid input
    }
    // Perform some action based on the input
    performAction(userInput);
    // End of the program
    logInfo("Program finished.");
    return 0;
}   

输出

 
[INFO] Program started.
Enter a positive integer: 384748
[INFO] Starting action...
[ERROR] System resources are low. Operation cannot proceed.
[INFO] Program finished.

解释

日志函数

这些函数 logError()、logWarning() 和 logInfo() 用于将消息类型作为前缀打印到控制台。

logError(const std::string& message)：记录错误消息，表示会阻止程序正常执行的问题。
logWarning(const std::string& message)：记录警告消息，表示非关键问题。这些不会停止程序，但开发人员应注意它们。
logInfo(const std::string& message)：记录信息性消息，用于跟踪程序的正常流程并提供有用的上下文。

用户输入验证

validateUserInput() 是一个验证用户输入的函数。
如果输入为负数，则函数会记录错误消息：“不允许负值”。此后，程序将返回 false，并停止进一步执行。
如果输入为 0，则会记录警告：“这可能会导致后续问题 - 输入为零。”
如果输入有效（正数且非零），程序将继续执行，否则函数将返回 true。

模拟资源检查

checkResources() 函数模拟资源检查，例如可用内存或系统容量。
使用随机数来随机模拟低资源。如果此数字为 0，则会记录错误：“系统资源不足。操作无法继续。”
如果资源充足（通过非零数字模拟），则会记录一条信息性消息：“系统资源充足。”

执行操作

程序可以调用 performAction() 函数，该函数将在输入有效且有足够资源的情况下执行某些任务。
validateUserInput() 函数在执行任务之前验证输入。
之后，下一个系统调用 checkResources() 来检查系统资源。如果资源不足，它也会立即返回，因此操作不会发生。
如果两个条件都满足，则操作成功执行，并生成一条信息性日志：“已成功执行操作。”

主函数

main 函数通过记录程序开始的消息：“程序已启动。”来开始执行。
之后，它提示用户输入一个正整数。如果输入为非数字，如果查询失败（通过 std::cin.fail() 检测到），则可以执行适当的错误处理。将记录错误消息，程序将以失败状态退出。
程序通过调用 performAction() 来检查输入和系统资源，如果输入有效，则根据结果有条件地提供消息。
之后，程序在完成执行时记录短语“程序结束”。

复杂度分析

时间复杂度

带有验证检查的 main 函数定义了时间复杂度。以下是明细：

logError()、logWarning()、logInfo() 函数

这些日志函数仅使用 std::ostream 操作将消息输出到 std::clog。打印字符串的长度是打印字符串的复杂度。然而，对于此分析，我们认为每个日志函数的时间复杂度为 O(1)，因为日志操作的输出大小与输入大小无关，并且日志消息的长度是恒定的。

validateUserInput()

此函数执行一次负数检查，然后执行一次零检查。这两者都是常数时间操作。

此函数花费线性时间，因为它只有一些条件检查，没有循环或递归调用，因此其时间复杂度为 O(1)。

checkResources()

此函数调用一个资源检查函数，该函数生成一个随机数，并根据该数字记录一条消息。生成随机数的复杂度为 O(1)，（基于结果的）日志记录也为 O(1)。

performAction()

它首先调用 validateUserInput() 函数，然后调用 checkResources()。由于我们没有循环或递归调用，performAction() 函数的时间复杂度为 O(1)，因为这两者都是 O(1) 操作。

主函数

main 函数执行以下操作：

所有上述操作都是顺序执行的（因此，我们可以首先想象它们），并且所有操作都具有恒定的时间复杂度，但 main 函数的时间复杂度为 O(1)。

空间复杂度

程序执行期间使用的内存量决定了空间复杂度。

日志记录

logError()、logWarning()、logInfo() 会将消息记录到输出，但它们不会在内存中保存任何数据。因此，日志记录的空间复杂度为 O(1)。

用户输入

一个字符串或整数被存储为用户输入。这里输入是一个变量，占用 O(1) 空间。

资源检查

为了模拟低资源，资源检查会生成一个随机数，并占用恒定的空间。这也被视为 O(1)。

辅助变量

它使用少量辅助变量（字符串、整数等）来存储用户输入和其他值，这些值不会随着输入大小而增长。因此，它们占用 O(1) 空间。

下一主题C++ 中 N 坐标的独立对之间的最大曼哈顿距离

C++ 中的 std::clog() 函数

引言

目的和用例

好处

方法 1：基本控制台日志记录

程序

解释

复杂度分析

方法 2：错误和警告的条件日志记录

程序

解释

复杂度分析

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

C++ 教程

C++ 控制语句

C++ 函数

C++ 数组

C++ 类和对象

C++ 构造函数

C++ 继承

C++ 多态

C++ 抽象

C++ 命名空间

C++ 模板

C++ 字符串

C++ 指针

信号处理

C++ 异常

C++ 文件与流

C++ STL 教程

面试题

选择题

C++ 程序

C++ STL Stack

C++ STL Bitset

C++ STL Deque

C++ STL List

C++ STL Map

C++ STL Math

C++ STL priority_queue

C++ STL Queue

C++ STL Multiset

C++ STL Multimap

C++ STL Set

C++ STD Strings

C++ STL Vector

C++ 操纵符

C++ STL Algorithms

C++ Algorithm

C++ Iterators

C++ 杂项

C++ 中的 std::clog() 函数

引言

目的和用例

好处

方法 1：基本控制台日志记录

程序

解释

复杂度分析

方法 2：错误和警告的条件日志记录

程序

解释

复杂度分析

相关帖子

C++ 替代方案

C++ 代码计算数组的局部极值

C++ 埃及分数贪心算法

C++ 中的维思序列

C++ 缓存无关算法

C++ 中的库尔森数

C++ 封装索引

C++ Jarvis March 算法

C++ 中的粒子群优化