2

场景：

我们有一个具有通用错误处理接口的 API。它是一个 C API，所以它告诉我们，在调用每个 API 函数之后，我们需要执行一些样板文件，如下所示：

if (APIerrorHappened()) {
    APIHandle h;
    while(h = APIgetNextErrorContext(...)) {
       cerr << APIgetText(h) << endl;
    }
}

你显然讨厌重复自己，所以你想把这个处理封装在一个宏中，这样你就可以编写如下代码：

...
// this API call returns something
APItype foo = MYMACRO(APIsomeFunction1(...));
// this one doesn't
MYMACRO(APIsomeFunction2(...));
// neither does this (glCompileShader)
MYMACRO(APIsomeFunction3(...));
...

您也可以从面向方面编程的角度来考虑这一点 - 想象一下宏添加了日志记录，将信息发送到远程监视器等等......关键是它应该封装一个表达式，在它周围做任何事情，然后返回表达式返回的任何类型 - 当然表达式可能不会返回任何内容。

这意味着你不能只是做

#define MYMACRO(x) { auto x = expr(); ... }

...因为在某些情况下，表达式不会返回任何内容！

那么......你会怎么做呢？

请不要建议将完整的语句封装在宏中......

#define MYMACRO(x)       \
{                        \
   /* ... stuff ...   */ \
   x;                    \
   // ... stuff
}

...因为这永远不会适用于以下内容：

if (foo() || APIfunctionReturningBool(...) || bar()) {
     ...
     APIfunction1();
     ...
} else if (APIOtherfunctionReturningBool() || baz()) {
     ...
     APIfunction2();
     ...
}

...你吞没了所有的 if 语句？它的动作包括其他 API 调用，所以……宏中的宏？调试简直成了地狱。

我自己的尝试如下，使用 lambdas 和 std::function - 但它可以说是丑陋的......我无法将表达式的 lambda 直接传递给采用 std::function 的模板（根据 lambda 的返回进行专门化类型），所以代码变得相当讨厌。

你能想出更好的方法吗？

void commonCode(const char *file, size_t lineno) {
    // ... error handling boilerplate
    // ... that reports file and lineno of error
}

template <class T>
auto MyAPIError(std::function<T()>&& t, const char *file, size_t lineno) -> decltype(t()) {
    auto ret = t();
    commonCode(file,lineno);
    return ret;
}

template<>
void MyAPIError(std::function<void(void)>&& t, const char *file, size_t lineno) {
    t();
    commonCode(file,lineno);
}

template <class T>
auto helper (T&& t) -> std::function<decltype(t())()>
{
    std::function<decltype(t())()> tmp = t;
    return tmp;
}

#define APIERROR( expr ) \
    return MyAPIError( helper( [&]() { return expr; } ),  __FILE__, __LINE__);

更新，KennyTM 优秀解决方案的附录

我在这里放置了触发这个问题的实际 OpenGL 代码。如您所见，错误检查代码不仅仅是打印 - 它还引发了用户代码可以处理的异常。我添加这个附录是为了注意使用 KennyTM 的解决方案，你最终会从析构函数中抛出这个异常，这没关系（继续阅读）：

struct ErrorChecker { 
    const char *file; 
    size_t lineno; 
    ~ErrorChecker() { 
        GLenum err = glGetError(); 
        if (err != GL_NO_ERROR) { 
            while (err != GL_NO_ERROR) { 
                std::cerr <<  
                    "glError: " << (char *)gluErrorString(err) <<  
                    " (" << file << ":" << lineno << ")" << std::endl; 
                err = glGetError(); 
            } 
            throw "Failure in GLSL..."; 
        } 
    } 
};

C++ FAQ中解释了可以从此析构函数中抛出的原因：

C++ 规则是，您决不能从在另一个异常的“堆栈展开”过程中调用的析构函数中抛出异常……您可以说在处理另一个异常时永远不要从析构函数中抛出异常。

在我们的例子中，我们希望用户代码（调用特殊宏）来处理异常；所以我们需要确定我们在ErrorChecker 的析构函数中的“抛出”是第一个——即实际调用的C API 永远不会抛出。这很容易用这种形式完成：

#define GLERROR(...)                                    \
    ([&]() -> decltype(__VA_ARGS__)                     \
    {                                                   \
        ErrorChecker _api_checker {__FILE__, __LINE__}; \
        (void) _api_checker;                            \
        try {                                           \
            return __VA_ARGS__;                         \
        } catch(...) {}                                 \
    } ())

这种形式的宏保证了实际的 C API（通过VA_ARGS 调用）永远不会抛出 - 因此，ErrorChecker 的析构函数中的“抛出”将始终是第一个这样做的。

所以这个解决方案涵盖了我最初问题的所有角度 - 非常感谢Alexander Turner提供它。

4

1 回答 1

2

将日志记录代码放入某个类的析构函数中——假设记录器不会抛出异常——然后在宏中创建该类的实例。滥用逗号运算符，我们有：

struct Logger
{
    const char* file;
    int lineno;
    ~Logger()
    {
        // The APIerrorHappened stuff.
    }
};

#define APIERROR(...) (Logger{__FILE__, __LINE__}, (__VA_ARGS__))

演示：http: //ideone.com/CiLGR

于 2012-03-13T17:26:18.770 回答