How can I abstract out a repeating try catch pattern in C++ - c++

Question

I have a pattern that repeats for several member functions that looks like this:
int myClass::abstract_one(int sig1)
{
try {
return _original->abstract_one(sig1);
} catch (std::exception& err) {
handleException(err);
} catch (...) {
handleException();
}
}
bool myClass::abstract_two(int sig2)
{
try {
return _original->abstract_two(sig2);
} catch (std::exception& err) {
handleException(err);
} catch (...) {
handleException();
}
}
[...]
int myClass::abstract_n(bool sig3a, short sig3b)
{
try {
return _original->abstract_n(sig3a, sig3b);
} catch (std::exception& err) {
handleException(err);
} catch (...) {
handleException();
}
}
Where abstract one through n are methods of a pure virtual abstract interface for which myClass and _original are concrete implementations.
I don't like that this pattern repeats in the code and would like to find a way to eliminate the repeating try / catch pattern and code as a single abstraction, but I can't think of a good way to do this in C++ without macros. I would think that there is a way with templates to do this better.
Please suggest a clean way to refactor this code to abstract out the repeated pattern.

Answer 1

I asked a very similar conceptual question, see Is re-throwing an exception legal in a nested 'try'?.
Basically, you can move the various exception handlers to a separate function by catching all exceptions, calling the handler and rethrowing the active exception.
void handle() {
try {
throw;
} catch (std::exception& err) {
handleException(err);
} catch (MyException& err) {
handleMyException(err);
} catch (...) {
handleException();
}
}
try {
return _original->abstract_two(sig2);
} catch (...) {
handle();
}
It scales well with more different exception kinds to differenciate. You can pack the first try .. catch(...) into macros if you like to:
BEGIN_CATCH_HANDLER
return _original->abstract_two(sig2);
END_CATCH_HANDLER

Answer 2

One option, if there are a limited number of function arities, would be to use a function template:
template <typename ReturnT, typename ClassT>
ReturnT call_and_handle(ClassT* obj, ReturnT(ClassT::*func)())
{
try {
return (obj->*func)();
}
catch (const std::exception& ex) {
handleException(ex);
}
catch (...) {
handleException();
}
return ReturnT();
}
This assumes that handleException is some non-member function, but it is easy to modify it if it is a member function. You need to decide what call_and_handle returns if an exception is handled; I have it returning an initialized ReturnT as a placeholder.
This reduces your member functions to:
int myClass::abstract_one()
{
return call_and_handle(_original, &myClass::abstract_one);
}
You would need a separate function template for calling functions that have one parameter, two parameters, etc.
If you have functions that have an unwieldy number of parameters and you were really desperate, you could use a macro (I wouldn't really recommend this, though):
#define CALL_AND_HANDLE(expr) \
try { \
return (expr); \
} \
catch (const std::exception& ex) { \
handleException(ex); \
} \
catch (...) { \
handleException(); \
}
Which can be used as:
int myClass::abstract_one()
{
CALL_AND_HANDLE(_original->myClass::abstract_one());
}
As an aside, if you catch (...) and do not rethrow the caught exception, you should in most cases terminate the program.

Answer 3

As a variant on Alexander Gessler's solution you can omit some of the braces that make this implementation a little long. It does exactly the same thing, just with a little less { } verbage.
void handle() try
{
throw;
}
catch (std::exception& err)
{
handleException(err);
}
catch (MyException& err)
{
handleMyException(err);
}
catch (...)
{
handleException();
}
int myClass::abstract_one(int sig1) try
{
return _original->abstract_one(sig1);
}
catch (...)
{
handle();
return -1;
}

Answer 4

My answer is conceptually similar to James McNellis', except that I use boost::bind to do the heavy lifting:
using boost::bind;
class myClass
{
public:
myClass(origClass * orig) : orig_(orig) {}
int f1(bool b) { return wrapper(bind(&origClass::f1, orig_, b)); }
bool f2(int i) { return wrapper(bind(&origClass::f2, orig_, i)); }
void f3(int i) { return wrapper(bind(&origClass::f3, orig_, i)); }
private:
origClass * orig_;
template <typename T>
typename T::result_type wrapper(T func)
{
try {
return func();
}
catch (std::exception const &e) {
handleError(e);
}
catch (...) {
handleError();
}
}
};
Note that I wouldn't use a boost::function here as it can interfere with inlining.

Answer 5

My answer is: do nothing at all. The first code example as shown is fine. So what is there's repetition? It is plain and clear, and does what it looks like it does. It can be understood with no extra mental burdens past the code seen and general knowledge of C++.
Consider your motive for asking this question.
Where I'm coming from is past projects where code had to be examined by others - not PhD Comp Sci experts, but federal inspectors, mechanical engineers, self-taught programmers, scientists, etc. Smart people, all of them (or most of them), but only an off-the-deep-end chrome dome PhD, or a younger programmer out to impress everyone with their hi IQ, would appreciate the clever "solutions" to this question. For the places I've been, nothing beats plain clear code that does what it says, with no mental burden of having to keep in mind the meaning of dozens of classes, macros, etc. and recognizing "design pattern" understood properly only be experienced software engineers.
Increasingly, I find C++ (and Java and C#) code becoming more sophisticated in a coding sense, but needing to be understood by non-experts in C++.
Of course YMMV, depending on the intended audience and source of potential future maintenence programmers. Sometimes clever coding is necessary to achieve certain goals. Is your case an example?

Answer 6

I don't have an answer except to suggest that you might be better off avoiding exception handling altogether and relying instead on Smart Pointers and Boost Scope Exit to do all your resource clean up. That way you won't have to catch exceptions unless you can do something about them, which is rarely the case. Then you can do all exception handling in one centralized place higher up the call chain for error reporting and such.

Answer 7

Use boost::function and boost::bind. Works with any function signature so long as the return type matches;
#include <boost/function.hpp>
#include <boost/bind.hpp>
using boost::function;
using boost::bind;
template<typename T>
T exception_wrapper(boost::function<T()> func)
{
try {
return func();
} catch (std::exception& err) {
handleException(err);
} catch (...) {
handleException();
}
}
// ways to call
int result = exception_wrapper<int>(bind(libraryFunc, firstParam));
// or a member function
LibraryClass* object;
result = exception_wrapper<int>(bind(&LibraryClass::Function, object, firstParam));
// So your wrapping class:
class YourWrapper : public SomeInterface
{
public:
int abstract_one(int sig1)
{
return exception_wrapper<int>(bind(&LibraryClass::concrete_one, m_pObject, sig1));
}
bool abstract_two(int sig1, int sig2)
{
return exception_wrapper<bool>(bind(&LibraryClass::concrete_two, m_pObject, sig1, sig2));
}
// ...
private:
LibraryClass* m_pObject;
};

Answer 8

A bit of an old question, but these days we can also craft an elegant generic solution with variadic templates and std::invoke. (Requires C++17)
template<typename Action, typename... Args>
int MyClass::abstract(Action action, Args&&... args)
{
try {
return std::invoke(action, std::forward<Args>(args)...);
} catch (std::exception& err) {
handleException(err);
} catch (...) {
handleException();
}
}
Here action can be a lambda, function pointer, or even member function pointers thanks to std::invoke. For example:
my_class->abstract(&Original::abstract_n, original, sig3a, sig3b);