Suppose I have the following class:

Foo.h:

```
class MyVectorClass;

class Foo {
public:
    MyVectorClass get();
    ...
}

```

Following the commonly agreed pattern to forward declare everything that can be forward declared, and since `MyVectorClass` is used only as a return type of a method, `MyVectorClass` is forward declared. Then, any user of this class should include `MyVectorClass.h` to be able to use the method `get`.

Bar.cpp:

```
#include "Foo.h"
#include "MyVectorClass.h"

Foo foo;
...
MyVectorClass result = foo.get();

```

The fact that in order to use class `Foo` we need to include some additional headers makes me question the idea of a forward declaration here. This is even more confusing for me if I use auto instead of `MyVectorClass`, which is preferable since I don't really care about `MyVectorClass` much, anything with a vector-like interface is good enough for me.

```cpp
#include "Foo.h"
#include "MyVectorClass.h"

Foo foo;
...
auto result = foo.get();

```

When reading this code, it's very hard to find out why do we include `MyVectorClass.h`. And when the interface of `Foo` changes, and `get` starts to return `AnotherVectorClass`, or `std::vector`, we should remove the old `MyVectorClass.h` in every user of the get method and include an appropriate new header instead.

Is forward declaration really worth it here?