Vermeiden von Makros für nahezu identische Klassendefinitionen

Question

ich eine Basisklasse für Ausnahmen haben:

class BaseException : public std::runtime_error 
{ 
public: 

    BaseException(int Code, std::string Msg) : runtime_error(Msg); 

    //...etc 
}; 

In jeder Klasse, die Ausnahmen braucht, binde ich eine Exception Klasse, die von BaseException erbt:

class Foo 
{ 
public: 

    class Exception : public BaseException 
    { 
    public: 

     Exception(int Code, std::string OptMsg = "") : BaseException(Code, OptMsg); 

     enum 
     { 
      Fire, 
      Flood, 
      Aliens 
     }; 
    }; 

    //...etc 
}; 

So Jetzt kann ich throw(Exception::Fire) innerhalb Foo und fangen nach Basisklasse oder durch Foo::Exception& und zum Beispiel mit Foo::Exception::Fire vergleichen.

Die Klassendefinition Exception ist fast immer identisch, nur der Inhalt des Enums ändert sich. Wegen DRY, dachte ich einen Makro zu schreiben, die so etwas wie dies ermöglicht:

EXCEPTIONS 
Fire, 
Flood, 
Aliens 
END_EXCEPTIONS 

Allerdings sind Makros verpönt in C++. Gibt es einen besseren Weg?

Answer 1

Sie können die BaseException-Konstruktoren mit dem Schlüsselwort using "erben", anstatt sie manuell neu zu implementieren. Dies sollte Ihnen ein wenig Tipparbeit ersparen. Der Rest des Boilerplate ist ziemlich minimal, also würde ich mir persönlich keine Sorgen machen.

struct Foo { 
    struct Exception : BaseException { 
    using BaseException::BaseException; 
    enum { 
     Fire, 
     Flood, 
     Aliens 
    }; 
    }; 
}; 

Answer 2

Wie wäre:

template <typename T> 
struct Exception : BaseException 
{ 
    Exception(int Code, std::string OptMsg = "") : BaseException(Code, OptMsg); 
}; 

class Foo 
{ 
public: 

    using Exception = ::Exception<Foo>;  
    enum ExceptionCodes 
    { 
     Fire, 
     Flood, 
     Aliens 
    }; 

    //...etc 
}; 

(oben ungesehen durch einen Compiler)

Der einzige Unterschied ist, dass Sie Foo::Fire oder Foo::ExceptionCodes::Fire beziehen haben.

Sie könnten ohne die using Anweisung, und nur unter Exception<Foo>.