#include <boost/config.hpp>

#include <exception>
#include <string>

namespace http {

class exception : public std::exception
{
public:
  exception(const std::string& msg) : _msg(msg) {}

  /* virtual */ const char* what() const override BOOST_NOEXCEPT
  {
    return _msg.c_str();
  }

private:
  const std::string _msg;
};

// ...

} // namespace http

#define MY_THROW(Ex) \
  throw Ex << base_exception::location_info(debug::location(__FILE__, BOOST_CURRENT_FUNCTION, __LINE__)) \
           << base_exception::trace_info(debug::get_call_stack())

class base_exception
  : virtual public std::exception
  , virtual public boost::exception
{
public:
  typedef boost::error_info<struct tag_backtrace, std::vector<std::string>> trace_info;
  typedef boost::error_info<struct tag_location, debug::location> location_info;
  typedef boost::error_info<struct tag_reason, std::string> reason_info;

  static reason_info reason(const std::string& str)
  {
    return reason_info(str);
  }

  template <typename T>
  const typename T::value_type* get() const
  {
    return boost::get_error_info<T>(*this);
  }

  const std::vector<std::string>& call_stack() const
  {
    if (const std::vector<std::string>* result = get<trace_info>())
    {
      return *result;
    }
    return std::vector<std::string>();
  }

  virtual std::string reason() const
  {
    if (const std::string* result = get<reason_info>())
    {
      return *result;
    }
    return std::string();
  }

  const debug::location& where() const
  {
    if (const debug::location* result = get<location_info>())
    {
      return *result;
    }
    return debug::location();
  }

  virtual const char* what() const throw() override
  {
    return boost::diagnostic_information_what(*this);
  }
};

class some_exception : public base_exception {};

MY_THROW(some_exception())
      << base_exception::reason("Some exception");

#define MY_THROW(Ex) \
  throw Ex << base_exception::location_info(debug::location(__FILE__, BOOST_CURRENT_FUNCTION, __LINE__)) \
           << base_exception::original_type_info(typeid((Ex)).name()) \
           << base_exception::trace_info(debug::get_call_stack())

void sometimes_throws(int arg, std::error_code& ec = throws());

int main() {
  // throw if failed:
  try {
    sometimes_throws(0);
  } catch(std::system_error& e) {
      std::cerr << e.code();
  }

  // do not throw:
  std::error_code ec;
  sometimes_throws(0, ec);
  std::cerr << ec;
}

FH>#include <boost/config.hpp>

FH>#include <exception>
FH>#include <string>

FH>namespace http {

FH>class exception : public std::exception
FH>{
FH>public:
FH>  exception(const std::string& msg) : _msg(msg) {}

FH>  /* virtual */ const char* what() const override BOOST_NOEXCEPT
FH>  {
FH>    return _msg.c_str();
FH>  }

FH>private:
FH>  const std::string _msg;
FH>};

FH>// ...

FH>} // namespace http
FH>

// создание плоской иерархии
template<class Tag> class tagged_exception : public std::exception { ..... };

struct foo_ex_tag {};
struct bar_ex_tag {};

try { ... throw tagged_exception<foo_ex_tag>("oh deer"); ... }
catch(tagged_exception<foo_ex_tag> const& e) { ... e.what() ... }

// миксины
template<class MixIn, class CtorArg = MixIn> class mixed_exception : public std::exception, public MixIn { ..... };

struct foo_mixin { /* дополнительные поля */ };

try { ... throw mixed_exception<foo_mixin>( foo_mixin(1,2,3) ); ... }
catch(mixed_exception<foo_mixin> const& e) { ... e.foo_member ... };

// CRTP

template<class Final> class curious_exception : public std::exception { .... static_cast<Final*>(this) ..... };

struct foo_exception : curious_exception<foo_exception> { ..... };

try { ... throw foo_exception("let eat bee", 1,2,3); ... };
catch(foo_exception const& e) { ... e.foo_member ... };

catch(e){ if(!we_can_handle(e)) throw; } ... }

FH>class exception : public std::exception
FH>{
FH>public:
FH>  exception(const std::string& msg) : _msg(msg) {}

FH>  /* virtual */ const char* what() const override BOOST_NOEXCEPT
FH>  {
FH>    return _msg.c_str();
FH>  }

FH>private:
FH>  const std::string _msg; // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
FH>};

#define STR_(t) #t
#define STR(t) Str_(t)
#define MY_THROW(type, msg) \
   throw type(__FILE__ "(" STR(__LINE__) "): " msg)

void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
        {       // try to allocate size bytes
        void *p;
        while ((p = malloc(size)) == 0)
                if (_callnewh(size) == 0)
                {       // report no memory
                static const std::bad_alloc nomem;
                _RAISE(nomem);
                }

E>Ну и, опять же, лично я сторонник широко использовать штуку вроде assert, вроде, а не сам по себе assert, потому, что оно должно проверять условие не только в дебаг-версии, а всегда. Ну, например, её можно называть StrongAssert, скажем...

#include <vector>
#include <iostream>
int main()
{
    std::vector< int> v;
    std::cout << "v.at(0) = " << v.at(0) << '\n';
    return 0;
}

#include <iostream>
#include <typeinfo>
struct Base {};
struct Derived: Base {};
int main() {
  try {
    std::cout << "thrown: " << typeid(Derived).name() << std::endl;
    throw Derived();
  }
  catch (const Base& e) {
    std::cout << "caught: " << typeid(e).name() << std::endl;
  }
}

thrown: Derived
caught: Base

struct Err : std::exception {
    Err(const char* p) : msg_(p) {}
    
    const char* msg_;
};

...

throw Err("some error message");

...

catch(Err const& e) {
    std::cout << e.msg_ << std::endl;  // должно вывести some error message
}

#include <exception>
#include <iostream>
#include <typeinfo>

class Base : public std::exception {};
class Derived: public Base {};

int main()
{
  try
  {
    throw Derived();
  }
  catch (const Base& ex)
  {
    std::cout << typeid(ex).name() << '\n';
  }
}

class Derived