class ATANCamera;
class Map;
class MapMaker;
class Tracker;
class ARDriver;
class MapViewer;

class System
{
public:
  System();
  void Run();

Damit teilst du dem Compiler mit, dass es diese Klassen gibt, ohne dass du dafür den entspechenden Header einbinden musst. Das musst du dann erst in der cpp-Datei machen, wenn du die Klassen tatsächlich verwendest.

Reicht es nicht aus die Header-Datei der jeweiligen Klasse in der cpp-Datei einzubinden ?

Wenn eine solche Klasse bspw. als Rückgabewert einer Methode deklarieren willst, reicht das nicht.

EDIT: falsch gelesen. Siehe Antwort von Daddy_felix. Meine Antwort gilt natürlich trotzdem.

Antwort: wenn es egal ist, wie die Klasse im Detail aussieht. Mit einer Vorwärtsdeklaration kannst du beispielsweise Zeiger auf diese Klasse verwenden:

class foo;
foo* ptr;

In einer Klasse ergibt das natürlich mehr Sinn, da der Pointee in der .cpp definiert werden kann. Hier muss natürlich die gesamte Klasse bekannt sein.
Ein Beispiel (schlechtes Design, don't try this at home):

// foo.hpp
class foo
{
    foo();
};

// foo.cpp
#include "foo.hpp"

foo::foo()
{
    // some code
}

// bar.hpp
class foo;

class bar
{
    bar();
    foo* foo_ptr;
};

// bar.cpp

#include "bar.hpp"
#include "foo.hpp"

bar::bar()
{
    foo_ptr = new foo;
}

Für Vollständigkeit: Warum ist das schlechtes Design? -> Hier gibt es keinen Grund, foo nicht als direkten Member von bar zu verwenden. Hier muss man noch einen Destruktor, einen Copy-Constructor und Zuweisungsoperator schreiben. Unnötig.

// bar.hpp

#include "foo.hpp"

class bar
{
    foo f;
}

// bar.hpp
class foo;

class bar
{
    barFct(foo* foo_ptr);
};

Ich würde sogar empfehlen Vorwärtsdeklarationen zu bevorzugen und den Header erst dann einzubinden, wenn es erforderlich ist, dass die Klasse vollständig ausdefiniert ist (kann ziemlich nervig sein das bei einem größeren Projekt nachträglich zu machen).

Finnegan

Gerne auch über spezielle "forward.hpp" Headers die Vorwärtsdeklarationen für alles was in einem Projekt/Modul/Namespace definiert wird enthalten.
enum s müssen dann halt ganz in diese "forward.hpp" Header verschoben werden. Das ist hässlich, stellt aber normalerweise kein echtes Problem dar.

Nur wenn man nested classes hat, und Zeiger/Referenzen auf diese ausserhalb der deklarierenden Klasse bräuchte, dann muss man halt weinen gehen

// Wäre fein, aber leider nein :(
class outer::inner;

// Und weil wir gerade dabei sind..., auch leider nein:
namespace foo::bar {

namespace foo {
namespace bar {
// Bäh! Viel schöner (UND praktischer) wäre:
namespace foo::bar {

Das hat jetzt mit Funktionalität nixe zu tun, aber es wäre angenehm.
U.a. könnte man dann die automatische Einrückung von Namespace-Content sinnvoll in Kombination mit Project::Module::SubModule Namespace-Hierarchien nutzen.
(Wer will schon den ganzen Content in allen Project/Module/SubModule/*.cpp Files 3-fach eingerückt haben, nur weil SubModule ein Namespace in einem Namespace in einem Namespace ist? Und wer will schon 3x namespace schreiben müssen dafür?)

ps: Sorry wegen OT

IIRC gibt's da ein angenommenes Proposal für C+++17 für.

Es gibt ein Proposal von 2003 das abgelehnt wurde.

Frage: wie bekommt man raus wie der Status von so einem Proposal ist?

EDIT: ARGH. OK. Auf http://en.wikipedia.org/wiki/C%2B%2B17 ist es unter "expected features" gelistet Aber wie findest man es allgemein raus, also ohne zufällig auf einer Seite wie Wikipedia etwas darüber zu finden?