You might want to read about the separation of interface from implementation. Abstract base classes play a big part in this.
In the extreme case you have classes which are only pure virtual functions; this is the C++ way of implementing an interface (something languages like C# and Java have a specific keyword for). Obviously you can never instantiate an interface. Abstract base classes with some implementation act similarly, in that they define an interface; but in addition provide some base functionality for their derived classes to use.
Using an interface allows you to define the behaviour of the class (what it can do) without dictating how it's implemented (how it's done.) They also allow you to more effectively decouple components (and ensure they stay nicely decoupled!)
To take a simple example; if you have a class which uses a std::map and std::vector internally but not for any of the parameters in its public methods, client code will still have to include <map> and <vector> (or have them included for them) to be able to compile their code.
If the public methods are factored out into an abtract base class which doesn't include the parts which uses std::map, then it will be possible to compile the client code without these dependencies.
While it's no big deal for two header files (esp. such common ones), when you apply this approach to lots of headers in more complicated projects it can reduce interdependencies considerably.
Separating Interface and Implementation in C++