C++中的异常调度

通过捕获(…)并调用一个共享处理程序函数来重新调用和分派,避免在每个调用站点复制catch块:

f()
{
    try
    {
        // something
    }
    catch (...)
    {
        handle();
    }
}

void handle()
{
    try
    {
        throw;
    }
    catch (const Foo& e)
    {
        // handle Foo
    }
    catch (const Bar& e)
    {
        // handle Bar
    }
    // etc
}

我经常遇到的一个想法是,异常应该被能够处理它们的级别捕获。例如,传输数据的函数可能会捕捉到CRC错误,一旦捕捉到该异常,它可能会尝试重新传输,而“无信号”异常可能会捕捉到更高级别的异常,并中断或延迟整个操作。

但我的猜测是,这些异常中的大多数都会被捕获在同一个函数周围。它 是 单独捕获和处理它们是个好主意(如soln 2),但您认为这会导致大量重复代码(导致soln 3)。

我的问题是,如果有很多代码要重复,为什么不把它变成一个函数呢?

我在考虑…

void SendData(DataHW* data, Destination *dest)
{
    try {
        data->send(dest);
    } catch (CRCError) {
        //log error

        //retransmit:
        data->send(dest);
    } catch (UnrecoverableError) {
        throw GivingUp;
    }
}

我想应该是exceptiondispatch()函数,而不是 switch 在异常类型上,它将包装异常生成调用本身,并且 catch 例外情况。

当然,这个函数过于简化了—您可能需要围绕datahw使用一个完整的包装器类;但我的观点是,最好有一个集中的点来处理所有datahw异常—如果该类的不同用户处理它们的方式相似的话。

也许您可以为datahw类编写一个包装类? 包装器将提供与datahw类相同的功能,但也包含所需的错误处理代码。好处是,您可以将错误处理代码放在一个地方(干燥原则),所有错误都将被统一处理。例如,可以将包装器中的所有低级I/O异常转换为高级异常。 基本上防止向用户显示低级异常。

正如巴特勒·兰普森所说:计算机科学中的所有问题都可以通过另一个间接层次来解决。

有三种方法可以解决这个问题。

正在写入包装函数

为每个函数编写一个包装函数,该函数可以引发处理异常的异常。然后,所有调用方调用该包装器,而不是原始的抛出函数。

使用函数对象

另一种解决方案是采用更通用的方法,编写一个函数,它接受一个函数对象并处理所有异常。下面是一些例子:

class DataHW {
public:
    template<typename Function>
    bool executeAndHandle(Function f) {
        for(int tries = 0; ; tries++) {
            try {
                f(this);
                return true;
            }
            catch(CrcError & e) {
                // handle crc error
            }
            catch(IntermittentSignalError & e) {
                // handle intermittent signal
                if(tries < 3) {
                    continue;
                } else {
                    logError("Signal interruption after 3 tries.");
                } 
            }
            catch(DriverError & e) {
                // restart
            }
            return false;
        }
    }

    void sendData(char const *data, std::size_t len);
    void readData(char *data, std::size_t len);
};

现在,如果你想做点什么,你可以做:

void doit() {
    char buf[] = "hello world";
    hw.executeAndHandle(boost::bind(&DataHW::sendData, _1, buf, sizeof buf));
}

因为您提供了函数对象,所以也可以管理状态。假设senddata更新len,这样它就知道读取了多少字节。然后,您可以编写读取和写入的函数对象,并为到目前为止读取的字符数保持计数。

第二种方法的缺点是不能访问抛出函数的结果值,因为它们是从函数对象包装器调用的。无法轻松获取函数对象绑定器的结果类型。一种解决方法是编写一个结果函数对象,该对象在函数对象执行成功后由ExecuteAndHandle调用。但是,如果我们把太多的工作放在第二种方法上,仅仅是为了让所有的家政工作顺利进行,那么结果就不值得了。

两者结合

还有第三种选择。我们可以将这两个解决方案(包装器和函数对象)结合起来。

class DataHW {
public:
    template<typename R, typename Function>
    R executeAndHandle(Function f) {
        for(int tries = 0; ; tries++) {
            try {
                return f(this);
            }
            catch(CrcError & e) {
                // handle crc error
            }
            catch(IntermittentSignalError & e) {
                // handle intermittent signal
                if(tries < 3) {
                    continue;
                } else {
                    logError("Signal interruption after 3 tries.");
                } 
            }
            catch(DriverError & e) {
                // restart
            }
            // return a sensible default. for bool, that's false. for other integer
            // types, it's zero.
            return R();
        }
    }

    T sendData(char const *data, std::size_t len) {
        return executeAndHandle<T>(
            boost::bind(&DataHW::doSendData, _1, data, len));
    }

    // say it returns something for this example
    T doSendData(char const *data, std::size_t len);
    T doReadData(char *data, std::size_t len);
};

诀窍是 return f(); 模式。即使F返回空值,我们也可以返回。这最终是我最喜欢的,因为它既允许将句柄代码集中在一个地方,也允许在包装函数中进行特殊处理。您可以决定是否最好将其拆分,并创建一个拥有该错误处理程序函数和包装器的类。可能这是一个更清洁的解决方案(我想 Separation of Concerns 在这里。一个是基本的数据硬件功能,另一个是错误处理)。