将 unique_ptr / shared_ptr 与 API 函数一起使用，通过指针将资源作为输出参数返回

Question

我现在正在赶上我当前项目中的 C++ 11/14 内容。我在使用unique_ptr/shared_ptr 时遇到问题，API 函数通过指针将资源作为输出参数返回。

我们以DsGetDcName(..., __out PDOMAIN_CONTROLLER_INFO* ppDCI) 为例。

在 c++11 之前，有一种使用 Windows API 的广泛模式。我会有一个 RIIA 类，它包含 PDOMAIN_CONTROLLER_INFO，在析构函数中调用 NetApiBufferFree，并拥有 PDOMAIN_CONTROLLER_INFO* operator&()，以便我可以编写：

info_ptr spInfo;
DsGetDcName(..., &spInfo);

现在有了 C++ 11/14，我看到很多文章提倡 unique_ptr/shared_ptr 使用自定义删除器以适当的方式释放资源。当资源作为 r 值从函数返回时，它确实很有效（LoadLibrary 就是一个很好的例子）。

我发现的一个解决方案是在 API 调用之后将原始指针附加到智能指针：

PDOMAIN_CONTROLLER_INFO pDCI = nullptr;
DsGetDcName(..., &pDCI);
std::unique_ptr<DOMAIN_CONTROLLER_INFO, decltype(&NetApiBufferFree)> spInfo(pDCI, &NetApiBufferFree);

但是，这不是我喜欢的方式。据我了解，新的智能指针并不是为输出参数而设计的，可能是因为“安全第一”的方法。

真的可以在这里做点什么吗？也许某种函子类作为输出参数代理，所以我可以写DsGetDcName(..., &out_param(spInfo))？

Answer 1

好吧，您可以制作一个临时包装器，在销毁时初始化您的 std::unique_ptr：

#include <windows.h>
#include <Dsgetdc.h>
#include <Lm.h>

#include <memory>

template<typename T, typename D>
struct OutParameterWrapper
{
    OutParameterWrapper(std::unique_ptr<T, D>& Target) : m_Target(Target), m_pSource(nullptr)
    {
    }
    ~OutParameterWrapper()
    {
        m_Target.reset(m_pSource);
    }
    operator T**()
    {
        return &m_pSource;
    }
    std::unique_ptr<T, D>& m_Target;
    T* m_pSource;
};

int main(int argc, char** argv)
{
    std::unique_ptr<DOMAIN_CONTROLLER_INFO, decltype(&NetApiBufferFree)> spInfo(nullptr, NetApiBufferFree);
    DsGetDcName(NULL, NULL, NULL, NULL, 0, OutParameterWrapper<DOMAIN_CONTROLLER_INFO, decltype(&NetApiBufferFree)>(spInfo));
    return 0;
}

编辑

要进行自动扣除并使其适用于std::unique_ptr 和std::shared_ptr，您可以执行以下操作：

#include <windows.h>
#include <Dsgetdc.h>
#include <Lm.h>

#pragma comment(lib, "Netapi32.lib")

#include <memory>

template<typename T, typename P>
struct OutParameterWrapper
{
    OutParameterWrapper(P& Target) : m_Target(Target), m_pSource(nullptr)
    {
    }
    ~OutParameterWrapper()
    {
        m_Target.reset(m_pSource);
    }
    operator T**()
    {
        return &m_pSource;
    }

    P& m_Target;
    T* m_pSource;
};

template<typename P>
OutParameterWrapper<typename P::element_type, P> MakeOutParameterWrapper(P& Target)
{
    return OutParameterWrapper<typename P::element_type,P>(Target);
}

int main(int argc, char** argv)
{
    std::unique_ptr<DOMAIN_CONTROLLER_INFO, decltype(&NetApiBufferFree)> spInfo(nullptr, NetApiBufferFree);
    std::shared_ptr<DOMAIN_CONTROLLER_INFO> spInfo2(nullptr, NetApiBufferFree);
    auto nResult = DsGetDcName(NULL, NULL, NULL, NULL, 0, MakeOutParameterWrapper(spInfo));
    DsGetDcName(NULL, NULL, NULL, NULL, 0, MakeOutParameterWrapper(spInfo2));
    return 0;
}

Answer 2

到目前为止，我想出了这个代码：

template<typename T>
class out
{
    T* _p;
    std::shared_ptr<T>& _sp;
public:
    out(std::shared_ptr<T>& sp) : _p(nullptr) , _sp(sp) {}
    ~out() { _sp.reset(_p); }
    T** operator&() { _ASSERT(nullptr == _p); return &_p; }
};

但它有两个缺点

1. 使用时看起来很重，因为类模板类型不是从构造函数推导出来的，例如我必须写 GetMeow(&out<Meow>(sp)) 而不是 GetMeow(&out(sp))
2. 同一名称不能同时用于shared_ptr 和unique_ptr。

有模板忍者吗？

编辑：

好的，我将 Rudolfs 的工作与我的一些调整结合起来，最终结果在这里：https://gist.github.com/kirillkovalenko/8219e7c1afea9b5da5da