无法捕获自定义std :: runtime_error

Question

In my code I throw my custom file_error exception, which is derived from std::runtime_error. In a different module I catch exceptions for that operation and want to handle my file_error like this:

try
{
  base::create_directory(INVALID_NAME, 0700);
  ...
}
catch (const base::file_error &exc)
{
   ...
}
catch(std::runtime_error &exc)
{
    ...
}
catch(std::exception &exc)
{
  ...
}

file_error is declared as:

namespace base {
class file_error : public std::runtime_error
{
  int sys_error_code;
  public:
    file_error(const std::string &text, int err);

    error_code code();
    int sys_code();
};
}

However, the catch branch for file_error is never triggered. Either I end up in the runtime_error branch or, if I remove that, in the exception branch.

However, this works fine in Linux + Win (gcc, VS) while it does not work on Mac (clang). Any idea what could be wrong here?

Update:

Here's the lldb output when I reach the runtime_error branch:

(lldb) p exc
(const base::file_error) $0 = {
  std::runtime_error = {
    __imp_ = (__imp_ = 0x0000000000000000)
  }
  sys_error_code = 13923331
}

That clearly indicates the exception is indeed of type base::file_error. It's just not catched in its associated catch block.

Update 2:

Declaring an own error based on file_error in the same file as the test code above like this:

class test_error : base::file_error {

public:
  test_error(const std::string &s) : base::file_error(s, 0) {};
};

allows me to catch it in a test_error block and in a catch-all block, but not in base::file_error, std::runtime_error or std::exception blocks. Weird.

Update 3:

After a lot of experimenting I now think this is a type mismatch issue, similar to the ODR-violation but a different kind. The types in the dylib and in the test app are not considered the same and hence the exception is not catched, unless I throw that base::file_error exeption directly in the test code.

Answer 1

class test_error : base::file_error 

allows me to catch it in a test_error block and in a catch-all block, but not in base::file_error, std::runtime_error or std::exception blocks.

Your exception classes need to derive publicly from base exception classes. Otherwise you won't be able to catch them via the base class:

class test_error : public base::file_error 

Answer 2

The solution for this problem is to avoid using the compiler option -fvisibility=hidden (or make it default) in the test application. Read more about this here: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options . In particular this part:

Note that -fvisibility does affect C++ vague linkage entities. This means that, for instance, an exception class that is be thrown between DSOs must be explicitly marked with default visibility so that the 'type_info' nodes are unified between the DSOs.

An overview of these techniques, their benefits and how to use them is at http://gcc.gnu.org/wiki/Visibility .