构造函数抛出异常的对象的异常处理是否可以靠近基于代码的堆栈创建？ 我试图让我的C++代码异常安全，并且有一个问题，既不询问朋友也不搜索Web会有帮助。p>

据我所知，当使用构造函数创建可能引发异常的对象时，创建代码需要包含在

try

块中，异常处理在

catch（）{}

中完成

如果创建是基于堆的（例如，

new

ed和默认分配器），我可以在创建附近放置异常处理代码，如下所示：

void f() {
  // work unrelated to Hoge object here

  try {
    Hoge *pHoge = new Hoge(); // could throw an exception
  } catch(HogeException& ex) {
    // handle exception
  }

  // rest of work here
}

但是，如果创建是基于堆栈的，由于

try

block的范围，我无法找到这样做的方法并求助于下面的代码：

void g() {
  // work unrelated to Hoge object here

  try {
    Hoge hoge; // could throw an exception

    // rest of work here
  } catch(HogeException& ex) {
    // handle exception
  }
}

如果上面的

//剩余工作

代码很大，则对象创建和异常处理之间的位置距离可能会很长，从而降低代码的可读性

---

我更喜欢异常处理代码接近对象创建（这可能是

try

-

catch

结构的概念之一）。有什么解决方案吗？

将

//剩余工作

委托给助手函数，并将

Hoge&

传递给该函数：

void RestOfWork(Hoge& hoge)
{
  // rest of work here
}

void g() {
  // work unrelated to Hoge object here

  try {
    Hoge hoge;
    RestOfWork(hoge);
    // rest of work here
  } catch(HogeException& ex) {
    // handle exception
  }
}

顺便说一句，

Hoge-Hoge（）不会做你认为它会做的事情。您可能认为您正在声明类型为
hoge
的名为
hoge
的对象，并通过调用默认构造函数对其进行初始化。实际上，您要做的是声明一个名为
hoge
的函数，该函数不接受任何参数，并按值返回一个
hoge
。我已经在上面的代码中修复了这个问题

编辑事实上，正如@LightnessRacesInOrbit所建议的那样，
Hoge
对象的构造也可以在延迟函数中进行，例如：

  void RestOfWork()
  {
       Hoge hoge;
      // rest of work here
  }

  void g() {
    // work unrelated to Hoge object here

    try {
      RestOfWork();
    } catch(HogeException& ex) {
      // handle exception
    }
  }

将
//剩余工作
委托给助手函数，并将
Hoge&
传递给该函数：

void RestOfWork(Hoge& hoge)
{
  // rest of work here
}

void g() {
  // work unrelated to Hoge object here

  try {
    Hoge hoge;
    RestOfWork(hoge);
    // rest of work here
  } catch(HogeException& ex) {
    // handle exception
  }
}

顺便说一句，
Hoge-Hoge（）不会做你认为它会做的事情。您可能认为您正在声明类型为
hoge
的名为
hoge
的对象，并通过调用默认构造函数对其进行初始化。实际上，您要做的是声明一个名为
hoge
的函数，该函数不接受任何参数，并按值返回一个
hoge
。我已经在上面的代码中修复了这个问题

编辑事实上，正如@LightnessRacesInOrbit所建议的那样，
Hoge
对象的构造也可以在延迟函数中进行，例如：

  void RestOfWork()
  {
       Hoge hoge;
      // rest of work here
  }

  void g() {
    // work unrelated to Hoge object here

    try {
      RestOfWork();
    } catch(HogeException& ex) {
      // handle exception
    }
  }

一种合理的方法是使用可为空的单项目容器，例如，
boost:：optional
：

void g() {
  // work unrelated to Hoge object here

  boost::optional<Hoge> opt_hoge;
  try {
    opt_hoge = boost::in_place<Hoge>();
  } catch(HogeException& ex) {
    // handle exception
  }
  Hoge &hoge = *opt_hoge;

  // rest of work here
}

一种合理的方法是使用可为空的单项目容器，例如，
boost:：optional
：

void g() {
  // work unrelated to Hoge object here

  boost::optional<Hoge> opt_hoge;
  try {
    opt_hoge = boost::in_place<Hoge>();
  } catch(HogeException& ex) {
    // handle exception
  }
  Hoge &hoge = *opt_hoge;

  // rest of work here
}

Hoge-Hoge（）无法引发异常，因为它是一个函数声明（令人烦恼的解析），而不是变量声明/初始化。@jpalecek我的意思是在堆栈上创建一个名为
Hoge
的
object类型的实例。这可能会引发异常，对吗？哦，看起来又发现了一个误会。。。谢谢大家!@k2_8191：实际上，创建一个对象（
Hoge-Hoge；
）可能会抛出一个表达式。我已经编辑了代码以符合您的意图。
Hoge Hoge（）无法引发异常，因为它是一个函数声明（令人烦恼的解析），而不是变量声明/初始化。@jpalecek我的意思是在堆栈上创建一个名为
Hoge
的
object类型的实例。这可能会引发异常，对吗？哦，看起来又发现了一个误会。。。谢谢大家!@k2_8191：实际上，创建一个对象（
Hoge-Hoge；
）可能会抛出一个表达式。我编辑了代码以符合你的意图。这个答案没有错。除此之外，可能在某些情况下，您最好首先在
RestOfWork
内部创建
hoge
。@LightnessRacesinOrbit:这不是一开始所做的吗？或者你的意思是把
try…catch
放在
g（）
中？@JohnDibling:的确如此
try…捕获对
SomeWork（）
的调用，将
Hoge
留在函数中。函数中的所有内容都需要
Hoge
来构造，而函数之外的任何内容都不需要使用它。所以就像你现在一样，这个答案没有错。除此之外，可能在某些情况下，您最好首先在
RestOfWork
内部创建
hoge
。@LightnessRacesinOrbit:这不是一开始所做的吗？或者你的意思是把
try…catch
放在
g（）
中？@JohnDibling:的确如此
try…捕获对
SomeWork（）
的调用，将
Hoge
留在函数中。函数中的所有内容都需要
Hoge
来构造，而函数之外的任何内容都不需要使用它。所以就像你现在一样。