Quote:Original post by FlowingOoze
If I'm not mistaken, you actually need to use reference, since the exception might be a subtype of CException (or whatever you use).
#include <exception>#include <iostream>#include <string>#include <typeinfo>namespace exceptional{ class exception : public std::exception { private: friend class hack; mutable std::string str; void prepend(const std::string & pre) const { str=pre+str; }; public: exception(const std::string & what) : str(what) {}; virtual const char * what() const throw() { return str.c_str(); }; virtual ~exception() throw() {}; }; class hack { private: std::string msg; public: hack(const char * m) : msg(m) {}; template<class T> const T & operator || (const T & e) { e.prepend(msg); return e; } };};#define STRINGIFY1(line) #line#define STRINGIFY2(line) STRINGIFY1(line)#define THROW throw exceptional::hack( __FILE__ ":" STRINGIFY2(__LINE__) ": " ) || struct MyException : public exceptional::exception{ MyException(const std::string & msg) : exceptional::exception(msg) {};};using namespace std;void foo(){ THROW MyException("Boo");}main(){ try { foo(); } catch(const exception & e) { cout << typeid(e).name() << " " << e.what() << endl; }}#include <stdexcept>#include <iostream>#include <string>#include <typeinfo>namespace exceptional{ class hack { private: std::string msg; public: hack(const char * m) : msg(m) {}; template<class T> void operator || (const T & e) { throw T(msg+e.what()); } };};#define STRINGIFY1(line) #line#define STRINGIFY2(line) STRINGIFY1(line)#define THROW exceptional::hack( __FILE__ ":" STRINGIFY2(__LINE__) ": " ) || struct MyException : public std::logic_error{ MyException(const std::string & msg) : std::logic_error(msg) {};};using namespace std;void foo(){ THROW MyException("Boo");}main(){ try { foo(); } catch(const exception & e) { cout << typeid(e).name() << " " << e.what() << endl; }}
Quote:Original post by FlowingOoze
I personally derive most of my exceptions from std::runtime_error, since it comes with a constructor that takes a string for what() (so i don't have to write it my self. Call me lazy. ;)
class Sprite{public: class SpriteException { //blah blah }; //blah blahprivate: //blah blah};class SpriteException{ //blah blah};class Sprite{public: //blah blahprivate: //blah blah};Quote:Original post by FlowingOoze
Naming exceptions only makes sense if you're actually going to catch them.
Ie. if you'll ever write something like catch(Sprite::SpriteException), which is be pretty ackward. If you really need exception classes that are thrown only by specific classes, then it might be worth it.
