C++ `std::source_location`：C++20 获取调用栈与调试信息

好的，各位观众老爷们，欢迎来到今天的C++旮旯技术分享会。今天咱要聊的是C++20里一个相当实用的小玩意儿：std::source_location。这玩意儿能帮我们获取代码的“案发现场”信息，让调试和日志记录变得更爽。准备好了吗？系好安全带，咱们发车啦！

一、啥是std::source_location？

简单来说，std::source_location就是一个记录代码行号、文件名、函数名等信息的类。有了它，我们就能在程序运行时知道某段代码是在哪个文件的哪一行，哪个函数里被执行的。这对于定位问题、理解代码执行流程非常有帮助。

想象一下，你写了一个复杂的程序，跑起来之后出了bug。调试的时候，你需要在茫茫代码中大海捞针，找bug的根源。有了std::source_location，就像给代码装了一个GPS，能告诉你“我在哪里，我是谁，我从哪里来”。

二、std::source_location的基本用法

std::source_location的使用非常简单。它提供了一个静态成员函数current()，可以获取当前代码位置的信息。

#include <iostream>
#include <source_location>

void log_message(const std::string& message, const std::source_location& location = std::source_location::current()) {
    std::cout << "File: " << location.file_name() << std::endl;
    std::cout << "Line: " << location.line() << std::endl;
    std::cout << "Function: " << location.function_name() << std::endl;
    std::cout << "Message: " << message << std::endl;
    std::cout << "---------------------" << std::endl;
}

void some_function() {
    log_message("This is a message from some_function.");
}

int main() {
    log_message("This is a message from main.");
    some_function();
    return 0;
}

在这个例子中，log_message函数接受一个消息和一个std::source_location对象作为参数。std::source_location的默认值是std::source_location::current()，也就是调用log_message时的代码位置。

运行结果大概是这样：

File: main.cpp
Line: 17
Function: main
Message: This is a message from main.
---------------------
File: main.cpp
Line: 13
Function: some_function
Message: This is a message from some_function.
---------------------

可以看到，log_message函数成功地输出了调用它的代码的文件名、行号和函数名。

三、std::source_location的成员函数

std::source_location提供了几个成员函数，用于获取代码位置的不同信息：

成员函数	返回值类型	描述
file_name()	const char*	返回包含调用位置的文件名。
line()	int	返回调用位置的行号。
column()	int	返回调用位置的列号。（有些编译器可能不支持，返回0）
function_name()	const char*	返回包含调用位置的函数名。（如果编译器支持，返回 demangled 的函数名）

四、std::source_location的实际应用

std::source_location在实际开发中有很多用处，下面列举几个常见的场景：

1. 日志记录

   在日志记录中，std::source_location可以帮助我们快速定位日志消息的来源。

   #include <iostream>
   #include <fstream>
   #include <source_location>
   
   void log_error(const std::string& message, const std::source_location& location = std::source_location::current()) {
      std::ofstream log_file("error.log", std::ios::app);
      if (log_file.is_open()) {
          log_file << "[" << location.file_name() << ":" << location.line() << "] "
                   << location.function_name() << ": " << message << std::endl;
          log_file.close();
      } else {
          std::cerr << "Error: Unable to open log file." << std::endl;
      }
   }
   
   void do_something_dangerous() {
      try {
          // Some code that might throw an exception
          throw std::runtime_error("Something went wrong!");
      } catch (const std::exception& e) {
          log_error(e.what());
      }
   }
   
   int main() {
      do_something_dangerous();
      return 0;
   }

   在这个例子中，log_error函数将错误消息和代码位置信息写入到error.log文件中。这样，当程序出现错误时，我们可以快速找到错误发生的地点。

2. 断言

   在断言中，std::source_location可以提供更详细的错误信息。

   #include <iostream>
   #include <source_location>
   #include <stdexcept>
   
   void my_assert(bool condition, const std::string& message, const std::source_location& location = std::source_location::current()) {
      if (!condition) {
          throw std::runtime_error("Assertion failed: " + message +
                                     " at " + location.file_name() + ":" + std::to_string(location.line()) +
                                     " in " + location.function_name());
      }
   }
   
   int main() {
      int x = 5;
      my_assert(x > 10, "x should be greater than 10."); // This will throw an exception
      return 0;
   }

   当断言失败时，会抛出一个包含文件名、行号和函数名的异常，方便我们定位问题。

3. 性能分析

   在性能分析中，std::source_location可以帮助我们统计每个函数的执行次数和时间。

   #include <iostream>
   #include <chrono>
   #include <map>
   #include <source_location>
   
   std::map<std::string, int> function_call_counts;
   std::map<std::string, std::chrono::microseconds> function_execution_times;
   
   class FunctionTimer {
   public:
      FunctionTimer(const std::source_location& location = std::source_location::current())
          : location_(location), start_(std::chrono::high_resolution_clock::now()) {
      }
   
      ~FunctionTimer() {
          auto end = std::chrono::high_resolution_clock::now();
          auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start_);
          std::string function_name = location_.function_name();
   
          function_call_counts[function_name]++;
          function_execution_times[function_name] += duration;
      }
   
   private:
      std::source_location location_;
      std::chrono::time_point<std::chrono::high_resolution_clock> start_;
   };
   
   void some_expensive_function() {
      FunctionTimer timer; // Starts the timer
   
      // Simulate some work
      for (int i = 0; i < 1000000; ++i) {
          // Do something
      }
   }
   
   int main() {
      {
          FunctionTimer timer; // Starts the timer for main
   
          some_expensive_function();
          some_expensive_function();
      } // timers are destroyed when exiting scope
   
      // Print the results
      for (const auto& pair : function_call_counts) {
          std::cout << "Function: " << pair.first << ", Calls: " << pair.second << std::endl;
          std::cout << "  Total Time: " << function_execution_times[pair.first].count() << " microseconds" << std::endl;
      }
   
      return 0;
   }

   在这个例子中，FunctionTimer类使用std::source_location来记录函数的名称，并在析构函数中统计函数的执行次数和时间。

4. AOP（面向切面编程）

   可以利用std::source_location 实现简单的AOP。例如，在函数执行前后自动记录日志。

   #include <iostream>
   #include <source_location>
   
   class FunctionTracer {
   public:
      FunctionTracer(const std::source_location& location = std::source_location::current())
          : location_(location) {
          std::cout << "Entering function: " << location_.function_name() << std::endl;
      }
   
      ~FunctionTracer() {
          std::cout << "Exiting function: " << location_.function_name() << std::endl;
      }
   
   private:
      std::source_location location_;
   };
   
   void my_function() {
      FunctionTracer tracer; // Tracks entry and exit
   
      std::cout << "Inside my_function" << std::endl;
   }
   
   int main() {
      FunctionTracer tracer; // Tracks entry and exit of main
   
      my_function();
      return 0;
   }

   运行结果：

   Entering function: main
   Entering function: my_function
   Inside my_function
   Exiting function: my_function
   Exiting function: main

五、std::source_location的注意事项

• C++20标准：std::source_location是C++20引入的，所以需要使用支持C++20的编译器。
• 编译器支持：std::source_location的某些功能，如column()和function_name()，可能需要编译器的支持。如果编译器不支持，可能会返回默认值或空字符串。
• 性能影响：虽然std::source_location的开销很小，但在性能敏感的代码中，还是需要注意避免过度使用。

六、std::source_location与宏

在std::source_location出现之前，我们通常使用宏来获取代码位置信息。例如：

#define LOG_MESSAGE(message) 
    std::cout << "File: " << __FILE__ << std::endl; 
    std::cout << "Line: " << __LINE__ << std::endl; 
    std::cout << "Function: " << __FUNCTION__ << std::endl; 
    std::cout << "Message: " << message << std::endl; 
    std::cout << "---------------------" << std::endl;

虽然宏也能实现类似的功能，但它存在一些缺点：

• 可读性差：宏的代码可读性较差，难以维护。
• 类型安全：宏没有类型检查，容易出错。
• 调试困难：宏在预处理阶段展开，调试时难以跟踪。

std::source_location可以克服这些缺点，提供更安全、更易于使用的代码位置信息获取方式。

七、更高级的用法：自定义source_location

虽然大多数情况下 std::source_location::current() 已经足够，但有时候我们可能需要传递一些额外信息，或者以不同的方式格式化输出。 这时候，我们可以自定义一个类来包装 std::source_location。

#include <iostream>
#include <source_location>

class MySourceLocation {
public:
    MySourceLocation(const std::source_location& loc = std::source_location::current(), const std::string& context = "")
        : location(loc), context_info(context) {}

    void print() const {
        std::cout << "File: " << location.file_name() << std::endl;
        std::cout << "Line: " << location.line() << std::endl;
        std::cout << "Function: " << location.function_name() << std::endl;
        std::cout << "Context: " << context_info << std::endl;
    }

private:
    std::source_location location;
    std::string context_info;
};

void some_function() {
    MySourceLocation loc(std::source_location::current(), "Important Function");
    loc.print();
}

int main() {
    MySourceLocation loc;
    loc.print();
    some_function();
    return 0;
}

在这个例子中，MySourceLocation 类包装了 std::source_location，并添加了一个 context_info 成员，用于存储额外的上下文信息。 这样，我们就可以在输出代码位置信息的同时，输出一些自定义的信息。

八、总结

std::source_location是C++20中一个非常实用的工具，它可以帮助我们获取代码位置信息，方便调试、日志记录和性能分析。虽然它不是解决所有问题的银弹，但在很多场景下，它可以大大提高我们的开发效率。

希望今天的分享对大家有所帮助。记住，代码就像侦探小说，std::source_location就是你的放大镜，帮你找到隐藏在代码背后的真相！

各位观众老爷，今天的分享就到这里，咱们下期再见！ 散花！