Tools to find included headers which are unused? [closed]

by

DISCLAIMER: My day job is working for a company that develops static analysis tools.

I would be surprised if most (if not all) static analysis tools did not have some form of header usage check. You could use this wikipedia page to get a list of available tools and then email the companies to ask them.

Some points you might consider when you’re evaluating a tool:

For function overloads, you want all headers containing overloads to be visible, not just the header that contains the function that was selected by overload resolution:

// f1.h
void foo (char);

// f2.h
void foo (int);


// bar.cc
#include "f1.h"
#include "f2.h"

int main ()
{
  foo (0);  // Calls 'foo(int)' but all functions were in overload set
}

If you take the brute force approach, first remove all headers and then re-add them until it compiles, if ‘f1.h’ is added first then the code will compile but the semantics of the program have been changed.

A similar rule applies when you have partial and specializations. It doesn’t matter if the specialization is selected or not, you need to make sure that all specializations are visible:

// f1.h
template <typename T>
void foo (T);

// f2.h
template <>
void foo (int);

// bar.cc
#include "f1.h"
#include "f2.h"


int main ()
{
  foo (0);  // Calls specialization 'foo<int>(int)'
}

As for the overload example, the brute force approach may result in a program which still compiles but has different behaviour.

Another related type of analysis that you can look out for is checking if types can be forward declared. Consider the following:

// A.h
class A { };

// foo.h
#include "A.h"
void foo (A const &);

// bar.cc
#include "foo.h"

void bar (A const & a)
{
  foo (a);
}

In the above example, the definition of ‘A’ is not required, and so the header file ‘foo.h’ can be changed so that it has a forward declaration only for ‘A’:

// foo.h
class A;
void foo (A const &);

This kind of check also reduces header dependencies.

More Related Contents:

  1. how to write makefile when two header files include eachother in c++? [duplicate]
  2. What is the difference between #include and #include “filename”?
  3. What should go into an .h file?
  4. C++ cast syntax styles
  5. Is pass-by-value a reasonable default in C++11?
  6. Is it a good practice to place C++ definitions in header files?
  7. multiple definition in header file
  8. What is the proper use of the comma operator?
  9. What’s the purpose of using braces (i.e. {}) for a single-line if or loop?
  10. List of standard header files in C and C++
  11. Difference between and ?
  12. Is #pragma once part of the C++11 standard?
  13. When should you use the “this” keyword in C++? [duplicate]
  14. scope of using declaration within a namespace
  15. Why use prefixes on member variables in C++ classes
  16. Iterate through a C++ Vector using a ‘for’ loop
  17. Advantages of std::for_each over for loop
  18. When to use an elaborated type specifier
  19. What are your favorite C++ Coding Style idioms [closed]
  20. How can I avoid including class implementation files?
  21. In C++, is it still bad practice to return a vector from a function?
  22. Isn’t the const modifier here unnecessary? [duplicate]
  23. Handling header files dependencies with cmake
  24. Why do some experienced programmers write comparisons with the value before the variable? [duplicate]
  25. Header file included only once in entire program?
  26. Default member values best practice
  27. Is is a good practice to put the definition of C++ classes into the header file?
  28. Eclipse CDT: Unresolved inclusion of stl header
  29. #ifdef vs #if – which is better/safer as a method for enabling/disabling compilation of particular sections of code?
  30. How do I include the string header?

Leave a Comment