Jaka jest różnica między funkcją, funkcją, func?

Pomimo Nie pełnej odpowiedzi na pierwotne pytanie, to jest prawdopodobnie to, co większość ludzi googlujących to chciał zobaczyć.

Dla GCC:

$ cat test.cpp 
#include <iostream>

int main(int argc, char **argv)
{
    std::cout << __func__ << std::endl
              << __FUNCTION__ << std::endl
              << __PRETTY_FUNCTION__ << std::endl;
}
$ g++ test.cpp 
$ ./a.out 
main
main
int main(int, char**)

__PRETTY_FUNCTION__ obsługuje funkcje C++: klasy, przestrzenie nazw, szablony i przeciążenia

Main.cpp

#include <iostream>

namespace N {
    class C {
        public:
            template <class T>
            static void f(int i) {
                (void)i;
                std::cout << "__func__            " << __func__ << std::endl
                          << "__FUNCTION__        " << __FUNCTION__ << std::endl
                          << "__PRETTY_FUNCTION__ " << __PRETTY_FUNCTION__ << std::endl;
            }
            template <class T>
            static void f(double f) {
                (void)f;
                std::cout << "__PRETTY_FUNCTION__ " << __PRETTY_FUNCTION__ << std::endl;
            }
    };
}

int main() {
    N::C::f<char>(1);
    N::C::f<void>(1.0);
}

Skompiluj i uruchom:

g++ -ggdb3 -O0 -std=c++11 -Wall -Wextra -pedantic -o main.out main.cpp
./main.out

Wyjście:

__func__            f
__FUNCTION__        f
__PRETTY_FUNCTION__ static void N::C::f(int) [with T = char]
__PRETTY_FUNCTION__ static void N::C::f(double) [with T = void]

Możesz być również zainteresowany śladami stosu z nazwami funkcji: Drukuj stos wywołań w C lub C++

Testowane w Ubuntu 19.04, GCC 8.3.0.

C++20 std::source_location::function_name

Http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1208r5.pdf poszedł do C++20, więc mamy jeszcze inny sposób.

Dokumentacja mówi:

Constexpr const char * function_name () const noexcept;

6 zwraca: jeśli obiekt ten reprezentuje pozycję w ciele funkcji, zwraca zdefiniowane w implementacji NTB, które powinny odpowiadać nazwa funkcji. W przeciwnym razie zwraca pusty łańcuch.

Gdzie NTBS oznacza "null zakończony Łańcuch bajtowy".

Spróbuję kiedy wsparcie dotrze do GCC, GCC 9.1.0 z g++-9 -std=c++2a nadal nie wesprzyj to.

Https://en.cppreference.com/w/cpp/utility/source_location claims usage will be like:

#include <iostream>
#include <string_view>
#include <source_location>
 
void log(std::string_view message,
         const std::source_location& location std::source_location::current()
) {
    std::cout << "info:"
              << location.file_name() << ":"
              << location.line() << ":"
              << location.function_name() << " "
              << message << '\n';
}
 
int main() {
    log("Hello world!");
}

Możliwe wyjście:

info:main.cpp:16:main Hello world!

Więc zauważ, jak to zwraca informacje o wywołującym i dlatego jest idealne do użycia w logowaniu, Zobacz także: czy istnieje sposób, aby uzyskać nazwę funkcji wewnątrz funkcji C++?

__func__ jest udokumentowany w standardzie C++0x w sekcji 8.4.1. W tym przypadku jest to predefiniowana zmienna lokalna funkcji o postaci:

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

Gdzie" nazwa funkcji " jest implementacją specfic. Oznacza to, że za każdym razem, gdy deklarujesz funkcję, kompilator doda tę zmienną niejawnie do twojej funkcji. To samo dotyczy __FUNCTION__ i __PRETTY_FUNCTION__. Pomimo wielkich liter, nie są to makra. Chociaż {[2] } jest dodatkiem do C++0x

g++ -std=c++98 ....

Będzie nadal kompilować kod używając __func__.

__PRETTY_FUNCTION__ i __FUNCTION__ są udokumentowane tutaj http://gcc.gnu.org/onlinedocs/gcc-4.5.1/gcc/Function-Names.html#Function-Names. __FUNCTION__ to tylko inna nazwa __func__. __PRETTY_FUNCTION__ jest tym samym co __func__ W C, ale w C++ zawiera również sygnaturę typu.

Dla tych, którzy zastanawiają się, jak to idzie w VS.

MSVC 2015 Update 1, cl.wersja exe 19.00.24215.1:

#include <iostream>

template<typename X, typename Y>
struct A
{
  template<typename Z>
  static void f()
  {
    std::cout << "from A::f():" << std::endl
      << __FUNCTION__ << std::endl
      << __func__ << std::endl
      << __FUNCSIG__ << std::endl;
  }
};

void main()
{
  std::cout << "from main():" << std::endl
    << __FUNCTION__ << std::endl
    << __func__ << std::endl
    << __FUNCSIG__ << std::endl << std::endl;

  A<int, float>::f<bool>();
}

Wyjście:

from main():
main
main
int __cdecl main(void)

from A::f():
A<int,float>::f
f
void __cdecl A<int,float>::f&ltbool>(void)

Użycie __PRETTY_FUNCTION__ powoduje, zgodnie z oczekiwaniami, nierejestrowany błąd identyfikatora.