我应该如何使用 getDC 作为具有 autocleanup 的本地对象？ C++

Question

我是 C++ 新手，正在学习最好的方法。 我看到了很多关于绘画的有用示例，但我没有看到任何带有智能类的简单疙瘩 getdc。

所以我自己写了一个：

class DCObject 
{
public:
    DCObject(HWND handle)
    {
        my_handle = handle;
        my_hdc = GetDC(my_handle);
    }

    HDC GetHDC() {
        return my_hdc;
    }

    ~DCObject()
    {
        ReleaseDC(my_handle, my_hdc);
    }
private:
    HWND my_handle;
    HDC my_hdc;
};

我试图像这样获得 hdc：

HDC mydc = DCObject(dialog_item_handle).GetHDC();

这是正确的吗？要求类方法，首先不创建类对象？在这种情况下，类会发生什么？也许我确实得到了 hdc 并且它立即被释放了？（它可以工作，但它可能会对 hdc 产生未定义的行为？）

也许我应该这样做：

DCObject myhdcobj(dialog_item_handle);
 HDC mydc = myhdcobj.GetHDC();

Answer 1

声明

HDC mydc = DCObject(dialog_item_handle).GetHDC();

调用DCObject 构造函数，创建一个临时对象。一个临时对象（保证）在完整表达式结束时被销毁。所以在这个语句之后临时对象已经被销毁，它的析构函数调用了ReleaseDC...

解决方案：存储对象而不是句柄，

const DCObject mydc( dialog_item_handle );

---

我更喜欢这样写

auto const mydc = DCObject( dialog_item_handle );

...但是对于问题中提出的DCObject 类，这是不安全，因为没有处理复制/移动，因此右侧临时对象的析构函数将调用@ 987654328@…

---

要为常量声明启用更自然的auto 表示法，并且通常启用移动和禁用复制，请执行以下操作：

class DCObject 
{
private:
    HWND my_handle;
    HDC my_hdc;

    DCObject( DCObject const& ) = delete;
    DCObject& operator=( DCObject const& ) = delete;

public:
    auto handle() const -> HDC { return my_hdc; }

    ~DCObject()
    { ReleaseDC( my_handle, my_hdc ); }

    DCObject( const HWND handle )
        : my_handle( handle )
        , my_hdc( GetDC( handle ) )
    {}

    DCObject( DCObject&& other )
        : my_handle( other.my_handle )
        , my_hdc( other.my_hdc )
    { other.my_hdc = 0; }
};

其他类型句柄的代码——即使是设备上下文句柄的其他用途——也将非常相似。

将其表达为通用类模板所需的一个主要见解是清理所需的附加状态，例如这里的窗口句柄，可以是指定的清理函数或类似函数的对象的一部分，特别是作为 lambda 中的捕获。

如果您还没有使用 lambda，请记住这一点。

您也可以使用状态删除器的原理，而无需使用 lambdas。

Answer 2

这就是我的做法。

#include <iostream>
#include <memory>
#include <windows.h>

template<typename T, typename D = void(*)(T &val)>
struct gdi_type
{
    typedef typename std::remove_reference<typename std::remove_pointer<T>::type>::type type;
    typedef typename std::unique_ptr<typename gdi_type<T>::type, D> unique_ptr_type;
};

template<typename T>
auto safe_gdi(const T &val)
{
    return typename gdi_type<T>::unique_ptr_type(val, [](T &t) {DeleteObject(t);});
}

auto safe_gdi(const HDC &val)
{
    return gdi_type<HDC>::unique_ptr_type(val, [](HDC &t) {DeleteDC(t);});
}

auto safe_gdi(const HWND &win, const HDC &val)
{
    auto deleter = [=](HDC &val) {ReleaseDC(win, val); val = nullptr;};
    return gdi_type<HDC, decltype(deleter)>::unique_ptr_type(val, deleter);
}

int main()
{
    HWND win = GetDesktopWindow();
    HDC DC = safe_gdi(win, GetDC(win)).get();

    HDC CDC = safe_gdi(CreateCompatibleDC(DC)).get();

    HPEN PEN = safe_gdi(CreatePen(PS_DASH, 0, 0xFF)).get();
    return 0;
}

Answer 3

如果您不将DCObject(dialog_item_handle) 分配给变量，您最终会得到Temporary Object。

临时对象在创建它们的表达式完成时被销毁。在您的情况下，就在分配给mydc 之后。所以在mydc被赋值之后，临时对象的析构函数就会被调用，DC也会被释放。不是你想要的。

第二个版本可以工作。你的myhdcobj 只会在它超出范围时被销毁——也就是说，当你离开函数时。