Item 26. Minimizing Compile-time Dependencies桺art 1

Difficulty: 4

When we talk about dependencies, we usually think of run-time dependencies like class interactions. In this Item, we will focus instead on how to analyze and manage compile-time dependencies. As a first step, try to identify (and root out) unnecessary headers.

Many programmers habitually #include many more headers than necessary. Unfortunately, doing so can seriously degrade build times, especially when a popular header file includes too many other headers.

In the following header file, which #include directives could be immediately removed without ill effect? You may not make any changes other than removing or rewriting #include directives. Note that the comments are important.

//  x.h: original header 


//


#include <iostream>


#include <ostream>


#include <list>


// None of A, B, C, D or E are templates.


// Only A and C have virtual functions.


#include "a.h"  // class A


#include "b.h"  // class B


#include "c.h"  // class C


#include "d.h"  // class D


#include "e.h"  // class E


class X : public A, private B


{


public:


     X( const C& );


  B  f( int, char* );


  C  f( int, C );


  C& g( B );


  E  h( E );


  virtual std::ostream& print( std::ostream& ) const;


private:


  std::list<C> clist_;


  D            d_;


};


inline std::ostream& operator<<( std::ostream& os, const X& x )


{


  return x.print(os);


}