# V1056. The predefined identifier '__func__' always contains the string 'operator()' inside function body of the overloaded 'operator()'.

The analyzer has detected the '__func__' identifier in the body of the overloaded '()' operator.

Consider the following example:

    class C
    {
      void operator()(void)
      {
        std::cout << __func__ << std::endl;
      }
    };

    void foo()
    {
      C c;
      c();
    }

This code will output the string 'operator()'. This behavior may seem reasonable in code like this, so let's take a look at a less trivial example:

    void foo()
    {
      auto lambda = [] () { return __func__; };
      std::cout << lambda() << std::endl;
    }

It is important to remember that '__func__' is not a typical variable, so the following versions will not work as intended and the program will be still outputting the string 'operator()':

    void fooRef()
    {
      auto lambda = [&] () { return __func__; };
      std::cout << lambda() << std::endl;
    }
    void fooCopy()
    {
      auto lambda = [=] () { return __func__; };
      std::cout << lambda() << std::endl;
    }

In the case of lambdas, this can be fixed by passing '__func__' explicitly using a capture list:

    void foo()
    {
      auto lambda = [func = __func__] () { return func; };
      std::cout << lambda() << std::endl;
    }

To get full-fledged output of the function name even inside the overloaded 'operator()' or lambdas, you can use the platform/compiler-specific macros. The MSVC compiler provides three such macros:

- '__FUNCTION__' – outputs the function name including its namespace. For example, this is what we will get for a lambda inside the main function: 'main::<lambda_....>::operator ()';
- '__FUNCSIG__' – outputs the full function signature. Similarly, it can be helpful when combined with a lambda: 'auto __cdecl main::<lambda_....>::operator ()(void) const';
- '__FUNCDNAME__' – outputs the decorated name of the function. This information is quite specific, so it cannot fully replace '__func__'.

Clang and GCC provide the following macros:

- '__FUNCTION__' – outputs the same name that the standard '__func__' does;
- '__PRETTY_FUNCTION__' – outputs the full function signature. For example, you will get the following output for a lambda: 'auto main()::(anonymous class)::operator()() const'.