Question

这是我第一次尝试编写一个实现简单形式的堆栈跟踪的自定义异常类。

这是.h：

class error {

    public:

        error ();
        error (const error & err);
        ~error ();

        int level ();

    private:

        int _level;

};

这是.cpp：

error::error ()
    : _level (0) {}

error::error (const error & err)
    : _level (err._level) {}

error::~error () {}

int error::level () {
    return ++_level;
}

然后我定义了两个宏，一个用于创建错误并在第一次抛出它（INIT_ERROR），另一个用于触发捕获的错误（KICK_ERROR）：

#define WHERE(stream) {fprintf (stream, " %-30s [%s: %3d]\n", __FUNCTION__, __FILE__, __LINE__);}

#define INIT_ERROR {fprintf (stderr, "#  0"); WHERE (stderr); throw error ();}
#define KICK_ERROR {fprintf (stderr, "# %2d", err.level ()); WHERE (stderr); throw;}

如您所料，使用方法如下：

    if (something wrong)
        INIT_ERROR;

第一次，并且：

    try {
        // some code
    }
    catch (error & err) {
        KICK_ERROR;
    }

所有其他时间。

然而，DrMemory（我正在使用Windows Xp），提醒我仍然可以访问的块：

ERRORS FOUND:
      0 unique,  0 total unaddressable access(es)
      0 unique,  0 total uninitialized access(es)
      0 unique,  0 total invalid heap argument(s)
      0 unique,  0 total GDI usage error(s)
      0 unique,  0 total warning(s)
      0 unique,  0 total,     0 byte(s) of leak(s)
      0 unique,  0 total,     0 byte(s) of possible leak(s)
      3 unique,  3 total,    16 byte(s) of still-reachable allocation(s)
ERRORS IGNORED:
      3 potential leak(s) (suspected false positives)

为了完整性，这是主要的：

void fun3 () {
    fprintf (stderr, "nothing special");
    INIT_ERROR;
}

void fun2 () {
    try {
        fun3 ();
    }
    catch (error & err) {
        KICK_ERROR;
    }
}

void fun1 () {
    try {
        fun2 ();
    }
    catch (error & err) {
        KICK_ERROR;
    }
}

int main () {
    try {
        fun1 ();
    }
    catch (error & err) {
        cerr << "error catched in main" << endl;
    }
}

我的代码中有什么问题吗？建议？

Answer 1

仍然可达的分配不是泄漏，这是在退出时程序仍然可用的内存。它可能是从您使用的库中分配的。我不担心他们。

Answer 2

我不认为有任何泄漏。您的代码似乎有效。我认为这三个块只是分配的对象，它们在程序开始清理时的确切时间点仍然存在，如果您可以这样称呼它。

我的意思是，像std :: cout这样的小事，你的异常和一些挥之不去的临时字符串;）

如果您想验证这一点，请在调用异常测试的最外部范围内添加顶级TRY / CATCH，以便实际捕获异常，堆栈展开，以便程序将正常退出。这样，在捕获/展开之后，应该清除延迟的异常对象和其他对象，并且您将看到 LESS 仍然可以使用。

不一定是零，这取决于所使用的库以及你的“DrMemory”占CRT“基线内存占用”的方式，抱歉我不知道怎么称呼它更好..

自定义异常中仍然可以访问（误报？）

2 个答案: