try/catch to avoid .stackdump

Question

In the code below i use try/catch in the python module code. In the try block i have a simple error (memory access violation) and trying to catch the corresponding exception and to terminate the program quietly without generation of the .stackdump file. However the latter is still generated what implies that try/catch construct does not do its job. How could i avoid generating .stackdump file and exit the program without errors when the improper operation (like one in the code) is met? P.S. i'm compiling the code in cygwin with gcc and boost.python

It is interesting that it doesn't work only in case x[3]=2, but works for all other cases: e.g. x[4]=2 or x[20]=2 or, obviously, x[2]=2.

#include <boost/python.hpp>
#include <iostream>
#include <iomanip>
using namespace std;
using namespace boost::python;


class Hello
{
    std::string _msg;

public:

    Hello(std::string msg){_msg = msg;}

    void run(){
      try{  

        double* x;
        x = new double[3];
        x[3] = 2.0;
        delete [] x;


      }catch(...){  exit(0);   }

    }

};


BOOST_PYTHON_MODULE(xyz)
{
    class_<Hello>("Hello", init<std::string>())
        .def("run",&Hello::run)
    ;  

}

EDIT:

According to what Maciek has suggested i tried the following trick:

Make signal handling function to throw an exception, but not exit

void sig_action(int signo) {
    std::cout << "SIGNAL " << signo << std::endl;
    throw 1;
//    exit(0);
}

And now try to enclose a possibly problematic function in try/catch block (signal function is placed in class constructor):

class Hello
{
    std::string _msg;

public:

    Hello(std::string msg){
    _msg = msg;
      signal(SIGABRT, sig_action);
      signal(SIGSEGV, sig_action);

    }
    void set(std::string msg) { this->_msg = msg; }
    std::string greet() { return _msg; }

    void run(){

      try{  
        double* x;
        x = new double[3];
        x[3] = 2.0;
        delete [] x;

      }catch(...){ cout<<"error in function run()\n"; exit(0);   }

    }

};

However such a trick doesn't work as i expected it produces the following output:

SIGNAL 6
terminate called after throwing an instance of 'int'
SIGNAL 6
terminate called recursively
SIGNAL 6
terminate called recursively
....
(and many more times the same)

So the exception is thrown, but everything finishes before it has been caught. Is there any way to let it be caught before terminating the process?

Answer 1

You can only catch exceptions that are thrown. An invalid pointer access doesn’t throw an exception, it simply causes undefined behaviour, and in your particular case it results in a stack dump.

If you want to catch such a situation situation, use std::vector and the at function to access items. This will throw std::out_of_range when used with an invalid index. However, it’s usually better to avoid the possibility of such accesses a priori since they are usually indicative of a bug in your program, and bugs should not be handled via exceptions, they should be removed from the code.

Answer 2

On linux core dumps are generated by signal handlers with default action set to core (SIGABRT, SIGSEGV, ...). If you want to avoid core dump you can always capture/ignore those signals. It should work on Cygwin stackdumps as well. But you will still probably get some nasty message as output.

EDIT:

#include <signal.h>

// [...]

void sig_action(int signo) {
    std::cout << "SIGNAL " << signo << std::endl;
    exit(0);
}

int main(int argc, char* argv[]) {
    signal(SIGABRT, sig_action);
    signal(SIGSEGV, sig_action);

    Hello h("msg");
    h.run();
}