Checking if headers include what they use

Question

Are there tools that will parse a C++ project and decide whether the header files include what they use: i.e. if a file Foo.cc (or Foo.h) mentions some class Bar (e.g. vector) then it itself includes a header file defining the class (a file defining Bar e.g. <vector>) ?

Edit: I want to clarify: if a header file Foo.h mentions vector and one of its includes already included vector, the compiler is happy. I don't want that. If Foo.h mentions vector at all, it should include it directly and not depend on another header. Does the compiler catch this?

Answer 1

The compiler will do this for you. A number of C++ style guides strongly recommend that for this reason all .cpp files should include the corresponding header as the first substantive include directive.

Answer 2

I've used a script for this. here's a simplified version:

#!/usr/bin/env bash
# hcheck: Check header file syntax (works on source files, too...)
if [ $# -eq 0 ]; then
    echo "Usage: $0 <filename>"
    exit 1
fi

for f in "$@" ; do
    case $f in
        *.c | *.cpp | *.cc | *.h | *.hh | *.hpp )
            echo "#include \"$f\"" > hcheck.cpp
            printf "\n\033[4mChecking $f\033[0m\n"
            make -s hcheck.o
            rm -f hcheck.o hcheck.cpp
            ;;
    esac
done

You need to have a Makefile, of course. If you don't want that, then replace the make line with an appropriate gcc command (don't forget any flags!). You'll also need to tweak it if your Makefile puts objects somewhere other than the current directory.

I'm sure there are plenty of improvements to be made. When I tell people about this, the knee-jerk response is "Compiling headers is a stupid idea," but it's worked well for me and can be used on headers that don't have sources or aren't included first in the source.

Answer 3

One way to ease the burden of reaching the goal of self sufficient headers is to make sure that whatever class (usually) or free functions (sometimes) are declared there have very specific intentions, as in adhering to the single responsibility principle. By doing that, there will be fewer dependencies that require headers to be included.

Answer 4

I'm not aware of such a tool. The problem isn't as easy to solve as it would seem. For example, which header files should the following include in order to be self-sufficient?

#ifdef FOO
  std::vector<int> getVector();
#endif

  void doStuff(std::string);

It might, might not, need to include <vector>. That depends on whether FOO is defined, and that might or might not be defined, depending on what was included before this file.

In general, preprocessor macros can really mess with any attempt at reading a header "in isolation".