确保销毁功能被称为

Question

有人使用共享指针来确保上述句柄在不再需要时被销毁。

实际上，InitDemoStruct() DestroyStruct() struct DemoStruct 的实现对我来说是不透明的。它们是由其他人提供的。

虽然这段代码按预期工作，但它看起来确实很奇怪：

通常会看到智能指针指向特定的类或结构，例如：std： :shared_ptr; ptr2object;最近看到这样的用法。使用智能指针指向特定类或结构的指针，例如：std::shared_ptrptr2point_of_object;

更新：nwp提供了答案。

这是前面提到的代码片段：

#include <memory>
#include <iostream>

struct DemoStruct;
using DemoStructHandle = DemoStruct* ;

//In practice, the implementation of  `InitDemoStruct()` `DestroyStruct()` `struct DemoStruct` is opaque to me.
//They are provided by others.
struct DemoStruct{
};


void InitDemoStruct(DemoStructHandle* handle_ptr){
    *handle_ptr = new DemoStruct(); 
    //may do some other meaningful init in InitDemoStruct(); 
    };


void DestroyStruct(DemoStructHandle* handle_ptr){
    std::cout << "Destroy() is called" << std::endl;
    if(handle_ptr==nullptr){
        return;
    }

    delete *handle_ptr;
}

//I use shared pointer to ensure that the aforementioned handle is destroyed when it's no longer needed.
std::shared_ptr<DemoStructHandle> MakeDemoStructHandlePtr(void)
{  
    return std::shared_ptr<DemoStructHandle>(new DemoStructHandle(nullptr), [](DemoStructHandle* pHandle){
        DestroyStruct(pHandle);
        delete pHandle;});
}


int main()
{
    std::shared_ptr<DemoStructHandle> demo_class_handle_ptr = MakeDemoStructHandlePtr();
    InitDemoStruct(demo_class_handle_ptr.get());           
}

Answer 1

这看起来像是C ++包装器周围的C ++包装器。

在一个文件中，是很奇怪的，但是当deSostructhandle是唯一的完整类型时，您（故意）不能做得更好。

Answer 2

我假设你的问题是如何避免双重间接（指针到指针）。您可以这样做：

std::shared_ptr<DemoStruct> MakeDemoStructPtr(/*void not required in C++*/)
{  
    DemoStruct *pHandle;
    InitDemoStruct(&pHandle);
    return std::shared_ptr<DemoStruct>(pHandle,
        [](DemoStruct *pHandle){
            DestroyStruct(&pHandle);
        }
    );
}


int main()
{
    std::shared_ptr<DemoStruct> demo_class_handle_ptr = MakeDemoStructPtr();
}

shared_ptr 指向 DemoStruct，而不是指向 DemoStructHandle。

如果 InitDemoStruct 有更多参数，您可以将参数添加到 MakeDemoStructPtr

Answer 3

我将使用shared_ptr这样：

struct DemoStructDeleter {
    void operator()(DemoStructHandle p) {
        DemoStructDestroy(&p);
    }
};

// in some function:
DemoStructHandle h;
InitDemoStruct(&h);
std::shared_ptr<DemoStruct> smartptr(h, DemoStructDeleter{});
// do something with smartptr

请注意，它不是sharone_ptr; deSostructhandle＆gt;，因为您不想有一个智能指针，而是到struct的智能指针本身。

如果将其包裹在出厂功能中，则不需要明确DemoStructDeleter，而是可以使用lambda函数。

Answer 4

我的回答：

class Wrarper_without_smartptr    
{
    public:
        Wrarper_without_smartptr(){
            InitDemoStruct(&handle);
        }

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

        ~Wrarper_without_smartptr(){
            DestroyStruct(&handle);
        }

    private:
        DemoStructHandle handle;
};

已更新：
也许这个一个要好得多：

class WrapperWithSmartPointer2Handle {
      public:
        WrapperWithSmartPointer2Handle()
                : handle_ptr(new DemoStructHandle(nullptr),
                             [](DemoStructHandle* handle_ptr) { DestroyStruct(handle_ptr); }) {
            InitDemoStruct(handle_ptr.get());
        }
    
        DemoStructHandle operator*() { return *handle_ptr; }
        DemoStructHandle operator->() { return *handle_ptr;}
    
      private:
        std::shared_ptr<DemoStructHandle> handle_ptr;
    };