2

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

这是.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;
    }
}

这是我的代码有问题吗？建议？

4

2 回答 2

1

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

于 2013-11-11T10:36:18.257 回答
0

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

我的意思是，一些微不足道的东西，比如 std::cout、你的异常和一些挥之不去的临时字符串；）

如果您想验证这一点，请在调用您的异常测试的最外层范围 od MAIN 处添加一个顶级 TRY/CATCH，以便实际捕获异常，展开堆栈，以便程序正常退出。这样，在捕获/展开之后，应该清理挥之不去的异常对象和其他对象，并且您可能会看到LESS仍然可访问的对象。

不一定为零，这取决于使用的库以及您的“DrMemory”占 CRT“基线内存占用”的方式，抱歉，我不知道如何更好地调用它。

于 2013-11-11T10:42:32.287 回答