Question

I often want to define new ‘Exception’ classes, but need to have an appropriate constructor defined because constructors aren’t inherited.

class MyException : public Exception  {  public:   MyException (const UString Msg) : Exception(Msg)   {   }; } 

Typedefs don’t work for this, because they are simply aliases, not new classes. Currently, to avoid repeating this trivial boilerplate, I use a #define which does the donkeywork.

#define TEXCEPTION(T) class T : public Exception \ { \ public:\     T(const UString Msg) : Exception(Msg) {}; \ }  ...  TEXCEPTION(MyException); 

But I keep wondering if there’s a better way of achieving this – maybe with templates, or some new C++0x feature

Answer 1

If you really want to have new classes derived from Exception, as opposed to having a template parameterized by a parameter, there is no way around writing your own constructor that just delegates the arguments without using a macro. C++0x will have the ability what you need by using something like

class MyException : public Exception  {  public:     using Exception::Exception; }; 

You can read about the details of that (seem to have quite a bit of extra rules) in 12.9 ‘Inheriting Constructors’ in the latest draft of C++0x.

_{In the meantime, i would recommend a policy based design (made small text, because the OP accepted the above, and not this policy stuff):}

// deriving from Impl first is crucial, so it's built first // before Exception and its Ctor can be used. template<typename Impl> struct ExceptionT : Impl, Exception {     // taking a tuple with the arguments.     ExceptionT(arg_types const& t = arg_types())         :Exception(Impl::Ctor(t)) { }     // taking a string. plain old stuff     ExceptionT(std::string const& s):Exception(Impl::Ctor(s)) { } };  struct ExceptionDefImpl {     typedef boost::tuple<> arg_types;      // user defined ctor args can be done using a tuple     std::string Ctor(arg_types const& s) {         return std::string();     }      std::string const& Ctor(std::string const& s) {         return s;     } };  // will inherit Ctor modifier from DefImpl. struct MemoryLost : ExceptionDefImpl {      typedef boost::tuple<int> arg_types;      std::string Ctor(arg_types const& s) {         std::ostringstream os;         os << 'Only ' << get<0>(s) << ' bytes left!';         return os.str();     }      int getLeftBytes() const { return leftBytes; } private:     int leftBytes; };  struct StackOverflow : ExceptionDefImpl { };  // alias for the common exceptions typedef ExceptionT<MemoryLost> MemoryLostError; typedef ExceptionT<StackOverflow> StackOverflowError;  void throws_mem() {     throw MemoryLostError(boost::make_tuple(5)); }      void throws_stack() { throw StackOverflowError(); }  int main() {     try { throws_mem(); }      catch(MemoryListError &m) { std::cout << 'Left: ' << m.getLeftBytes(); }     catch(StackOverflowError &m) { std::cout << 'Stackoverflow happened'; } }