blocks|key|2781875|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2781876|，或者有没有一种方法可以使用gdb打印出有用的信息，而不必遍历代码。|blockquote|2781877|2781878|2781879|是。只在你真正关心的函数上设置断点。使用"continue“，直到你找到这些函数，或者直到你的程序崩溃。然后使用"backtrace“(或"bt")获取堆栈跟踪。|2781880|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|J|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|K|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|L|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|M|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|N|7|@]|8|@]|9|$]]|$1|H|3|-4|4|5|6|O|7|@]|8|@]|9|$]]]|I|$]]

<blockquote>
 Or is there a way to use gdb to print out the information that would be useful, while not having to step through the code
</blockquote>

Yes. Set a breakpoint only at the functions that you actually care about. Use "continue" until you get to those functions or until your program crashes. Then use "backtrace" (or "bt") to get a stack trace.

blocks|key|2781900|text|#define+BEGIN_FUNC(X)+printf("Function+%25s+Entered",X)
#define+END_FUNC(X)++printf("Function+%25s+End",X)

foo()
{
BEGIN_FUNC(__func__);

//Your+code+here


END_FUNC(__func__);


}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2781901|我认为如果你像上面那样编写一个宏，并按照描述的那样对每个函数使用它，那么你就可以在终端上获得日志。|unstyled|2781902|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>#define BEGIN_FUNC(X) printf("Function %s Entered",X)
#define END_FUNC(X) printf("Function %s End",X)

foo()
{
BEGIN_FUNC(__func__);

//Your code here


END_FUNC(__func__);


}
</code></pre>

I think if you write a macro like above and use it for every function as described then you can get the logs on the terminal.

blocks|key|2006515|text|有一个__FUNCTION__+(Reference)宏用于确定您使用的是什么方法(格式为Class::Method)，但这更像是一个手动过程。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2006516|然而，当我最近需要同样的“跟踪”信息时，我找不到一个自动的方法。|2006517|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/b0084kay(VS.80).aspx^0|3|C|19|D|G|B|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@$9|U|A|V|1|W]]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

There is a <code>__FUNCTION__</code> <a href="http://msdn.microsoft.com/en-us/library/b0084kay(VS.80).aspx" rel="nofollow noreferrer">(Reference)</a> macro used to determine what method (in the format <code>Class::Method</code>) you're in, but this is more of a manual process.

However, when I needed the same 'trace' information recently, I could not find a automatic method.

blocks|key|4894703|text|您可能想看看Valgrind's+Callgrind，它可以将函数调用跟踪到一个漂亮的图形中。它将显示函数调用，但不显示参数或返回值。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4894704|entityMap|0|LINK|mutability|MUTABLE|url|http://valgrind.org/docs/manual/cl-manual.html^0|6|K|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

You may want to look at <a href="http://valgrind.org/docs/manual/cl-manual.html" rel="nofollow noreferrer">Valgrind's Callgrind</a> which can track function calls into a pretty graph. It will show function calls, but not the parameter or return values.

blocks|key|2781989|text|大多数编译器允许您在函数调用之前和之后插入插入指令插入函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2781990|在MSVC中，它们是_penter和_pexit。一篇不错的文章：http://www.drdobbs.com/184403601。|offset|length|style|CODE|2781991|在GCC中，您将使用-finstrument-functions选项，请参见the+docs。|2781992|您可以使用调试库或映射文件来获取更多信息。|2781993|entityMap|0|LINK|mutability|MUTABLE|url|http://www.drdobbs.com/184403601|1|http://gcc.gnu.org/onlinedocs/gcc-4.4.4/gcc/Code-Gen-Options.html^0|0|A|7|I|6|X|W|0|0|A|M|12|8|1|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@$D|X|E|Y|F|G]|$D|Z|E|10|F|G]]|9|@$D|11|E|12|1|13]]|A|$]]|$1|H|3|I|5|6|7|14|8|@$D|15|E|16|F|G]]|9|@$D|17|E|18|1|19]]|A|$]]|$1|J|3|K|5|6|7|1A|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]|T|$5|O|P|Q|A|$R|U]]]]

Most compilers allow you to inject an instrumentation function before and after the function call. 

In MSVC they are <code>_penter</code> and <code>_pexit</code>. A nice article: <a href="http://www.drdobbs.com/184403601" rel="noreferrer">http://www.drdobbs.com/184403601</a>.

In GCC you would use the <code>-finstrument-functions</code> option, see <a href="http://gcc.gnu.org/onlinedocs/gcc-4.4.4/gcc/Code-Gen-Options.html" rel="noreferrer">the docs</a>.

You can use debug libaries or map files to get more info.

blocks|key|2782016|text|如果你需要自动化它，你可以看看TARGET_ASM_FUNCTION_END_PROLOGUE和TARGET_ASM_FUNCTION_BEGIN_EPILOGUE。这些是编译器钩子，可以让您指定要与常规函数前言/结尾一起发出的程序集片段--在您的示例中，您将使用它们发出一个小程序集，以记录从所讨论的函数进入/退出。您还可以查看FUNCTION_PROFILE和/或PROFILE_HOOK+(例如，在：http://gcc.gnu.org/onlinedocs/gccint/Function-Entry.html)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2782017|entityMap|0|LINK|mutability|MUTABLE|url|http://gcc.gnu.org/onlinedocs/gccint/Function-Entry.html^0|F|W|1C|Y|4L|G|54|C|5N|1K|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@$9|W|A|X|1|Y]]|E|$]]|$1|F|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

If you need to automate it, you might take a look at <code>TARGET_ASM_FUNCTION_END_PROLOGUE</code> and <code>TARGET_ASM_FUNCTION_BEGIN_EPILOGUE</code>. These are compiler hooks that will let you specify pieces of assembly to be emitted along with the normal function prologue/epilogue -- in your case, you'd use them to emit a little assembly to log the entry/exit from the function in question. You could also look at <code>FUNCTION_PROFILE</code> and/or <code>PROFILE_HOOK</code> (e.g., at: <a href="http://gcc.gnu.org/onlinedocs/gccint/Function-Entry.html" rel="nofollow noreferrer">http://gcc.gnu.org/onlinedocs/gccint/Function-Entry.html</a>).

blocks|key|2782052|text|一个相当复杂的解决方案是使用RAII来控制函数的范围。这将对性能有很大的影响，但在日志中将非常明确，而不需要用户在可能离开函数的所有可能的代码路径中添加工具：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2782053|class+ScopeLogger+{
public:
+++ScopeLogger(+std::string+const+&+msg+)+:+msg(msg)
+++{+++std::cout+<<+"Enter:+"+<<+msg+<<+std::endl;+}
+++~ScopeLogger()
+++{+++std::cout+<<+"Exit:++"+<<+msg+<<+std::endl;+}
+++std::string+msg;
};
#if+DEBUG
#define+FUNCTION(x)+ScopeLogger+l_##x##_scope(x);
#endif

void+foo(+int+value+)+{
+++FUNCTION(+__FUNCTION__+);
+++if+(+value+>+10+)+throw+std::exception;
+++std::cout+<<+"."+<<+std::endl;
}

int+main()+{
+++foo(0);++++//+Enter:+foo\n.\nExit:++foo
+++foo(100);++//+Enter:+foo\nExit:++foo
}|code-block|syntax|javascript|2782054|如果代码是单线程的，您甚至可能希望向ScopedLogger添加一个具有一定缩进级别的静态变量，而不会增加太多已经很严重的性能影响：|offset|length|style|CODE|2782055|class+ScopeLogger+{
public:
+++ScopeLogger(+std::string+const+&+msg+)+:+msg(msg)
+++{+++std::cout+<<+std::string(indent%2B%2B,'+')+<<+"Enter:+"+<<+msg+<<+std::endl;+}
+++~ScopeLogger()
+++{+++std::cout+<<+std::string(--indent,'+')+<<+"Exit:++"+<<+msg+<<+std::endl;+}
+++std::string+msg;
+++static+int+indent;
};
int+ScopeLogger::indent+=+0;|2782056|entityMap^0|0|0|I|C|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

A quite intrussive solution is using RAII to control the scope of the function. This will have a great impact in performance, but will be quite explicit in the logs without requiring the user to add instrumentation in all possible code paths that may leave the function:

<pre><code>class ScopeLogger {
public:
 ScopeLogger( std::string const &amp; msg ) : msg(msg)
 { std::cout &lt;&lt; "Enter: " &lt;&lt; msg &lt;&lt; std::endl; }
 ~ScopeLogger()
 { std::cout &lt;&lt; "Exit: " &lt;&lt; msg &lt;&lt; std::endl; }
 std::string msg;
};
#if DEBUG
#define FUNCTION(x) ScopeLogger l_##x##_scope(x);
#endif

void foo( int value ) {
 FUNCTION( __FUNCTION__ );
 if ( value &gt; 10 ) throw std::exception;
 std::cout &lt;&lt; "." &lt;&lt; std::endl;
}

int main() {
 foo(0); // Enter: foo\n.\nExit: foo
 foo(100); // Enter: foo\nExit: foo
}
</code></pre>

If the code is single threaded, you might even want to add a static variable with some indentation level to <code>ScopedLogger</code> without adding too much to the already heavy performance impact:

<pre><code>class ScopeLogger {
public:
 ScopeLogger( std::string const &amp; msg ) : msg(msg)
 { std::cout &lt;&lt; std::string(indent++,' ') &lt;&lt; "Enter: " &lt;&lt; msg &lt;&lt; std::endl; }
 ~ScopeLogger()
 { std::cout &lt;&lt; std::string(--indent,' ') &lt;&lt; "Exit: " &lt;&lt; msg &lt;&lt; std::endl; }
 std::string msg;
 static int indent;
};
int ScopeLogger::indent = 0;
</code></pre>

blocks|key|99712|text|既然您使用的是GCC，那么您也可以使用链接器函数包装。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|99713|Link-Time+Replacement+/+Wrapping
–+GCC+option:+-Wl,--wrap,function_name|code-block|syntax|javascript|99714|基本上，您可以使用名为"function_name()“的函数，并用名为"__wrap_function_name()”的函数包装它。您可以通过调用"__real_function_name()“来访问原始函数。|99715|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Since you are using GCC, you can also use linker function wrapping.

<pre><code>Link-Time Replacement / Wrapping
– GCC option: -Wl,--wrap,function_name
</code></pre>

Basically, you can take a function called "function_name()" and wrap it with a function called "__wrap_function_name()". You can access the original function by calling "__real_function_name()".

blocks|key|101512|text|下面是一个示例，说明了the+answer+by+Jonathan+Fischoff的GCC方面。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|101513|在这里，我们调用外部工具addr2line将位置打印为functionName+at+/path/to/file.cpp:line，而不仅仅是地址。为此，我尝试使用dladdr+(正如上面链接的答案的注释中所建议的那样)，但它在dli_sname中只返回空指针。|style|CODE|101514|这种解析地址的方法有一些缺点：|101515|101516|由于fork/execve/file读取而速度较慢。|unordered-list-item|101517|它需要包含地址的二进制文件的确切文件路径，因此下面的简单代码无法打印共享库中的符号。|101518|101519|//+Instrumentation
#include+<stdio.h>
#include+<stdlib.h>
#include+<unistd.h>

static+void+__attribute__((no_instrument_function))
++++log_func(const+void*+funcAddr,+const+char*+action,+const+void*+callSite)
{
++++char+cmd[50];
++++snprintf(cmd,+sizeof+cmd,+"addr2line+-Cpfe+/proc/%25d/exe+%25p",+getpid(),+funcAddr);
++++fprintf(stderr,+"%25p+%25s+%25p+",+callSite,+action,+funcAddr);
++++system(cmd);
}

extern+"C"+void+__attribute__((no_instrument_function))
++++__cyg_profile_func_enter(void*+this_fn,+void*+call_site)
{
++++log_func(this_fn,+"->",+call_site);
}

extern+"C"+void+__attribute__((no_instrument_function))
++++__cyg_profile_func_exit(void*+this_fn,+void*+call_site)
{
++++log_func(this_fn,+"<-",+call_site);
}

//+Actual+code+we're+tracing
#include+<iostream>

struct+Test
{
++++Test()+{+std::cout+<<+"Hi,+I'm+Test+constructor\n";+}
++++void+method()+const+{+std::cout+<<+"And+I'm+Test+method\n";+}
};

int+main()
{
++++std::cout+<<+"Hello,+my+name+is+main\n";
++++Test+test;
++++test.method();
}|code-block|syntax|javascript|101520|编译和运行：|101521|$+g%2B%2B+test.cpp+-o+test+-g+-finstrument-functions+&&+time+./test
0x8048b0b+->+0x804899b+_GLOBAL__sub_I___cyg_profile_func_enter+at+/tmp/test.cpp:41
0x80489c4+->+0x804890b+__static_initialization_and_destruction_0(int,+int)+at+/tmp/test.cpp:41
0x80489c4+<-+0x804890b+__static_initialization_and_destruction_0(int,+int)+at+/tmp/test.cpp:41
0x8048b0b+<-+0x804899b+_GLOBAL__sub_I___cyg_profile_func_enter+at+/tmp/test.cpp:41
0xf7a0de71+->+0x804886a+main+at+/tmp/test.cpp:37
Hello,+my+name+is+main
0x80488b1+->+0x80489de+Test::Test()+at+/tmp/test.cpp:32
Hi,+I'm+Test+constructor
0x80488b1+<-+0x80489de+Test::Test()+at+/tmp/test.cpp:32
0x80488c0+->+0x8048a4a+Test::method()+const+at+/tmp/test.cpp:33
And+I'm+Test+method
0x80488c0+<-+0x8048a4a+Test::method()+const+at+/tmp/test.cpp:33
0xf7a0de71+<-+0x804886a+main+at+/tmp/test.cpp:37

real++++0m0.062s
user++++0m0.054s
sys+++++0m0.008s|101522|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/3315327/673852^0|B|V|0|0|C|9|R|12|2A|6|36|9|0|0|0|2|4|7|6|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|17|8|@]|9|@$A|18|B|19|1|1A]]|C|$]]|$1|D|3|E|5|6|7|1B|8|@$A|1C|B|1D|F|G]|$A|1E|B|1F|F|G]|$A|1G|B|1H|F|G]|$A|1I|B|1J|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|1K|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|1L|8|@]|9|@]|C|$]]|$1|K|3|L|5|M|7|1M|8|@$A|1N|B|1O|F|G]|$A|1P|B|1Q|F|G]]|9|@]|C|$]]|$1|N|3|O|5|M|7|1R|8|@]|9|@]|C|$]]|$1|P|3|-4|5|6|7|1S|8|@]|9|@]|C|$]]|$1|Q|3|R|5|S|7|1T|8|@]|9|@]|C|$T|U]]|$1|V|3|W|5|6|7|1U|8|@]|9|@]|C|$]]|$1|X|3|Y|5|S|7|1V|8|@]|9|@]|C|$T|U]]|$1|Z|3|-4|5|6|7|1W|8|@]|9|@]|C|$]]]|10|$11|$5|12|13|14|C|$15|16]]]]

Below is an example illustrating the GCC side of <a href="https://stackoverflow.com/a/3315327/673852">the answer by Jonathan Fischoff</a>.

Here we call external tool <code>addr2line</code> to print the location as <code>functionName at /path/to/file.cpp:line</code> instead of simply the address. I've tried using <code>dladdr</code> for this (as suggested in a comment to the answer linked above), but it returned only null pointers in <code>dli_sname</code> for me.

This approach of resolving the addresses has some drawbacks:

<ul>
<li>It's slow due to <code>fork</code>/<code>execve</code>/file read.</li>
<li>It needs exact file path to the binary containing the address, so the simple code below can't print symbols in shared libraries.</li>
</ul>

<pre><code>// Instrumentation
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;unistd.h&gt;

static void __attribute__((no_instrument_function))
 log_func(const void* funcAddr, const char* action, const void* callSite)
{
 char cmd[50];
 snprintf(cmd, sizeof cmd, "addr2line -Cpfe /proc/%d/exe %p", getpid(), funcAddr);
 fprintf(stderr, "%p %s %p ", callSite, action, funcAddr);
 system(cmd);
}

extern "C" void __attribute__((no_instrument_function))
 __cyg_profile_func_enter(void* this_fn, void* call_site)
{
 log_func(this_fn, "-&gt;", call_site);
}

extern "C" void __attribute__((no_instrument_function))
 __cyg_profile_func_exit(void* this_fn, void* call_site)
{
 log_func(this_fn, "&lt;-", call_site);
}

// Actual code we're tracing
#include &lt;iostream&gt;

struct Test
{
 Test() { std::cout &lt;&lt; "Hi, I'm Test constructor\n"; }
 void method() const { std::cout &lt;&lt; "And I'm Test method\n"; }
};

int main()
{
 std::cout &lt;&lt; "Hello, my name is main\n";
 Test test;
 test.method();
}
</code></pre>

Compilation and running:

<pre class="lang-none prettyprint-override"><code>$ g++ test.cpp -o test -g -finstrument-functions &amp;&amp; time ./test
0x8048b0b -&gt; 0x804899b _GLOBAL__sub_I___cyg_profile_func_enter at /tmp/test.cpp:41
0x80489c4 -&gt; 0x804890b __static_initialization_and_destruction_0(int, int) at /tmp/test.cpp:41
0x80489c4 &lt;- 0x804890b __static_initialization_and_destruction_0(int, int) at /tmp/test.cpp:41
0x8048b0b &lt;- 0x804899b _GLOBAL__sub_I___cyg_profile_func_enter at /tmp/test.cpp:41
0xf7a0de71 -&gt; 0x804886a main at /tmp/test.cpp:37
Hello, my name is main
0x80488b1 -&gt; 0x80489de Test::Test() at /tmp/test.cpp:32
Hi, I'm Test constructor
0x80488b1 &lt;- 0x80489de Test::Test() at /tmp/test.cpp:32
0x80488c0 -&gt; 0x8048a4a Test::method() const at /tmp/test.cpp:33
And I'm Test method
0x80488c0 &lt;- 0x8048a4a Test::method() const at /tmp/test.cpp:33
0xf7a0de71 &lt;- 0x804886a main at /tmp/test.cpp:37

real 0m0.062s
user 0m0.054s
sys 0m0.008s
</code></pre>

I am looking for a clever way to track function calls and returns.
I know I can use the debugger, but I would like a way to just have it print something out to the terminal when calling a function vs having to step through code. 
I am thinking that I might be able to use the preprocessor, but I am not sure what would be the best way to go about this. 
Or is there a way to use gdb to print out the information that would be useful, while not having to step through the code.

C/C++ need a clever way to track function calls

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我正在寻找一种聪明的方法来跟踪函数调用和返回。我知道我可以使用调试器，但我想要一种方法，让它在调用函数时将某些内容打印到终端，而不是单步执行代码。我在想，我也许可以使用预处理器，但我不确定什么是最好的方法。或者，有没有一种方法可以使用gdb打印出有用的信息，而不必遍历代码。

问C/C++需要一种聪明的方法来跟踪函数调用
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C/C++需要一种聪明的方法来跟踪函数调用EN