Wie können wir den Namen der aufrufenden Funktion erfahren?

In der C-Sprache __FUNCTION__ kann verwendet werden, um die zu erhalten aktuell Funktionsname. Aber wenn ich eine Funktion namens a() definiere und sie in b() aufgerufen wird, wie unten:

b()
{
    a();
}

Nun, im Quellcode gibt es viele Funktionen wie b(), die a() aufrufen, zB c(), d(), e()…

Ist es möglich, innerhalb von a() Code hinzuzufügen, um den Namen der Funktion zu erkennen, die a() aufgerufen hat?

Des Weiteren:

1. Sorry für den irreführenden Tippfehler. Ich habe es korrigiert.
2. Ich versuche herauszufinden, welche Funktion a() zu Debugging-Zwecken aufruft. Ich weiß nicht, wie es dir geht, wenn du in der gleichen Situation bist?
3. Und mein Code ist unter vxWorks, aber ich bin mir nicht sicher, ob er mit C99 oder etwas anderem zusammenhängt.

Es gibt nichts, was Sie nur in a tun können.

Mit einem einfachen Standard-Makrotrick können Sie jedoch erreichen, was Sie wollen, IIUC zeigt den Namen des Anrufers an.

void a()
{
    /* Your code */
}

void a_special( char const * caller_name )
{
    printf( "a was called from %s", caller_name );
    a();
}

#define a() a_special(__func__)

void b()
{
    a();
}

Sie können dies mit einem integrierten gcc tun.

void * __builtin_return_address(int level)

Der folgende Weg sollte den unmittelbaren Aufrufer einer Funktion a() ausgeben.

Beispiel:

a() {
    printf ("Caller name: %pS\n", __builtin_return_address(0));
}

Wenn Sie ein Linux-System verwenden, können Sie die verwenden backtrace() Funktion.

Siehe die Manpage für weitere Details und ein Codebeispiel.

Versuche dies:

void a(<all param declarations to a()>);

#ifdef DEBUG
#  define a(<all params to a()>) a_debug(<all params a()>, __FUNCTION__)
void a_debug(<all params to a()>, const char * calledby);
#endif

void b(void)
{
  a(<all values to a()>);
}

#ifdef DEBUG
#  undef a
#endif

void a(<all param declarations to a()>)
{
  printf("'%s' called\n", __FUNCTION__);
}

#ifdef DEBUG
void a_debug(<all param declarations to a()>, const char * calledby)
{
  printf("'%s' calledby '%s'", __FUNCTION__, calledby);
  a(<all params to a()>);
}
#endif

Wenn zum Beispiel <all param declarations to a()> ist int i, double d, void * p dann <all params to a()> ist i, d, p.

Oder (weniger böse ;->> – aber mehr Code-Modding, da jeder Aufruf von a() berührt werden muss):

void a((<all params of normal a()>    
#ifdef DEBUG
  , const char * calledby
#endif
  );

void a((<all params of normal a()>    
#ifdef DEBUG
  , const char * calledby
#endif
  )
{
#ifdef DEBUG
  printf("'%s' calledby '%s', __FUNCTION__, calledby);
#endif
  ...
}

...

void b(void)
{
    a(<all params of normal a()>
#ifdef DEBUG
      , __FUNC__
#endif
    );
}

__FUNCTION__ ist (zumindest?) auf GCC verfügbar, wenn Sie einen anderen C99-Compiler verwenden, ersetzen Sie ihn durch __func__.

Verweisen: https://www.gnu.org/software/libc/manual/html_node/Backtraces.html

Ein Backtrace ist eine Liste der Funktionsaufrufe, die derzeit in einem Thread aktiv sind. Der übliche Weg, einen Backtrace eines Programms zu untersuchen, ist die Verwendung eines externen Debuggers wie gdb. Manchmal ist es jedoch nützlich, einen Backtrace programmgesteuert innerhalb eines Programms zu erhalten, z. B. für Protokollierungs- oder Diagnosezwecke.

Die Header-Datei execinfo.h deklariert drei Funktionen, die Backtraces des aktuellen Threads erhalten und manipulieren.

Wenn Sie erst wissen möchten, wo Sie sich zu Protokollierungs-/Debugzwecken befunden haben, können Sie ein Makro verwenden, um dies zu vermeiden __func__ Angabe des Namens Ihrer Protokollierungs-/Debug-Funktion, aber der Funktion, die sie aufruft.

In einem Makro zu sein, führt nicht zu einer Änderung von __func__ aber “fühlen” sich an, als würden Sie eine Funktion verwenden.

z.B

#define LOG(s, data...) log("%s: "s, __function__, ## data)

Wenn Ihre Plattform Windows ist, können Sie Folgendes verwenden: durch die Callstack gehen