c++ - 如何在 C++ 中正确实现我自己的异常处理程序

Question

我正在从 C# 转向 C++，所以如果问题是基本问题或有一些误解，请原谅我...

我想构建自己的异常以用于我的 try/catch block 。我需要报告自定义异常代码、自定义异常消息和自定义异常源来源 - 我可能拥有所有或部分这些参数。

所以我构建了那个类:

CommonException.hpp

namespace exceptionhelper
{

    class CommonException : public std::exception {

    public:
        CommonException();
        CommonException(std::string message);
        CommonException(std::string source, std::string message);
        CommonException(int code, std::string source, std::string message);
        virtual ~CommonException();
        const char *what() const throw();


    private:
        int exceptionCode;
        std::string exceptionSource;
        std::string exceptionMessage;
    };

}

和实现:

CommonException.cpp

namespace exceptionhelper {
        CommonException::CommonException() {
            exceptionCode = 0;
            exceptionMessage = "No message.";
            exceptionSource = "No source.";
        }
        CommonException::CommonException(std::string message) {
            exceptionCode = 0;
            exceptionMessage = message;
            exceptionSource = "No source.";
        }
        CommonException::CommonException(std::string source, std::string message) {
            exceptionCode = 0;
            exceptionMessage = message;
            exceptionSource = source;
        }
        CommonException::CommonException(int code, std::string source, std::string message) {
            exceptionCode = code;
            exceptionMessage = message;
            exceptionSource = source;
        }
        CommonException::~CommonException() {
        }
        const char *CommonException::what() const throw()
        {
            std::stringstream s;
            s << "Code    : " << exceptionCode << std::endl;
            s << "Source  : " << exceptionSource << std::endl;
            s << "Message : " << exceptionMessage << std::endl;
            return s.str().c_str();
        }
    }

最后是我的实现:

main ()
{
   try {
        ... code ...

        throw new CommonException(10, "here", "test exception");

   }
   catch (const std::exception &exc)
   {
            std::cerr << "Exception detected:" << std::endl;
            std::cerr << exc.what();
        }
        catch (...)
        {
            std::cerr << "Unknown exception called." << std::endl;
            throw;
        }
}

出于某种原因，我得到了这个结果:

Unknown exception called.
terminate called after throwing an instance of 'linuxcommon::exceptionhelper::CommonException*'
Aborted (core dumped)

问题:

a) 为什么我没有捕捉到我的自定义异常？b) 我很确定有更好的方法来进行这种异常处理，但我还不能弄清楚......

感谢您的帮助...

Answer 1

代码的一些注释。

1. 您可能希望从 std::runtime_error 派生您的异常类(而不是 std::exception )，因为 std::runtime_error已经提供了带有错误消息字符串的构造函数。当然你可以在派生类中添加你自己的异常的数据成员。

2. 您不需要为您的异常类定义一个空主体的虚拟析构函数，因为您没有要执行的显式清理代码。 std::exception有一个虚拟析构函数，这对您的派生异常类来说工作得很好。

3. 您可以使用更惯用的 C++ 语法在构造函数中初始化您的异常数据成员，例如而不是:

CommonException::CommonException() {
    exceptionCode = 0;
    exceptionMessage = "No message.";
    exceptionSource = "No source.";
}

你可以使用:

CommonException::CommonException()
  : exceptionCode(0), 
    exceptionMessage("No message."), 
    exceptionSource("No source.")
{ }

1. 如果你传递字符串参数，你仍然可以按值传递，但你可能想要std::move()从值来初始化数据成员，例如而不是:

CommonException::CommonException(std::string source, std::string message) {
    exceptionCode = 0;
    exceptionMessage = message;
    exceptionSource = source;
}

你可以这样做:

CommonException::CommonException(std::string source, std::string message) 
    : exceptionCode(0),
      exceptionMessage(std::move(message)),
      exceptionSource(std::move(source))
{
}

1. 考虑制作单字符串参数构造函数 explicit ，以防止从字符串到异常的虚假隐式转换:

   explicit CommonException(std::string message);
   

2. 在当前形式中，您的 what()方法实现可以抛出，因为在 << 上插入操作( std::stringstream )可以抛出:

const char *CommonException::what() const throw()
{
    std::stringstream s;
    s << "Code    : " + exceptionCode << std::endl;
    s << "Source  : " + exceptionSource << std::endl;
    s << "Message : " + exceptionMessage << std::endl;
    return s.str().c_str();
}

因此，删除 throw()规范，使其简单:

const char* CommonException::what() const

(作为旁注，将方法标记为非抛出的现代 C++11 方法是使用 noexcept)。

您可能还想简单地使用 '\n'而不是 std::endl避免过早悲观。

此外，您将在此行中返回一个临时字符串:

 return s.str().c_str();

const char*返回给调用者的指针只会指向调用站点的一些垃圾:这会引入错误。

要解决这个问题，您可能需要考虑添加一个 std::string数据成员，在异常对象构造期间格式化该数据成员内的整个错误消息字符串(即在您的构造函数中 - 您也可以构建一个私有(private)辅助方法来执行此操作，以避免在每个构造函数中重复代码)，然后返回 m_str.c_str()来自 what()方法。

如果您从 std::runtime_error 派生异常类，您可以在构建时构建整个错误消息字符串，并将其传递给 std::runtime_error的构造函数。在这种情况下，std::runtime_error::what()会做正确的事，你不需要覆盖 what()在你的异常类中。

例如

// Derive from std::runtime_error instead of std::exception
class CommonException : public std::runtime_error

...

CommonException::CommonException( /* your exception data */ )
    : std::runtime_error(BuildErrorMessage( /* your exception data */ )
{ }

// Private helper method
std::string CommonException::BuildErrorMessage( /* your exception data */ )
{
    // Build your exception message string here,
    // e.g. you can use std::ostringstream here,
    // and just call its str() method
    // to return the whole error message string.
    ...
}

---

在异常的“客户端”端，您有:

  ... code ...

    throw new CommonException(10, "here", "test exception");

}
catch (const std::exception &exc)

相反，考虑按值 抛出，而不是在堆上动态分配异常对象，例如简单地做:

throw CommonException( /* your exception data*/ );