blocks|key|1023824|text|我想您正在寻找一个code+coverage工具。代码覆盖工具将在代码运行时分析代码，它将让您知道哪些代码行执行了多少次，以及哪些代码行没有执行。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1023825|您可以尝试一下这个开源的代码覆盖工具:+C/C%2B%2B和C#的TestCocoon代码覆盖工具。|1023826|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Code_coverage|1|http://www.testcocoon.org/^0|9|D|0|0|T|A|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]]]

I think you are looking for a <a href="http://en.wikipedia.org/wiki/Code_coverage" rel="nofollow">code coverage</a> tool. A code coverage tool will analyze your code as it is running, and it will let you know which lines of code were executed and how many times, as well as which ones were not.

You could try giving this open source code coverage tool a chance: <a href="http://www.testcocoon.org/" rel="nofollow">TestCocoon</a> - code coverage tool for C/C++ and C#.

blocks|key|1023882|text|我自己没有用过它，但是cppcheck声称可以找到不用的函数。它可能不会解决完整的问题，但它可能是一个开始。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1023883|entityMap|0|LINK|mutability|MUTABLE|url|http://sourceforge.net/apps/mediawiki/cppcheck/index.php?title=Main_Page#Unused_functions^0|B|8|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]]]]

I haven't used it myself, but <a href="http://sourceforge.net/apps/mediawiki/cppcheck/index.php?title=Main_Page#Unused_functions" rel="noreferrer">cppcheck</a>, claims to find unused functions. It probably won't solve the complete problem but it might be a start.

blocks|key|809334|text|在不导致编译错误的情况下，将尽可能多的公共函数和变量标记为私有或受保护的，同时，尝试也重构代码。通过将函数设置为私有的并在某种程度上受到保护，您可以缩小搜索区域，因为私有函数只能从同一个类中调用(除非有愚蠢的宏或其他技巧来规避访问限制，如果是这样的话，我建议您找一份新工作)。确定您不需要私有函数要容易得多，因为只有您当前正在处理的类才能调用此函数。如果您的代码库具有较小的类并且是松散耦合的，则此方法更容易。如果您的代码库没有小类或耦合非常紧密，我建议先清理这些类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|809335|下一步是标记所有剩余的公共函数，并制作一个调用图来弄清楚类之间的关系。从这棵树中，试着找出树枝的哪一部分看起来可以修剪。|809336|这种方法的优点是你可以在每个模块的基础上做它，所以当你的代码库损坏时，很容易保持通过你的单元测试，而不会有很长一段时间。|809337|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Mark as much public functions and variables as private or protected without causing compilation error, while doing this, try to also refactor the code. By making functions private and to some extent protected, you reduced your search area since private functions can only be called from the same class (unless there are stupid macro or other tricks to circumvent access restriction, and if that's the case I'd recommend you find a new job). It is much easier to determine that you don't need a private function since only the class you're currently working on can call this function. This method is easier if your code base have small classes and is loosely coupled. If your code base does not have small classes or have very tight coupling, I suggest cleaning those up first. 

Next will be to mark all the remaining public functions and make a call graph to figure out the relationship between the classes. From this tree, try to figure out which part of the branch looks like it can be trimmed. 

The advantage of this method is that you can do it on per module basis, so it is easy to keep passing your unittest without having large period of time when you've got broken code base.

blocks|key|1024002|text|我真的没有用过任何工具来做这样的事情...但是，据我在所有答案中看到的，从来没有人说这个问题是不可计算的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1024003|这是什么意思？这个问题不能用计算机上的任何算法来解决。这个定理(这样的算法不存在)是图灵停顿问题的推论。|1024004|你将使用的所有工具都不是算法，而是启发式算法(即不是精确的算法)。他们不会给你所有没用到的代码。|1024005|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

I really haven't used any tool that does such a thing... But, as far as I've seen in all the answers, no one has ever said that this problem is uncomputable.

What do I mean by this? That this problem cannot be solved by any algorithm ever on a computer. This theorem (that such an algorithm doesn't exist) is a corollary of Turing's Halting Problem.

All the tools you will use are not algorithms but heuristics (i.e not exact algorithms). They will not give you exactly all the code that's not used.

blocks|key|809412|text|如果您使用的是Linux，那么您可能希望研究一下callgrind，这是valgrind套件中的一个C/C%2B%2B程序分析工具，它还包含一些检查内存泄漏和其他内存错误的工具(您也应该使用这些工具)。它分析程序的运行实例，并生成有关其调用图以及调用图上节点的性能成本的数据。它通常用于性能分析，但也会为您的应用程序生成一个调用图，因此您可以看到调用了哪些函数以及它们的调用者。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|809413|这显然是对页面上其他地方提到的静态方法的补充，它只会有助于消除完全未使用的类、方法和函数-它不会帮助找到实际调用的方法中的死代码。|809414|entityMap^0|O|9|10|8|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

If you are on Linux, you may want to look into <code>callgrind</code>, a C/C++ program analysis tool that is part of the <code>valgrind</code> suite, which also contains tools that check for memory leaks and other memory errors (which you should be using as well). It analyzes a running instance of your program, and produces data about its call graph, and about the performance costs of nodes on the call graph. It is usually used for performance analysis, but it also produces a call graph for your applications, so you can see what functions are called, as well as their callers.

This is obviously complementary to the static methods mentioned elsewhere on the page, and it will only be helpful for eliminating wholly unused classes, methods, and functions - it well not help find dead code inside methods which are actually called.

blocks|key|809015|text|一种方法是使用调试器和编译器功能，在编译过程中消除未使用的机器码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|809016|一旦消除了一些机器代码，调试器就不会让您在相应的源代码行上放置一个断点。所以你把断点放在任何地方，启动程序并检查断点-那些处于“没有为这个源代码加载代码”状态的断点对应于消除的代码-要么代码永远不会被调用，要么它已经被内联了，你必须执行一些最小的分析来找出这两个中的哪一个发生了。|809017|至少这是它在Visual+Studio中的工作方式，我猜其他工具集也可以做到这一点。|809018|这是大量的工作，但我想比手动分析所有代码更快。|809019|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

One way is use a debugger and the compiler feature of eliminating unused machine code during compilation.

Once some machine code is eliminated the debugger won't let you put a breakpojnt on corresponding line of source code. So you put breakpoints everywhere and start the program and inspect the breakpoints - those which are in "no code loaded for this source" state correspond to eliminated code - either that code is never called or it has been inlined and you have to perform some minimum analysis to find which of those two happened.

At least that's how it works in Visual Studio and I guess other toolsets also can do that.

That's lots of work, but I guess faster than manually analyzing all code.

blocks|key|809496|text|CppDepend是一个商业工具，可以检测未使用的类型、方法和字段，以及执行更多操作。它可用于Windows和Linux+(但目前没有64位支持)，并附带2周的试用版。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|809497|免责声明:我不在那里工作，但我有这个工具的许可证(以及NDepend，它是.NET代码的更强大的替代品)。|809498|对于那些好奇的人，这里有一个用CQLinq编写的用于检测失效方法的内置(可定制)规则示例|809499|//+<Name>Potentially+dead+Methods</Name>
warnif+count+>+0
//+Filter+procedure+for+methods+that+should'nt+be+considered+as+dead
let+canMethodBeConsideredAsDeadProc+=+new+Func<IMethod,+bool>(
++++m+=>+!m.IsPublic+&&+++++++//+Public+methods+might+be+used+by+client+applications+of+your+Projects.
+++++++++!m.IsEntryPoint+&&++++++++++++//+Main()+method+is+not+used+by-design.
+++++++++!m.IsClassConstructor+&&++++++
+++++++++!m.IsVirtual+&&+++++++++++++++//+Only+check+for+non+virtual+method+that+are+not+seen+as+used+in+IL.
+++++++++!(m.IsConstructor+&&++++++++++//+Don't+take+account+of+protected+ctor+that+might+be+call+by+a+derived+ctors.
+++++++++++m.IsProtected)+&&
+++++++++!m.IsGeneratedByCompiler
)

//+Get+methods+unused
let+methodsUnused+=+
+++from+m+in+JustMyCode.Methods+where+
+++m.NbMethodsCallingMe+==+0+&&+
+++canMethodBeConsideredAsDeadProc(m)
+++select+m

//+Dead+methods+=+methods+used+only+by+unused+methods+(recursive)
let+deadMethodsMetric+=+methodsUnused.FillIterative(
+++methods+=>+//+Unique+loop,+just+to+let+a+chance+to+build+the+hashset.
++++++++++++++from+o+in+new[]+{+new+object()+}
++++++++++++++//+Use+a+hashet+to+make+Intersect+calls+much+faster!
++++++++++++++let+hashset+=+methods.ToHashSet()
++++++++++++++from+m+in+codeBase.Application.Methods.UsedByAny(methods).Except(methods)
++++++++++++++where+canMethodBeConsideredAsDeadProc(m)+&&
++++++++++++++++++++//+Select+methods+called+only+by+methods+already+considered+as+dead
++++++++++++++++++++hashset.Intersect(m.MethodsCallingMe).Count()+==+m.NbMethodsCallingMe
++++++++++++++select+m)

from+m+in+JustMyCode.Methods.Intersect(deadMethodsMetric.DefinitionDomain)
select+new+{+m,+m.MethodsCallingMe,+depth+=+deadMethodsMetric[m]+}|code-block|syntax|javascript|809500|entityMap|0|LINK|mutability|MUTABLE|url|http://cppdepend.com/|1|http://ndepend.com/|2|http://cppdepend.com/Features.aspx#CQL^0|0|9|0|0|R|7|1|0|F|6|2|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|F|3|G|5|6|7|16|8|@]|9|@$A|17|B|18|1|19]]|C|$]]|$1|H|3|I|5|J|7|1A|8|@]|9|@]|C|$K|L]]|$1|M|3|-4|5|6|7|1B|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]|W|$5|P|Q|R|C|$S|X]]]]

<a href="http://cppdepend.com" rel="nofollow">CppDepend</a> is a commercial tool which can detect unused types, methods and fields, and do much more. It is available for Windows and Linux (but currently has no 64-bit support), and comes with a 2-week trial.

Disclaimer: I don't work there, but I own a license for this tool (as well as <a href="http://ndepend.com" rel="nofollow">NDepend</a>, which is a more powerful alternative for .NET code).

For those who are curious, here is an example built-in (customizable) rule for detecting dead methods, written in <a href="http://cppdepend.com/Features.aspx#CQL" rel="nofollow">CQLinq</a>:

<pre><code>// &lt;Name&gt;Potentially dead Methods&lt;/Name&gt;
warnif count &gt; 0
// Filter procedure for methods that should'nt be considered as dead
let canMethodBeConsideredAsDeadProc = new Func&lt;IMethod, bool&gt;(
 m =&gt; !m.IsPublic &amp;&amp; // Public methods might be used by client applications of your Projects.
 !m.IsEntryPoint &amp;&amp; // Main() method is not used by-design.
 !m.IsClassConstructor &amp;&amp; 
 !m.IsVirtual &amp;&amp; // Only check for non virtual method that are not seen as used in IL.
 !(m.IsConstructor &amp;&amp; // Don't take account of protected ctor that might be call by a derived ctors.
 m.IsProtected) &amp;&amp;
 !m.IsGeneratedByCompiler
)

// Get methods unused
let methodsUnused = 
 from m in JustMyCode.Methods where 
 m.NbMethodsCallingMe == 0 &amp;&amp; 
 canMethodBeConsideredAsDeadProc(m)
 select m

// Dead methods = methods used only by unused methods (recursive)
let deadMethodsMetric = methodsUnused.FillIterative(
 methods =&gt; // Unique loop, just to let a chance to build the hashset.
 from o in new[] { new object() }
 // Use a hashet to make Intersect calls much faster!
 let hashset = methods.ToHashSet()
 from m in codeBase.Application.Methods.UsedByAny(methods).Except(methods)
 where canMethodBeConsideredAsDeadProc(m) &amp;&amp;
 // Select methods called only by methods already considered as dead
 hashset.Intersect(m.MethodsCallingMe).Count() == m.NbMethodsCallingMe
 select m)

from m in JustMyCode.Methods.Intersect(deadMethodsMetric.DefinitionDomain)
select new { m, m.MethodsCallingMe, depth = deadMethodsMetric[m] }
</code></pre>

blocks|key|1023777|text|这取决于您用来创建应用程序的平台。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1023778|例如，如果你使用Visual+Studio，你可以使用像.NET+ANTS+Profiler这样的工具来解析和分析你的代码。这样，您就可以快速了解代码的哪一部分被实际使用。Eclipse也有等效的插件。|offset|length|1023779|否则，如果您需要了解最终用户实际使用应用程序的哪些功能，并且可以轻松发布应用程序，则可以使用日志文件进行审计。|1023780|对于每个主函数，您可以跟踪其使用情况，几天/周后，只需获取日志文件，并查看它。|1023781|entityMap|0|LINK|mutability|MUTABLE|url|http://www.red-gate.com/products/dotnet-development/ants-performance-profiler/^0|0|S|I|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@$D|T|E|U|1|V]]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]]]

It depends of the platform you use to create your application.

For example, if you use Visual Studio, you could use a tool like <a href="http://www.red-gate.com/products/dotnet-development/ants-performance-profiler/" rel="nofollow">.NET ANTS Profiler</a> which is able to parse and profile your code. This way, you should quickly know which part of your code is actually used. Eclipse also have equivalent plugins.

Otherwise, if you need to know what function of your application is actually used by your end user, and if you can release your application easily, you can use a log file for an audit.

For each main function, you can trace its usage, and after a few days/week just get that log file, and have a look at it.

blocks|key|1024377|text|今天我有一个朋友问我这个问题，我看了看一些很有前途的Clang开发，例如ASTMatchers和Static+Analyzer，它们在编译过程中可能有足够的可见性来确定死代码部分，但后来我发现了以下内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1024378|https://blog.flameeyes.eu/2008/01/today-how-to-identify-unused-exported-functions-and-variables|1024379|它几乎完整地描述了如何使用几个似乎是为了识别未引用的符号而设计的GCC标志！|1024380|entityMap|0|LINK|mutability|MUTABLE|url|http://clang.llvm.org/docs/LibASTMatchers.html|1|http://clang-analyzer.llvm.org/|2^0|10|A|0|1C|F|1|0|0|2N|2|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]]|C|$]]|$1|F|3|G|5|6|7|13|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]|P|$5|K|L|M|C|$N|Q]]|R|$5|K|L|M|C|$N|E]]]]

I had a friend ask me this very question today, and I looked around at some promising Clang developments, e.g. <a href="http://clang.llvm.org/docs/LibASTMatchers.html" rel="nofollow">ASTMatcher</a>s and the <a href="http://clang-analyzer.llvm.org/" rel="nofollow">Static Analyzer</a> that might have sufficient visibility in the goings-on during compiling to determine the dead code sections, but then I found this:

<a href="https://blog.flameeyes.eu/2008/01/today-how-to-identify-unused-exported-functions-and-variables" rel="nofollow">https://blog.flameeyes.eu/2008/01/today-how-to-identify-unused-exported-functions-and-variables</a>

It's pretty much a complete description of how to use a few GCC flags that are seemingly designed for the purpose of identifying unreferenced symbols!

blocks|key|1024459|text|关于是否调用某个函数的一般问题是NP-完全问题。你不能提前知道某个函数是否会被调用，因为你不知道图灵机是否会停止。你可以(静态地)得到从main()到你所写的函数的路径，但这并不能保证它会被调用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1024460|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The general problem of if some function will be called is NP-Complete. You cannot know in advance in a general way if some function will be called as you won't know if a Turing machine will ever stop. You can get if there's some path (statically) that goes from main() to the function you have written, but that doesn't warrant you it will ever be called.

blocks|key|1023930|text|如果你使用g%2B%2B，你可以使用这个标志-Wunused|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1023931|根据文档：|1023932|Warn+whenever+a+variable+is+unused+aside+from+its+declaration,+whenever+a+function+is+declared+static+but+never+defined,+whenever+a+label+is+declared+but+not+used,+and+whenever+a+statement+computes+a+result+that+is+explicitly+not+used.|code-block|syntax|javascript|1023933|http://docs.freebsd.org/info/gcc/gcc.info.Warning_Options.html|offset|length|1023934|编辑:根据文档，下面是其他有用的标志-Wunreachable+code：|1023935|This+option+is+intended+to+warn+when+the+compiler+detects+that+at+least+a+whole+line+of+source+code+will+never+be+executed,+because+some+condition+is+never+satisfied+or+because+it+is+after+a+procedure+that+never+returns.|1023936|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|1Q|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|10|8|@]|9|@$K|11|L|12|1|13]]|A|$]]|$1|M|3|N|5|6|7|14|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|15|8|@]|9|@]|A|$G|H]]|$1|Q|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|J]]]]

Well if you using g++ you can use this flag -Wunused

According documentation:

<pre><code>Warn whenever a variable is unused aside from its declaration, whenever a function is declared static but never defined, whenever a label is declared but not used, and whenever a statement computes a result that is explicitly not used.
</code></pre>

<a href="http://docs.freebsd.org/info/gcc/gcc.info.Warning_Options.html" rel="nofollow">http://docs.freebsd.org/info/gcc/gcc.info.Warning_Options.html</a>

Edit: Here is other usefull flag -Wunreachable-code According documentation:

<pre><code>This option is intended to warn when the compiler detects that at least a whole line of source code will never be executed, because some condition is never satisfied or because it is after a procedure that never returns.
</code></pre>

I have legacy C++ code that I'm supposed to remove unused code from. The problem is that the code base is large.

How can I find out which code is never called/never used?

How can I know which parts in the code are never used?

Visual Studio

日志文件

单元测试

编译器

调试器

Windows

Eclipse

Linux

我有遗留的C++代码，我应该从中删除未使用的代码。问题是代码库太大了。我如何找出哪些代码从未调用过/从未使用过？

问我如何知道代码中哪些部分从未使用过？
EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我如何知道代码中哪些部分从未使用过？EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我如何知道代码中哪些部分从未使用过？
EN