別の場所で一連の例外を捕捉するマクロは問題ありませんか？

Question

私は一連の関数を持っており、スローされる可能性のある例外を エラーコードに変換する必要があります。

は、この目的を達成するために、私は、try/catch文と実際の呼び出しをラップしています

int f_with_error_codes() 
{ 
    try { 
    f(); // wrapped function call 

    return E_SUCCESS; 
    } 
    catch (error1&) { 
    return E_ERROR1; 
    } 
    catch (error2&) { 
    return E_ERROR2; 
    } 
} 

int g_with_error_codes(int a); 
{ 
    try { 
    G g(a);  // wrapped expressions 
    g.print(); 

    return E_SUCCESS; 
    } 
    catch (error1&) { 
    return E_ERROR1; 
    } 
    catch (error2&) { 
    return E_ERROR2; 
    } 
} 

... 

これらのキャッチstatmementsが自分自身を繰り返します。さらに、新しい例外 が追加されるたびに、新しい呼び出し句を各呼び出しラッパーに追加する必要があります。

catchステートメントを適切に置き換えると、以下のようなマクロがありますか？

での結果でしょう

#define CATCH_ALL_EXCEPTIONS \ 
catch (error1&) {    \ 
    return E_ERROR1;   \ 
}        \ 
catch (error2&) {    \ 
    return E_ERROR2;   \ 
} 

：あなたのケースのために

int f_with_error_codes() 
{ 
    try { 
    f(); // the wrapped 

    return E_SUCCESS; 
    } 
    CATCH_ALL_EXCEPTIONS 

Answer 1

代わりに、このようなマクロの機能を使用することができます。

int f_with_error_codes() 
{ 
    try { 
    f(); // wrapped function call 

    return E_SUCCESS; 
    } 
    catch (...) { 
    return error_code(); 
    } 
} 

int error_code() 
{ 
    try { 
    throw; 
    } 
    catch (error1&) { 
    return E_ERROR1; 
    } 
    catch (error2&) { 
    return E_ERROR2; 
    } 
} 

Answer 2

、あなたが任意のマクロを必要としません。
virtual関数を含む単純な基本クラスで十分です。

今

class error : public std::exception { // std::exception is your wish 
    const char* what() throw(); // needed if std::exception is based 
    virtual int GetValue() const = 0; // <--- This is the core part 
} 

は、すべてのerror#クラスでこのクラスを継承します。

class error1 : public error { 
    virtual int GetValue() const { return E_ERROR1; } // <--- override 
}; 
// ... 

は最後に、あなたのコードは次のように簡単です：

void f_with_error_codes() 
{ 
    try { 
    f(); // wrapped function call 
    return E_SUCCESS; 
    } 
    catch (error& e) { // <--- base handle 
    return e.GetValue(); 
    } 
} 

virtualのコストについては気にしないでくださいここで機能する。それは最小限であり、例外もまれなイベントです。 virtualの非常に小さなコストは、コードをメンテナンス可能かつ拡張可能にするための価値があります。