Get function name programmatically in C language

　 Just to get the function name, embedding a hard-coded string in the function body is tedious and can easily lead to errors. Let’s take a look at how to use the new C99 features to get the function name when the program is running.

　Object reflection libraries, debugging tools and code analyzers often need to access the name of a function at runtime. Until recently, the only portable way to accomplish this task was to manually embed a function with the name in the function body. Hard-coded strings for function names. Needless to say, this approach is very tedious and can easily lead to errors. This article will demonstrate how to use the new C99 feature to obtain function names at runtime.

　So how to programmatically get the function name from the currently running function?

　The answer is: use __FUNCTION__ and related macros.

　　Causing questions

　 Often, the most frustrating phase of debugging is constantly checking to see if a specific function has been called. The solution to this problem is usually to add a cout or PRintf() - if you use C language, as follows:

void myfunc()
{
cout<<"myfunc()"<< endl;
//Other code
}
Usually in a typical project, there will be thousands of functions. It will undoubtedly be difficult to add such an output statement to each function. Therefore, There needs to be a mechanism that can do this automatically.

　Get function name

　As a C++ programmer, you may often encounter macros such as __TIME__, __FILE__, and __DATE__. They will be converted into characters containing the compilation time, the name of the conversion unit processed, and the current time during compilation. string.

In the latest ISO C standard, known as C99, another useful macro-like expression __func__ has been added, which will report the unmodified (that is, uncropped), being The name of the function to be accessed. Note that __func__ is not a macro, since the preprocessor knows nothing about this function; instead, it is implemented as an implicitly declared constant character array:

static const char __func__[] = "function- name";
　At function-name, it is the actual function name. To activate this feature, some compilers require specific compilation flags, please check the corresponding compiler documentation for specific information.

　 With it, we can avoid most of the drudgery of manual modification to display function names. The above example can be rewritten as follows:

void myfunc()
{
cout<<"__FUNCTION__ "<}
　The __func__ identifier defined by the official C99 standard for this purpose is indeed worthy of everyone's attention. However, ISO C++ does not fully support all C99 extensions. Therefore, most compilers provide Business owners use __FUNCTION__ instead, and __FUNCTION__ is usually a macro defined as __func__. This name is used because it is widely supported by most.

　In Visual Studio 2005, this feature is activated by default, but cannot be used with the /EP and /P compile options. Please note that in the IDE environment, __func__ cannot be recognized and must be replaced by __FUNCTION__.

　 Comeau users should also use __FUNCTION__ instead of __func__ .

　 C++ BuilderX users should use a slightly different name: __FUNC__.

　 GCC 3.0 and higher support both __func__ and __FUNCTION__ .

Once the current function name can be automatically obtained, you can define a function that displays any function name as follows:

void show_name(const char * name)
{
cout<}

void myfunc()
{
show_name(__FUNCTION__); ​​//Output: myfunc
}

void foo()
{
show_name(__FUNCTION__); ​​//Output: foo
}
Because __FUNCTION__ will be in function braces It is initialized immediately after starting, so the foo() and myfunc() functions can safely use it in the parameter list without worrying about overloading.

　Signatures and Modified Names

　The __FUNCTION__ feature was originally designed for the C language. However, C++ programmers will often need additional information about their functions. In Visual Studio 2005, two other non-standard extension features are also supported. : __FUNCDNAME__ and __FUNCSIG__, which are translated into the modified name and signature of a function respectively. Modified names of functions are very useful, for example, if you want to check whether two compilers share the same ABI. In addition, it can also help you solve those obscure link errors and even use It calls another function from a DLL linked in C++. In the following example, show_name() reports the modified name of the function:

void myfunc()
{
show_name(__FUNCDNAME__); //Output: ?myfunc@@YAXXZ
}
The signature of a function consists of the function name, parameter list, return type, and included namespace. If it is a member function, its class name and const/volatile qualifier will also be part of the signature. The following code demonstrates the difference between the signatures of an independent function and a const member function. The names, return types, and parameters of the two functions are exactly the same:

void myfunc()
{
show_name(__FUNCSIG__); // void __cdecl myfunc(void)
}

strUCt S
{
void myfunc() const
{
show_name(__FUNCSIG__); //void __thiscall S::myfunc(void) const

}
};

That’s it Get the content of the function name programmatically in C language. For more related articles, please pay attention to the PHP Chinese website (www.php.cn)!