How to use std::source_location from C 20 for better logging?

Use std::source_location::current() as the default parameter to automatically capture the file name, line number and function name of the call point; 2. You can simplify log calls through macros such as #define LOG(msg) log(msg, std::source_location::current()); 3. You can expand the log content with log level, timestamp and other information; 4. To optimize performance, function names can be omitted or location information can be disabled in the release version; 5. Details such as column() are rarely used, but are available. Using std::source_location can significantly increase the debugging value of logs with extremely low overhead, eliminating the need to manually pass FILE or __LINE__, allowing the compiler to automatically complete context capture, enabling more efficient and clear diagnostic output.

std::source_location in C 20 is a lightweight utility that captures information about the source code's context—like file name, line number, function name, and column—at the point where it's used. It's incredibly useful for improving logging by automatically including diagnostic context without requiring manual input.

Here's how to use std::source_location effectively for better logging.

1. Include and Capture Source Location Automatically

std::source_location is defined in the <source_location></source_location> header (C 20). It's a constexpr -friendly class that captures location info at the call site when used with default arguments.

 #include <iostream>
#include <string_view>
#include <source_location>

void log(std::string_view message,
         std::source_location location = std::source_location::current())
{
    std::cout << location.file_name() << ":"
              << location.line() << " "
              << location.function_name() << "() - "
              << message << &#39;\n&#39;;
}

Now when you call log("Something happened"); , the file, line, and function are captured automatically.

Example usage:

 void my_function() {
    log("Debug message"); // Automatically prints file, line, function
}

Output might look like:

 main.cpp:15 my_function() - Debug message

2. Use in Macros for Cleaner Logging

To avoid passing source_location manually every time, wrap the logging in a macro—though with C 20, you often don't need macros thanks to default parameter capture.

But if you want a clean interface (eg, LOG("msg") ), a macro helps:

 #define LOG(msg) log(msg, std::source_location::current())

// Usage
LOG("Error occurred");

This ensures the location is captured at the macro call site, not inside the log function.

Note: Since std::source_location::current() is a built-in compiler intrinsic, the macro isn't strictly necessary, but it makes the syntax cleaner and more familiar.

3. Customize Log Format and Add Extra Context

You can extend the logger to include timestamps, log levels, or custom tags.

 enum class LogLevel {
    Debug,
    Info,
    Warning,
    Error
};

void log(LogLevel level, std::string_view message,
         std::source_location loc = std::source_location::current())
{
    const char* level_str[] = {"DEBUG", "INFO", "WARNING", "ERROR"};

    std::cout << "[" << level_str[static_cast<int>(level)] << "] "
              << loc.file_name() << ":" << loc.line() << " "
              << loc.function_name() << " - "
              << message << &#39;\n&#39;;
}

Usage:

 log(LogLevel::Warning, "Value out of range");

Output:

 [WARNING] config.cpp:42 parse_config() - Value out of range

4. Optimize for Performance

std::source_location is lightweight, but capturing function names (which may include full signatures and templates) can be expensive in terms of binary size or performance.

If you don't need the function name, skip it:

 std::cout << loc.file_name() << ":" << loc.line();

Or, use conditional compilation to disable location info in release builds:

 #ifdef DEBUG
    auto loc = std::source_location::current();
    std::cout << loc.file_name() << ":" << loc.line() << " ";
#else
    std::cout << "[debug info disabled] ";
#endif

Alternatively, design your logging system so that debug-level logs (with full location) are compiled out when not needed.

5. Capture Column and Other Details (Rarely Used)

std::source_location also provides column() and file_name() / function_name() as const char* . Column is rarely useful but available.

 std::cout << "Column: " << loc.column() << &#39;\n&#39;; // Usually 1 or not very meaningful

Most compilers set column to the start of the statement, so it's not commonly used.

Summary

• Use std::source_location::current() as a default function parameter to auto-capture location.
• Avoid macros if you're OK with plain function calls; otherwise, use them for cleaner syntax.
• Include file, line, and function in logs to speed up debugging.
• Be mindful of performance and binary bloat from long function names.
• Combine with log levels and formatting for production-ready logging.

Using std::source_location makes logging more informative with almost zero effort—no more manually writing __FILE__ or __LINE__ . It's a small feature with a big impact on debuggability.

Basically, just add it to your logging function and let the compiler do the rest.

The above is the detailed content of How to use std::source_location from C 20 for better logging?. For more information, please follow other related articles on the PHP Chinese website!