ich habe ein kleines Problem mit einem inneren enum. Folgende 4 Dateien habe ich:

//---------- Logger.h ----------
class Logger {
public:
   enum LEVEL { LEVEL_ALL, 
		LEVEL_DEBUG, 
		LEVEL_INFO, 
	     };
   void callAppenders(const LoggingEvent& logEvent) const;

   void log(LEVEL level, const std::string& message);	
};

//---------- Loger.cpp ----------
#include "Logger.h"
#include <cassert>
#include "Appender.h"

/* hier stehen jetzt alle Methodendefinitionen von Logger */

//---------- Appender.h ----------
#include "Logger.h"
class LoggingEvent;

class Appender {
public:
   virtual void doAppend(const LoggingEvent& logEvent) = 0;
};

struct LoggingEvent {
   const Logger::LEVEL	_level;

   LoggingEvent(Logger::LEVEL level, const std::string& message);
};

//--------- Appender.cpp -----------
#include "Appender.h"

/* Definitionen von Appender und LoggingEvent

Das Problem ist nun: Ich will, dass ich nur in meinen anderen Dateien nur noch Logger.h inkludieren muss (im Moment muss ich immer Logger.h UND Appender.h inkludieren).
Ich will also Appender.h in Logger.h inkludieren. Das geht aber leider nicht, weil es dann an dieser Stelle einen Compilerfehler in Loggingevent gibt:

const Logger::LEVEL _level;

Ist ja auch klar, denn die Deklaration von Logger.h kommt ja erst noch. Ich habs mit einer Forward declaration probiert (enum Logger::LEVEL), aber das gibt auch einen Compilerfehler.
Gibt es eine Möglichkeit das elegant zu lösen? (also das Logger.h Appender.h inkludiert)

Kannst du "Appender.h" nicht erst nach der Klassendefinition von Logger einbinden? Dann wäre die Enumeration bekannt.

Grüssli