这取决于创建应用程序时使用的平台。

例如，如果你使用Visual Studio，你可以使用像. net ANTS Profiler这样的工具来解析和分析你的代码。通过这种方式，您应该很快知道实际使用了代码的哪一部分。Eclipse也有等效的插件。

否则，如果您需要知道最终用户实际使用了应用程序的哪些功能，并且您可以轻松地发布应用程序，则可以使用日志文件进行审计。

对于每个主要函数，您可以跟踪它的使用情况，并在几天/一周后获取日志文件，并查看它。

我自己没有使用过cppcheck，但它声称可以找到未使用的函数。这也许不能完全解决问题，但可能是个开始。

If you are on Linux, you may want to look into callgrind, a C/C++ program analysis tool that is part of the valgrind 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.

这显然是对页面其他地方提到的静态方法的补充，它只会有助于消除完全不使用的类、方法和函数——它不会帮助找到实际调用的方法内部的死代码。

CppDepend是一个商业工具，它可以检测未使用的类型、方法和字段，以及做更多的事情。它适用于Windows和Linux(但目前不支持64位)，并有两周的试用期。

免责声明:我不在那里工作，但我拥有这个工具的许可证(以及NDepend，它是。net代码的一个更强大的替代方案)。

对于那些好奇的人来说，这里有一个内置的(可定制的)检测死方法的规则示例，用CQLinq编写:

// <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] }

一种方法是使用调试器和编译器特性，在编译过程中消除未使用的机器代码。

一旦某些机器代码被删除，调试器就不会让你在相应的源代码行上添加断点。因此，您将断点放置在任何地方，并启动程序并检查断点——那些处于“此源未加载代码”状态的断点对应于已消除的代码——要么该代码从未被调用，要么已内联，您必须执行一些最小分析，以找出这两者中哪一个发生了。

至少这是它在Visual Studio中的工作方式，我猜其他工具集也可以做到这一点。

这需要做很多工作，但我认为比手动分析所有代码要快。

我有个朋友今天问了我这个问题，我看了看一些有前途的Clang开发，例如ASTMatchers和Static Analyzer，它们可能在编译过程中有足够的可见性来确定死代码部分，但后来我发现了这个:

https://blog.flameeyes.eu/2008/01/today-how-to-identify-unused-exported-functions-and-variables

它几乎完整地描述了如何使用一些GCC标志，这些标志似乎是为了识别未引用的符号而设计的!