¿Por qué no puedo ver esta excepción?

Question

Quiero crear una serie de tipos de excepciones que se derivan de std :: runtime_error y quiero que tengan la funcionalidad de tipo de secuencia de cadenas. Por lo tanto, he creado una clase de excepción de que consta un std::stringstream y que se deriva de std::runtime_error:

template<typename T> 
class error_stream : public std::runtime_error 
{ 
public: 
     error_stream() : 
     std::runtime_error(""), ss(std::make_shared<std::basic_stringstream<T>>()) 
     { 
     } 

     ~error_stream() throw() 
     { 
     } 

     template <typename T> 
     error_stream & operator << (const T & t) 
     { 
      *ss << t; 
      return *this; 
     } 

     virtual const char * what() const throw() 
     { 
      get_str(s_, ss->str()); 
      return s_.c_str(); 
     } 

protected: 

    template <typename T> 
    void get_str(std::basic_string<char> & s_, const std::basic_string<T> & str) const 
    { 
     s_ = str; 
    } 

    template<> 
    void get_str(std::basic_string<char> & s_, const std::basic_string<wchar_t> & str) const 
    { 
     std::basic_string<char> ret(str.begin(), str.end()); 
     s_ = ret; 
    } 

protected: 
    std::shared_ptr<std::basic_stringstream<T>> ss; 
    mutable std::basic_string<char> s_; 
}; 

Y he creado un tipo de excepción más específica que a su vez deriva de este error_stream excepción:

template<typename T> 
class w32file_exception : public w32utils::error_stream<T> 
{ 
public: 
    w32file_exception() : error_stream<T>() {} 
}; 

Sin embargo, me he encontrado con algo que no entiendo aquí, porque cuando lanzo un w32file_exception en realidad solo puedo verlo ya que es el padre error_stream. ¿Alguien puede ver lo que estoy haciendo mal?

try 
    { 
     throw w32file_exception<char>() << "test"; 
    } 
    catch (w32file_exception<char> & e) 
    { 
     ASSERT_PASSED; 
    } 
    catch (error_stream<char> & e) 
    { 
     std::cout << e.what() << std::endl; // Why do I end up here? 
    } 

Answer 1

Qué hace exactamente su throw parece? ¿Está utilizando su operator<< antes de llamar a tiro, así:

throw w32file_exception<T>() << "fooobar"; 

entonces la respuesta es, que sus operator<< devuelve un error_stream y sin w32file_exception por lo que el tipo de la excepción lanzada es error_stream.

Se puede resolver este problema de esta manera:

template<typename T, typename DERIVED> 
    class error_stream : public std::runtime_error 
{ 
public: 
    // ... 
    template <typename U> 
     DERIVED & operator << (const T & t) 
    { 
     *ss << t; 
     return static_cast<DERIVED&>(*this); 
    } 
    // ... 
}; 

Pero entonces perder la capacidad de captar cada error_stream excepción porque es un nuevo tipo para cada tipo DERIVED.