c++ - 是否可以将异常传递给处理程序然后重新抛出原始异常？

Question

我正在尝试编写在发生错误时传递给处理程序的代码。

class Handler {
   public: virtual void handle(std::exception const& e) = 0;
};

class DoIt {
  Handler* handler;
  public:
  void doStuff() {
    try {
      methodThatMightThrow();
    } catch (std::exception const& e) {
      handler->handle(e);
    }
  }
  void setHandler(Handler* h) { handler = h; }
  void methodThatMightThrow();

不同的项目将使用具有不同错误处理技术的此类。

项目 1 记录错误

class Handler1: public Handler {
  void handle(std::exception const& e) override {
    logError(e.what());
  }
};

项目 2 传播异常

class Handler2: public Handler {
  void handle(std::exception const& e) override {
    throw e;
  }
};

这两个都应该有效。但是，如果异常是 std::exception 的子类，Handler2 将抛出异常的拷贝并丢失任何派生类信息，这几乎可以肯定是。

有没有什么好的方法可以重新抛出原来的异常，甚至是同类型的拷贝？

Answer 1

您可以使用裸throw 来重新抛出当前异常。

重写您的 Handler2 以使用它会产生以下代码:

class Handler2 : public Handler
{
public: void handle(const std::exception& ex) const override
    {
        throw;
    }
};

您不必将异常作为参数发送，并且可以编写更高级的处理程序，这些处理程序可以根据异常类型执行不同的操作，例如这个简单的处理程序。

class WrapperHandler : public Handler
{
public:
    void handle() const
    {
        try
        {
            throw;
        }
        catch (const notveryserious_exception& ax)
        {
            std::cout << "Not very serious, I'm going to let this slide." << std::endl;
            std::cout << ax.what() << std::endl;
        }
        catch (const myown_exception& ax)
        {
            // Probably serious, will let this propagate up the stack.
            throw;
        }
        catch (...)
        {
            // Bad, bad, bad.. Unhandled exception that we haven't thrown ourselves.
            throw myown_exception("Unhandled exception.");
        }
    }
};