A dependency between two program elements exists if one reuses the other; that is, if building, using or testing one (the reuser) requires the presence and correctness of the other one (the reused).

In the case of classes, a dependency exists if the implementation of the reuser class must change whenever the interface of the reused class changes.

Figure 7.1 shows the dependency between a reuser ClassA and a reused ClassB with a UML diagram.

A dependency between ClassA and ClassB can arise in a variety of ways.

In each of the following situations, a change in the interface of ClassB might necessitate changes in the implementation of ClassA.

In each case, it is necessary to #include ClassB in the implementation file for ClassA.

Code reuse, a valuable and important goal, always produces dependencies.

When designing classes and libraries, you need to make sure that you produce as few unnecessary or unintentional dependencies as possible

Each #include directive produces a dependency and should be carefully examined to make sure that it is really necessary.

It is especially important to eliminate unnecessary #includes in header files.

A forward declaration of a class declares its name as a valid class name but leaves out its definition.

The class name can then be used as a type for pointers and references that are not dereferenced before the definition is encountered.

In a class definition header file, one good rule to follow is this: Do not use an #include if a forward declaration suffices.

For example, the header file "classa.h" might look something like this:

  #include "classb.h"
  #include "classd.h"
  // other #include directives as needed
  class ClassC;    // forward declaration
  class ClassA : public ClassB {
    public:
      ClassC* f1(ClassD);
    // other stuff that does not involve ClassC
  };