8

我有一些处理对象创建和销毁的 C API，它提供：createObject(...)和destroy(...). 我想将它包装成一些更现代的构造/破坏机制，并将它们与智能指针一起使用。我担心在某些时候我会忘记销毁对象，或者会发生一些异常。

我知道 的自定义删除器函数shared_ptr，但我不能显式调用new，因为createOjbect函数处理初始化。

在这种情况下我可以使用 STL 智能指针吗？在这种情况下，我是否必须从头开始实现一个在构造函数中初始化、在析构函数中销毁和引用计数的类？

4

3 回答 3

9

完全能够使用std::shared_ptrcutstom 创建者和删除器创建和删除对象，但new您必须使用创建者功能。

让我们考虑一下，我们有以下创建者和删除者：

typedef struct {
    int m_int;
    double m_double;
} Foo;

Foo* createObject(int i_val, double d_val) {
    Foo* output = (Foo*)malloc(sizeof(Foo));

    output->m_int = i_val;
    output->m_double = d_val;

    puts("Foo created.");
    return output;
}

void destroy(Foo* obj) {
    free(obj);
    puts("Foo destroyed.");        
}

要管理由上述函数创建的实例Foo，只需执行以下操作：

std::shared_ptr<Foo> foo(createObject(32, 3.14), destroy);

std::shared_ptr如果您不想共享对象的所有权，则使用是一种开销。在这种情况下，std::unique_ptr情况要好得多，但对于这种类型，您必须定义一个自定义删除器仿函数，它可以使用它删除托管Foo实例：

struct FooDeleter {
    void operator()(Foo* p) const {
        destroy(p);
    }
};
using FooWrapper = std::unique_ptr<Foo, FooDeleter>;

/* ... */

FooWrapper foo(createObject(32, 3.14));
于 2017-08-26T08:17:38.163 回答
6

C++17。

template<auto X> using constant_t=std::integral_constant<std::decay_t<decltype(X)>, X>
template<auto X> constexpr constant_t<X> constant{};
template<class T, auto dtor> using smart_unique_ptr=std::unique_ptr< T, constant_t<dtor> >;

现在假设你有一个Bob 用Bob* createBob(some_args...)and包装的 C API destroyBob(Bob*)：

using unique_bob=smart_unique_ptr< Bob, destroyBob >;
unique_bob make_unique_bob(some_args args){
  return unique_bob( createBob(args) );
}

aunique_bob可以隐式移动到 ashared_ptr<Bob>中。

一些额外的假设可以使这项工作在 C++14 中工作：

template<class T, void(*dtor)(T*)> using smart_unique_ptr=std::unique_ptr< T, std::integral_constant<decltype(dtor),dtor> >;

假设 dtor 签名是void(T*).

在 C++11 中，您必须为零开销 unqiue ptrs 编写一个新的无状态函数指针调度程序。

于 2017-08-26T11:57:05.063 回答
1

为我的案例发布完整的解决方案：

根据@Akira 的建议，我使用共享指针对其进行了包装，因为我希望这个对象在许多宫殿中共享，并且 lambda：

// coming from some API:
struct SomeStruct;
bool initializedata(SomeStruct **data);
bool destorycdata(SomeStruct **data);

class SomeStructWrapper
{
public:
    SomeStructWrapper()
    {
        SomeStruct* data;
        if(initializedata(&data))
        {
            m_data = std::shared_ptr<SomeStruct>(data, [](SomeStruct* ptr){
                destorycdata(&ptr);
            });
        }
        else
        {
            throw std::runtime_error("Data was not initalized");
        }
    }

    const SomeStruct* operator->() const {return m_data.get();}
    SomeStruct* operator->() {return m_data.get();}

private:
    std::shared_ptr<SomeStruct> m_data;
};
于 2017-08-26T17:46:09.087 回答