The most effective debugging trick in C/C is using the built-in macros __FILE__, __LINE__, and __FUNCTION__ to get precise error context. 1. __FILE__ provides the current source file’s path as a string. 2. __LINE__ gives the current line number as an integer. 3. __FUNCTION__ (non-standard but widely supported) or __func__ (standard C 11) returns the enclosing function’s name. These compile-time constants allow detailed logging with no runtime overhead, making it easy to trace crashes or invalid states. They are especially useful when writing custom assertions, debugging without a debugger, or working in legacy or embedded systems. For better reuse, wrap them in macros like DEBUG_LOG() or ASSERT(). Be cautious with inlining, as it may affect __FUNCTION__’s accuracy, and prefer __func__ for stricter portability. Using these tools consistently saves debugging time and requires no external dependencies.

When debugging C (or C) code, one of the simplest yet most effective tricks is leveraging the built-in preprocessor macros __LINE__, __FILE__, and __FUNCTION__. These aren't functions or variables — they’re compile-time constants automatically filled in by the compiler, giving you pinpoint context about where something went wrong.

Why These Macros Matter

Imagine you're tracing a crash, a failed assertion, or an unexpected state deep in your code. Printing generic messages like "Error occurred" doesn’t help much. But if you log:

std::cerr << "Error at " << __FILE__ << ":" << __LINE__ 
          << " in " << __FUNCTION__ << std::endl;

Suddenly, you know exactly which file, which line, and which function triggered the issue — no guessing, no hunting through logs.

These macros are especially useful when:

• You're writing low-level debugging logs
• You're building custom assertions
• You're working in environments without a debugger
• You're maintaining legacy or embedded systems

How Each Macro Works

• __FILE__ → Expands to a string literal of the current source file’s full path (e.g., "src/utils.cpp")
• __LINE__ → Expands to an integer constant representing the current line number
• __FUNCTION__ → A non-standard but widely supported identifier that holds the name of the enclosing function (note: it's not a macro, but a static const char[] in C )

Example:

void processData(int value) {
    if (value < 0) {
        std::cerr << "Invalid input detected\n"
                  << "  File: " << __FILE__ << "\n"
                  << "  Line: " << __LINE__ << "\n"
                  << "  Func: " << __FUNCTION__ << std::endl;
    }
}

Output:

Invalid input detected
  File: src/main.cpp
  Line: 42
  Func: processData

Practical Tips for Better Debugging

• Wrap in a macro for reuse:

  #define DEBUG_LOG() \
      std::cerr << "Debug: " << __FILE__ << ":" << __LINE__ \
                << " in " << __FUNCTION__ << std::endl

  Then sprinkle it where needed:

  DEBUG_LOG(); // Quick trace point

• Combine with assertions:

  #define ASSERT(cond) \
      do { \
          if (!(cond)) { \
              std::cerr << "Assertion failed: " #cond "\n" \
                        << "  At " << __FILE__ << ":" << __LINE__ \
                        << " in " << __FUNCTION__ << std::endl; \
              std::abort(); \
          } \
      } while(0)

  Now you get rich context on failure.

• Watch out for inlining:
  If a function is inlined, __FUNCTION__ will reflect the caller’s function in some contexts — be aware when debugging deeply nested or optimized code.

• Compiler differences:
  While __FILE__ and __LINE__ are standard, __FUNCTION__ is implementation-specific. For stricter portability, consider __func__ (C 11), which is a local static variable available in every function:

  void foo() {
      std::cout << "Now in: " << __func__ << std::endl; // Standard C  11
  }

  Note: __func__ isn't a macro, so you can't stringize it with #, but it’s reliable and standard.

  Bottom Line

  You don’t need a fancy logging framework to get actionable debug info. With __LINE__, __FILE__, and __FUNCTION__ (or __func__), you add zero-cost, precise context to diagnostics. They’re always available, require no setup, and save hours when tracking down bugs.

  Basically, if you're not using them already — start now. It’s debugging 101, but often overlooked.

  The above is the detailed content of Pinpoint-Accurate Debugging with __LINE__, __FILE__, and __FUNCTION__. For more information, please follow other related articles on the PHP Chinese website!