Uncaught exceptions

I could look it up, but do you happen to know what happens if there is no exception handler for an exception that is thrown?

#include <stdexcept>                                                                                   
#include <iostream>                                                                                    
                                                                                                       
struct MyRTExc: public std::runtime_error { MyRTExc(): std::runtime_error("") {} };                    
struct MyOwnExc { };                                                                                   
                                                                                                       
int main()                                                                                             
{                                                                                                      
  int step = 0;                                                                                        
  try {                                                                                                
    step = 1;                                                                                          
    throw MyOwnExc();                                                                                  
    step = 2;                                                                                          
    throw MyRTExc();                                                                                   
    step = 3;                                                                                          
  }                                                                                                    
  catch(std::exception exc)                                                                            
  {                                                                                                    
    std::cerr << "probably MyRTExc" << std::endl;                                                      
  }                                                                                                    
  std::cerr << "step=" << step << std::endl;                                                           
  return 0;                                                                                            
}                                                                                                      

[Note: I corrected the syntax today]

Without trying it out: It just could be, that step=2 in the end, right? Because I have no exception handler installed for MyOwnExc the code just continues with the next instruction after the throw. The next throw behaves as exptected and leaves before step=3 so the final step would be 2.

Guideline: Install exception handlers for any exceptions that you throw.

Update: The relevant section in the C++ Specification is "15.5.1" which says that when no fitting handler can be found terminate() must be called. But I think the above guideline still stands, at least for good programming style reasons.