C++ C++；11：使用自定义Lambda Deleter返回std:：unique_ptr

问题：

有人知道如何返回使用定义为lambda的自定义删除器的

std:：unique_ptr

？如果做不到这一点，有人知道有更好的整体方法来解决以下问题吗

背景：

我正在开发一个C++11数据库连接池。这个想法相当简单，但是我似乎被实际返回的连接指针卡住了

“我的连接池”的总体设计是预先创建一些连接，这些连接与

bool

一起存储在

std:：vector

中，以指示给定连接是否可用：

static std::vector<std::pair<DataStore*, bool>> connList;

我尝试的解决方案是：

return std::unique_ptr<DataStore, decltype(connDeleter)>
    (connList[index].first, connDeleter);

返回std:：unique\u ptr
（connList[index]。首先是connDeleter）；

不幸的是，这需要类的所有外部使用者了解

conndeler

，这没有任何意义，因为

index

和

connList

在相关函数之外没有任何意义

抱歉，任何其他解决方案（函子或自由函数）都不允许我接收任何类型的索引来重置连接。我可以将指针和索引包装在一个中间对象中，并重写取消引用操作符以“传递”到底层指针。这将允许我更新/提取中间对象中的任何内容，但这对我来说真的很烦人。也不确定额外对象对性能的影响

更多信息：

• 此池将通过多个线程并发访问。数据库操作不是同构的，因此可以按任何顺序返回连接

• 我更愿意对消费者隐瞒尽可能多的删除业务

• 对于我的应用程序，速度比空间更重要

---

您可以使用

std:：function

作为

std:：unique\u ptr

中的删除器类型

std::unique_ptr<DataStore, std::function<void(DataStore*)>> get_ptr()
{
    auto deleter = [index](DataStore*) {
        connList[index].second = true;
    });
    return std::unique_ptr<DataStore, std::function<void(DataStore*)>>(new DataStore(), deleter)
}

std:：unique_ptr get_ptr（）
{
自动删除程序=[index]（数据存储*）{
connList[index].second=true；
});
return std:：unique_ptr（new DataStore（），deleter）
}

并告诉您的用户使用

using managed_ptr = std::unique_ptr<DataStore, std::function<void(DataStore*)>>;

使用managed_ptr=std:：unique_ptr；

我建议使用手动编写的删除器。与使用

：：std:：function

的方法不同，与lambda相比，此方法不应受到开销的影响：

class
t_MyDeleter
{
    private: ::std::size_t m_index;

    private: t_MyDeleter(void) = delete;

    public: t_MyDeleter(t_MyDeleter const & that) noexcept: m_index{that.m_index} {}

    public: explicit t_MyDeleter(::std::size_t const index) noexcept: m_index{index} {}

    public: void operator ()(DataStore * const p_store) const
    {
        static_cast<void>(p_store); // not used?
        // don't we also need to keep a reference to connList?
        connList[m_index].second = true;
    }
};

using
t_UniquePointerToDataStore = ::std::unique_ptr<DataStore, t_MyDeleter>;

t_UniquePointerToDataStore
Make_DataStore(void)
{
    ::std::size_t index{};
    return(t_UniquePointerToDataStore{connList[index].first, t_MyDeleter{index}});
}

类
t_MyDeleter
{
private:：std：：size\u t m\u index；
private:t_MyDeleter（void）=删除；
public:t_MyDeleter（t_MyDeleter const&that）noexcept:m_index{that.m_index}{}
public:explicit t_MyDeleter（：：std:：size_t const index）noexcept:m_index{index}{index}
public:void操作符（）（数据存储*const p_存储）const
{
静态_cast（p_存储）；//未使用？
//我们不也需要保留对connList的引用吗？
connList[m_index].second=true；
}
};
使用
t_UniquePointerToDataStore=：：std:：unique_ptr；
t_UniquePointerToDataStore
生成数据存储（无效）
{
：：std：：大小索引{}；
返回（t_UniquePointerToDataStore{connList[index]。首先，t_MyDeleter{index}）；
}

同样，通过C++14函数的自动返回类型推断，可以在不做任何更改的情况下使用lamba：

auto
Make_DataStore(void)
{
    auto connDeleter = [index](DataStore* p) { connList[index].second = true; };
    return(::std::unique_ptr<DataStore, decltype(connDeleter)>{connList[index].first, connDeleter});
}

自动
生成数据存储（无效）
{
auto-connDeleter=[index]（数据存储*p）{connList[index].second=true；}；
返回（：：std:：unique_ptr{connList[index]。首先，connDeleter}）；
}

即使我更喜欢自定义的deleter类，隐藏deleter的另一种可能性是使用

std:：shared_ptr

（因此比

std:：unique_ptr

开销更大）：

std:：共享的\u ptr MakeDataStore（int索引）
{
auto-connDeleter=[index]（数据存储*p）{connList[index].second=true；}；
返回std:：shared_ptr（connList[index]。首先是connDeleter）；
}

lamba基本上是编译器生成的函数。您可以为外部代码编写自己的delete函数，并保持

索引

。使用

std:：function

作为deleter的指针类型有什么不对？@BenjaminLindley我认为在这种情况下使用

：：std:：function

会导致额外的开销，内存和计算能力。在这里使用lambda的一个潜在危险是挂起引用，因为deleter可以在不同的上下文中调用。如果对象类使用RAII惯用法，自定义删除器应该是不必要的。因为您不关心使用返回值进行内存管理：我建议您编写自己的包装器来存储索引，甚至指针本身，并使用RAII来更新布尔值。请注意，与functor或lamba相比，使用

std:：function

将需要额外的资源内存（在32位VS2017

std:：function

实例上是40字节，而functor只有4字节）以及每次调用的一些额外开销。嗯，这是有道理的。为什么要定义复制构造函数？我以为

唯一的\u ptr

无法复制？这可能包括deleter对象？此外，为了回答您在评论中提出的问题，

connList

是静态定义的，因此不需要传递。@phobos51594因为deleter对象存储在

unique\u ptr

中，所以它必须是可构造和可分配的nothrow copy或move。当调用构造函数时，将从传递的临时对象复制删除器。当

unique\u ptr

对象被移动时，删除程序将再次被复制。我明白了。我是否可以通过定义move构造函数+赋值来节省一些额外的周期，或者开销可以忽略不计？从您的描述来看，似乎我可以选择复制或移动，而移动通常更快。@phobos51594为

t\u MyDeleter

定义移动构造函数不会带来任何好处，因为它仍然会复制单个

size\u t

字段。不会返回

共享\u ptr

a

auto
Make_DataStore(void)
{
    auto connDeleter = [index](DataStore* p) { connList[index].second = true; };
    return(::std::unique_ptr<DataStore, decltype(connDeleter)>{connList[index].first, connDeleter});
}

std::shared_ptr<DataStore> MakeDataStore(int index)
{
    auto connDeleter = [index](DataStore* p) { connList[index].second = true; };

    return std::shared_ptr<DataStore>(connList[index].first, connDeleter);
}