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.

接下来将标记所有剩余的公共函数，并制作一个调用图，以找出类之间的关系。从这棵树上，试着找出树枝的哪一部分看起来可以修剪。

这种方法的优点是你可以在每个模块的基础上进行测试，所以当你的代码库损坏时，你很容易通过单元测试，而不会有很长一段时间。

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

你可以尝试使用Gimple Software的PC-lint/FlexeLint。它声称

找到未使用的宏，typedef， 类、成员、声明等。 贯穿整个项目

我曾用它进行静态分析，并发现它非常好，但我必须承认，我没有专门用它来查找死代码。

我不认为它可以自动完成。

即使使用代码覆盖工具，也需要提供足够的输入数据来运行。

可能是非常复杂和昂贵的静态分析工具，如Coverity的或LLVM编译器可能会有所帮助。

但我不确定，我更喜欢手动代码审查。

更新

嗯. .不过，仅删除未使用的变量和未使用的函数并不难。

更新

看了其他人的回答和评论后，我更加坚定地认为这是不可能的。

您必须了解代码以获得有意义的代码覆盖率度量，如果您知道大量的手动编辑将比准备/运行/检查覆盖率结果更快。

GNU链接器有一个——cref选项，用于生成交叉引用信息。你可以通过-Wl，——cref从gcc命令行传递它。

例如，假设foo。O定义了一个符号foo_sym，也在bar.o中使用。然后在输出中你会看到:

foo_sym                            foo.o
                                   bar.o

如果foo_sym限制为foo。O，那么你不会看到任何额外的目标文件;后面会跟着另一个符号:

foo_sym                            foo.o
force_flag                         options.o

现在，从这里我们不知道是否使用了foo_sym。它只是一个候选:我们知道它是在一个文件中定义的，而没有在其他任何文件中使用。Foo_sym可以在foo中定义。O和用于那里。

那么，你该怎么处理这些信息呢

执行一些文本修改，以识别限制在一个目标文件中的这些符号，生成候选列表。 进入源代码，给每个候选对象提供带有静态的内部链接，就像它应该有的那样。 重新编译源代码。 现在，对于那些真正未使用的符号，编译器将能够警告，为你精确定位它们;你可以删除它们。

当然，我忽略了其中一些符号是故意不使用的可能性，因为它们是为动态链接而导出的(即使在链接可执行文件时也可能出现这种情况);这是一种更微妙的情况，你必须了解并明智地处理。

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.

接下来将标记所有剩余的公共函数，并制作一个调用图，以找出类之间的关系。从这棵树上，试着找出树枝的哪一部分看起来可以修剪。

这种方法的优点是你可以在每个模块的基础上进行测试，所以当你的代码库损坏时，你很容易通过单元测试，而不会有很长一段时间。