在类构造函数上清除异常后的数据

Question

为什么这段代码不在类析构函数中调用CloseHandles
在我的代码测试中，我调用“（（MyClass*）pThis）-

#include <windows.h>
#include <exception>

class MyClass
{
public:

    explicit MyClass( void **pThis)
    {
        *pThis = this;
        m_bFinished = false;

        //code open handle here

        //an error occurs
        throw new std::exception("Exception thrown!");
    }

    ~MyClass()
    {
        if ( ! m_bFinished ) CloseHandles();
    }

    void CloseHandles()
    {
        if ( m_bFinished ) return;

        //close handles here.

        m_bFinished = true;
    }

private:
    bool m_bFinished;
};

int main(int argc, char* argv[])
{
    MyClass * pMyClass;
    void * pThis = NULL;

    try
    {
        pMyClass = new MyClass(&pThis);
    }
    catch(std::exception * e)
    {
        //delete pThis;

        if ( pThis )
        {
            ((MyClass*)pThis)->CloseHandles();
        }
    }

    return 0;
}

Answer 1

因为类的析构函数在构造函数抛出时不会运行，所以对象还没有完全初始化。

此外，您实际上并没有抛出std:：exception，而是一个指向它的指针：

// dynamically allocates std::exception and throws a pointer to it
throw new std::exception("Exception thrown!");

编辑：我注意到你也在捕捉指针，所以这不是问题所在。但是，std:：exception的构造函数不接受字符串文本，所以我想知道你的代码是如何编译的。

在任何情况下，如果构造函数可能在分配原始资源后抛出，则可能存在泄漏。

您需要将资源封装在管理它的类中——可能是一个智能指针或类似的RAII包装器。并使用成员初始值设定项列表！

另一个选项是构造函数委托（C 11中新增）。当一个对象的任何构造函数完成执行时，它被认为是完全构造的。这意味着，如果从委托给另一个构造函数的构造函数中抛出异常（您将在其中获取句柄），将调用析构函数。

用一些代码来说明：

struct Handle {
    Handle() : handle(new int()) {}
    ~Handle() { delete handle; }
    int* handle;
};

class MyClass {
    Handle h;
    MyFlass() : h() // handle initialized here
    {
       /**** code that may throw ****/
       // this will properly close handles because
       // the destructors of already initialized
       // members (like h) will be called
    }
    ~MyClass() { /* not called if constructor throws */ }
};

还有一个建造商授权的例子：

#include <iostream>

class MyClass {
private:
    int* handle;
    MyClass(int)  // dummy parameter just for overloading
        : handle(new int()) { /* better not throw from here */ }
public:
    MyClass() : MyClass(0) // handle initialized here
    {
       /**** code that may throw ****/
       throw 42;
    }
    ~MyClass() { delete handle; std::cout << "dtor!"; }
};

int main()
{
    try { MyClass m; } catch (int) {};
}

输出是dtor！。