What’s the difference between __PRETTY_FUNCTION__, __FUNCTION__, __func__?

by

__func__ is an implicitly declared identifier that expands to a character array variable containing the function name when it is used inside of a function. It was added to C in C99. From C99 §6.4.2.2/1:

The identifier __func__ is implicitly declared by the translator as if, immediately following the opening brace of each function definition, the declaration

static const char __func__[] = "function-name";

appeared, where function-name is the name of the lexically-enclosing function. This name is the unadorned name of the function.

Note that it is not a macro and it has no special meaning during preprocessing.

__func__ was added to C++ in C++11, where it is specified as containing “an implementation-defined string” (C++11 §8.4.1[dcl.fct.def.general]/8), which is not quite as useful as the specification in C. (The original proposal to add __func__ to C++ was N1642).

__FUNCTION__ is a pre-standard extension that some C compilers support (including gcc and Visual C++); in general, you should use __func__ where it is supported and only use __FUNCTION__ if you are using a compiler that does not support it (for example, Visual C++, which does not support C99 and does not yet support all of C++0x, does not provide __func__).

__PRETTY_FUNCTION__ is a gcc extension that is mostly the same as __FUNCTION__, except that for C++ functions it contains the “pretty” name of the function including the signature of the function. Visual C++ has a similar (but not quite identical) extension, __FUNCSIG__.

For the nonstandard macros, you will want to consult your compiler’s documentation. The Visual C++ extensions are included in the MSDN documentation of the C++ compiler’s “Predefined Macros”. The gcc documentation extensions are described in the gcc documentation page “Function Names as Strings.”

More Related Contents:

  1. Why don’t the C or C++ standards explicitly define char as signed or unsigned?
  2. Compiler issue or some bug in code block of c [duplicate]
  3. Why are Standard iterator ranges [begin, end) instead of [begin, end]?
  4. Difference between void main and int main in C/C++? [duplicate]
  5. Constants and compiler optimization in C++
  6. Why will std::sort crash if the comparison function is not as operator
  7. Deprecation of the static keyword… no more?
  8. Is it legal to recurse into main() in C++? [duplicate]
  9. Using Unicode in C++ source code
  10. Is `long` guaranteed to be at least 32 bits?
  11. How to check if C++ compiler uses IEEE 754 floating point standard
  12. How to create a static library with g++?
  13. Are all integer values perfectly represented as doubles? [duplicate]
  14. Why do compilers allow string literals not to be const?
  15. Why is `i = ++i + 1` unspecified behavior?
  16. what is/are the purpose(s) of inline?
  17. Why the sizeof(bool) is not defined to be one, by the Standard itself?
  18. what is “stack alignment”?
  19. When do compilers inline C++ code?
  20. Are there stackless or heapless implementation of C++?
  21. How is static variable initialization implemented by the compiler?
  22. Does new[] call default constructor in C++?
  23. Is it legal to use the increment operator in a C++ function call?
  24. is it ok to specialize std::numeric_limits for user-defined number-like classes?
  25. Is a C++ preprocessor identical to a C preprocessor?
  26. Looking for 16-bit x86 compiler
  27. x86 MUL Instruction from VS 2008/2010
  28. shared_ptr: horrible speed
  29. Can we apply content not explicitly cited from the normative references to the C++ standard?
  30. Fun with uninitialized variables and compiler (GCC)

Leave a Comment