Question

想象一下，我有一份工作要做，可以通过三种不同的方式来完成：缓慢而痛苦，但却是安全的方式;鉴于你有Resource1;这是一种快速简便的方法，需要Resource1和Resource2。现在，这些资源是宝贵的，所以我把它们包装成RAII实现ResNHolder并写下这样的东西：

void DoTheJob(Logger& log/*, some other params */) {
    try {
        Res1Holder r1(/* arguments for creating resource #1 */);
        try {
            Res2Holder r2(/* arguments */);
            DoTheJobQuicklyAndEasily(log, r1, r2);
        }
        catch (Res2InitializationException& e) {
            log.log("Can't obtain resource 2, that'll slowdown us a bit");
            DoTheJobWithModerateSuffering(log, r1);
        }
    }
    catch (Res1InitializationException& e) {
        log.log("Can't obtain resource 1, using fallback");
        DoTheJobTheSlowAndPainfulWay(log);
    }
}

“DoTheJobXxx（）”会引用Logger / ResNHolder，因为它们是不可复制的。我是不是太笨拙了？有没有其他聪明的方法来构建函数？

Answer 1

我认为您的代码会很好，但是可以考虑以下方法：

void DoTheJob(Logger &log/*,args*/)
{
    std::unique_ptr<Res1Holder> r1 = acquireRes1(/*args*/);
    if (!r1) {
        log.log("Can't acquire resource 1, using fallback");
        DoTheJobTheSlowAndPainfulWay(log);
        return;
    }
    std::unique_ptr<Res2Holder> r2 = acquireRes2(/*args*/);
    if (!r2) {
        log.log("Can't acquire resource 2, that'll slow us down a bit.");
        DoTheJobWithModerateSuffering(log,*r1);
        return;
    }
    DoTheJobQuicklyAndEasily(log,*r1,*r2);
}

当资源无法初始化时，acquireRes函数返回null unique_ptr：

std::unique_ptr<Res1Holder> acquireRes1()
{
  try {
    return std::unique_ptr<Res1Holder>(new Res1Holder());
  }
  catch (Res1InitializationException& e) {
    return std::unique_ptr<Res1Holder>();
  }
}

std::unique_ptr<Res2Holder> acquireRes2()
{
  try {
    return std::unique_ptr<Res2Holder>(new Res2Holder());
  }
  catch (Res2InitializationException& e) {
    return std::unique_ptr<Res2Holder>();
  }
}

Answer 2

你的代码看起来很好，这是我可以想象你可能遇到的唯一问题，因为异常被认为不是很有效。如果是这样，您可以将代码更改为：

void DoTheJob(Logger& log/*, some other params */) {
    Res1HolderNoThrow r1(/* arguments for creating resource #1 */);
    if( r1 ) {
        Res2HolderNoThrow r2(/* arguments */);
        if( r2 ) 
            DoTheJobQuicklyAndEasily(log, r1, r2);
        else {
            log.log("Can't obtain resource 2, that'll slowdown us a bit");
            DoTheJobWithModerateSuffering(log, r1);
        }
    } else {
        log.log("Can't obtain resource 1, using fallback");
        DoTheJobTheSlowAndPainfulWay(log);
    }
}

你需要另一个不抛出异常但有状态的RAII对象，并在运算符bool（）或其他地方返回它。但是你的代码看起来不容易出错，除非你遇到性能问题或者需要避免异常，否则我宁愿使用它。

RAII和构造函数中的异常

2 个答案: