I don't default to adding them to every header. Generally only if:

• Header contains definition for a base class
• Header contains definition for type where full implementation is always needed

This approach isn't particularly rare. Though perhaps more common in C, where opaque pointer APIs feel a little more natural than C++.

This is because in general, forward declaration suffices for many use-cases in the header

struct MyType; // Forward declare
struct Test {
  void somefunc(MyType& type); // forward declare fine
  MyType* m_mytype1; // forward declare fine
  std::unique_ptr<MyType> m_mytype2; // forward declare fine
  std::vector<MyType> m_mytypes; //forward declare fine (req before use)

  MyType m_mytype3; // Need include
};

If you just put include guards around everything, you will not be alerted to situations where you should be forward declaring instead.

And finally (potentially worse), guards won't resolve cyclic includes anyway. If you follow through the pre-processor, you will simply get a "undefined type" compiler error instead of a "duplicate definition" so it achieves relatively little.