std::source_location

std::source_location (заголовок <source_location>) — тип, хранящий информацию о конкретном месте в исходном коде: имя файла (.file_name()), номер строки (.line()), номер столбца (.column()) и имя функции (.function_name()). Получают его через статический метод std::source_location::current(), обычно используемый как значение параметра функции по умолчанию — тогда он автоматически заполняется местом ВЫЗОВА этой функции, а не местом её определения.std::source_location (from <source_location>) is a type holding information about a specific point in the source code: the file name (.file_name()), the line number (.line()), the column number (.column()), and the function name (.function_name()). You obtain it via the static method std::source_location::current(), typically used as a function parameter's default value — in that position it automatically fills in with the location of the CALL to that function, not the location of its definition.

#define LOG(msg) log_impl(msg, __FILE__, __LINE__)

void log_impl(std::string_view msg, const char* file, int line);

LOG("hello");
// работает, но требует макроса вместо обычной функции —// works, but needs a macro instead of an ordinary function —
// теряются перегрузки, пространства имён, типобезопасность вызова// losing overloads, namespaces, call-site type safety

void log(std::string_view msg,
         std::source_location loc = std::source_location::current()) {
    std::cout << loc.file_name() << ":" << loc.line() << ": " << msg;
}

log("hello");
// loc заполнится местом ЭТОГО вызова log() — обычная функция,// loc fills in with THIS call site of log() — an ordinary function,
// никакого макроса, перегрузки и пространства имён работают как обычно// no macro, overloads and namespaces work as usual

Макросы __FILE__/__LINE__/__func__ решали задачу диагностики места вызова с самого начала C, но ценой отказа от обычных функций:The __FILE__/__LINE__/__func__ macros had solved the call-site diagnostics problem since the earliest days of C, but at the cost of giving up ordinary functions:

Правило вычисления default-аргументов в C++ обычно таково: выражение по умолчанию подставляется и вычисляется в контексте вызывающего кода, но было бы неверно с точки зрения обычной семантики, если бы current() просто "знал", откуда его вызвали, как обычная функция — на самом деле компилятор обязан специально распознать вызов std::source_location::current() именно в позиции default-аргумента и подставить туда координаты точки вызова функции, к которой этот аргумент относится. Это специальное правило стандарта, а не следствие общей механики компиляции.The usual rule for evaluating default arguments in C++ is that the default expression is substituted and evaluated in the calling code's context — but it would be wrong under ordinary semantics to expect current() to simply "know" where it was called from, like a normal function would. In reality, the compiler is specifically required to recognize a call to std::source_location::current() exactly when it appears in a default-argument position, and substitute the coordinates of the call site of the function that argument belongs to. This is a special standard rule, not a consequence of ordinary compilation mechanics.

#include <source_location>
#include <iostream>

void log(std::string_view msg,
         std::source_location loc = std::source_location::current()) {
    std::cout << loc.file_name() << ":" << loc.line()
              << " in " << loc.function_name() << ": " << msg << "\n";
}

void do_work() {
    log("starting");   // loc укажет на эту строку внутри do_work,// loc points at this line inside do_work,
}                        // а не на строку определения log()// not at log()'s definition line

Тот же механизм часто комбинируют с исключениями — кастомный класс исключения захватывает source_location в момент создания (то есть в точке throw, поскольку конструктор исключения и есть та функция, у которой параметр со значением по умолчанию), и обработчик в catch получает не только текст ошибки, но и точное место, где она была брошена — без ловли исключения сразу на месте броска только ради логирования координат.The same mechanism is often combined with exceptions — a custom exception class captures a source_location at the moment of construction (that is, at the throw site, since the exception's constructor is itself the function with the defaulted parameter), and the handler in catch gets not just the error text but the exact place it was thrown — with no need to catch right at the throw site just to log the coordinates.

class TracedError : public std::runtime_error {
public:
    TracedError(std::string_view msg,
                std::source_location loc = std::source_location::current())
        : std::runtime_error(std::format("{}:{}: {}", loc.file_name(), loc.line(), msg))
        , location_(loc) {}

    const std::source_location& where() const { return location_; }

private:
    std::source_location location_;
};

void validate(int x) {
    if (x < 0) throw TracedError("negative value");  // loc — это место throw, а не конструктора// loc is the throw site, not the constructor's
}

try {
    validate(-1);
} catch (const TracedError& e) {
    std::cerr << "caught at " << e.where().line() << ": " << e.what() << "\n";
}

• cppreference — std::source_location
• WG21 P1208 — Adopt source_location for C++20