CODEWITHSUNDEEP
c++exception
Deve
Deve

Reputation: 4648

Why is my exception caught on some configurations and on others is not?

I have a program throwing an exception that is caught on some configurations (Suse Linux, g++ version 4.4.1) as expected but is obviously not caught on another, here: SunOS 5.10, g++ version 3.3.2. Following is the implementation of my exception class:

CException.hpp:

#ifndef _CEXCEPTION_HPP
#define _CEXCEPTION_HPP

#include <string>
#include <sstream>
#include <exception>
#include <stdlib.h>
#include <iostream>

class CException : public std::exception {
public:
    CException();
    CException(const std::string& error_msg);
    CException( const std::stringstream& error_msg );
    CException( const std::ostringstream& error_msg );
    virtual ~CException() throw();
    const char* what() const throw();
    static void myTerminate()
    {
        std::cout << "unhandled CException" << std::endl;
        exit(1);
    };
private:
  std::string m_error_msg;

};

CException.cpp:

#include "CException.hpp"
#include <string>
#include <sstream>

CException::CException()
{
    std::set_terminate(myTerminate);
    m_error_msg = "default exception";
}

CException::CException(const std::string& error_msg)
{
    std::set_terminate(myTerminate);
    m_error_msg = error_msg;
}

CException::CException(const std::stringstream& error_msg)
{
    std::set_terminate(myTerminate);
    m_error_msg = error_msg.str();
}

CException::CException(const std::ostringstream& error_msg)
{
    std::set_terminate(myTerminate);
    m_error_msg = error_msg.str();
}

CException::~CException() throw()
{
}

const char* CException::what() const throw()
{
    return m_error_msg.c_str();
}
#endif  /* _CEXCEPTION_HPP */

Unfortunately, I've not been able to create a simple program to reproduce the issue, but I will try to outline the code. The exception is thrown in a function foo() in some file Auxiliary.cpp:

std::ostringstream errmsg;
//...
errmsg << "Error occured.";
throw CException( errmsg );

Function foo() is used in the main program:

#include Auxiliary.hpp
//...
int main( int argc, char** argv )
{
  try {
    //...
    foo();
  } catch ( CException e ) {
    std::cout << "Caught CException" << std::endl;
    std::cout << "This is the error: " << e.what( ) << std::endl;
  } catch ( std::exception& e ) {
    std::cout << "std exception: " << e.what( ) << std::endl;
  } catch ( ... ) {
    std::cout << "unknown exception: " << std::endl;
  }

I can see that the exception isn't caught as the program exits with printing unhandled CException which is defined by myTerminate().

I've tried the -fexceptions option to the GNU compiler without success. The compiler options are actually the same on both systems.

At the moment I just can't figure out what the problem is. Any ideas are appreciated. Thanks!

Upvotes: 4

Views: 385

Answers (1)

Deve
Deve

Reputation: 4648

I've found out that the problem is caused by the use of a Fortran95 compiler. It is used as a linker when building the program on a Sun machine, on other machines g++ is used. I have no idea what exactly the problem is but I think I'll just switch to g++ on the Sun machines as well.

Upvotes: 1

Related Questions