Подтвердить что ты не робот

Как узнать имя функции звонящего?

В языке C __FUNCTION__ можно использовать для получения имени функции current. Но если я определяю функцию с именем a() и вызывается в b(), как показано ниже:

b()
{
    a();
}

Теперь в исходном коде есть много функций, таких как b(), которые вызывают a(), например. c(), d(), e()...

Возможно ли, в пределах() добавить код для определения имени функции, которая вызвала()?

Далее:

  • Извините за вводящую в заблуждение опечатку. Я исправил его.
  • Я пытаюсь выяснить, какая функция вызывает функцию() для целей отладки. я не знаете, как вы это делаете, когда в той же ситуации?
  • И мой код находится под vxWorks, но я не уверен, связано ли это с C99 или что-то еще.
4b9b3361

ОТВЕТЫ

Ответ 1

Там вы ничего не можете сделать только в.

Однако, используя простой стандартный трюк, вы можете достичь того, что хотите, и в том числе идентификатор вызывающего абонента. 

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();
}

Ответ 2

Попробуйте следующее:

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

Если, например, <all param declarations to a()> - int i, double d, void * p, то <all params to a()> - i, d, p.

Или (меньше зла; → > - но больше кода modding, так как каждый вызов to() должен быть затронут):

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__ доступен в GCC (по крайней мере?), если использовать другой компилятор C99 замените его на __func__.

Ответ 3

Если вы используете систему Linux, вы можете использовать функцию backtrace().

Подробнее см. man page и пример кода.

Ответ 4

Вы можете сделать это с помощью встроенного gcc.

void * __builtin_return_address(int level)

Следующий способ должен напечатать непосредственный вызывающий функцию a().

Пример:

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

Ответ 6

Обратитесь: https://www.gnu.org/software/libc/manual/html_node/Backtraces.html

Backtrace - это список вызовов функций, которые в настоящее время активны в потоке. Обычным способом проверки обратного хода программы является используйте внешний отладчик, такой как gdb. Однако иногда это полезно для получения обратного канала программно изнутри программы, например, для целей каротажа или диагностики.

Файл заголовка execinfo.h объявляет три функции, которые манипулировать обратными трассами текущего потока.

Ответ 7

Если вы только узнаете, где вы были для целей ведения журнала/отладки, вы можете использовать макрос, чтобы избежать __func__, указав имя вашей функции регистрации/отладки, но функции, вызывающей его.

Бытие в макросе не приведет к изменению на __func__, но будет "чувствовать", как использование функции.

например.

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

Ответ 8

Вы можете пометить каждую функцию, которая вызывает a() с помощью целочисленного идентификатора, который передается в a() в качестве параметра, а затем используйте case в a(), чтобы указать, какая функция вызывается a().A printf() указывает, какую функцию вызывается a() в зависимости от значения целочисленного идентификатора, если вы используете это как аргумент для конструкции case-переключателя в a()

#include<stdio.h>

void a(int);
void b();
void c();
void d();

int main(void)
{

b();
c();
d();

}

void b()
{

int x=1;
a(x);

}

void c()
{

int x=2;
a(x);

}

void d()
{

int x=3;
a(x);

}

void a(int x)
{

switch(x)
{
case 1:
printf("b called me\n");
break;
 case 2:
printf("c called me\n");
break;
case 3:
printf("d called me\n");
}

}

Ответ 9

#include <stdio.h>
#include <stdlib.h>

#define FUNCTION_NAME (ФУНКЦИЯ) printf ( " ФУНКЦИЯ =% s\r\n", # ФУНКЦИЯ);

int a() {
  printf("A function call");
}

int b() {
  printf("B function call");
}

int main(){
FUNCTION_NAME(a);
FUNCTION_NAME(b);
return 0;

}

Ответ 10

Если рассматриваемая функция находится в другом файле c, вы можете сделать

#define name_of_function(...) \
    printf("Function %s is parent\n", __FUNCTION__); \
    name_of_function(__VA_ARGS__);

И в верхней части файла C он живет в

#ifdef name_of_function
#undef name_of_function
#endif

Если они находятся в одном файле, вы можете обернуть определение функции во второй макрос, а затем переопределить первый макрос в конце. Он не очень расширяемый, потому что вы не можете генерировать новые определения из других определений, но если вы пытаетесь отследить родителей для определенной функции, это работает без всякой чепухи.

https://godbolt.org/z/f2jKOm