c++ - RAII - 存储 `void*&` 或 `void**`

Question

我正在设计一个包装类来提供 RAII 功能。原始用例如下:

void* tid(NULL);
OpenFunc(&tid);
CloseFunc(&tid);

我引入一个新的包装类之后，我希望以后的用法是这样的:

void* tid(NULL);
TTTA(tid);

或

TTTB(tid);

问题:

TTTA 或 TTTB 哪个实现更好？或者都不好，请介绍一个更好的。

我担心的一件事是，在分配资源后，id 将在 TTTA 或 TTTB 类之外访问，直到id 被销毁。根据我的理解，我的设计不应该为此产生副作用。

谢谢

class TTTA : boost::noncopyable
{
public:
    explicit TTTA(void *id)
        : m_id(id)
    {
        OpenFunc(&m_id); // third-party allocate resource API
    }

    ~TTTA()
    {
        CloseFunc(&m_id); // third-party release resource API
    }   
private:
    void* &m_id; // have to store the value in order to release in destructor
}

class TTTB : boost::noncopyable
{
public:
    explicit TTTB(void *id)
        : m_id(&id)
    {
        OpenFunc(m_id); // third-party allocate resource API
    }

    ~TTTB()
    {
        CloseFunc(m_id); // third-party release resource API
    }   
private:
    void** m_id; // have to store the value in order to release in destructor
}

//传入指针比较

class TTTD
{
public:
    TTTD(int* id)    // Take as reference, do not copy to stack.
        : m_id(&id)
    {
        *m_id = new int(40);
    }

private:
    int** m_id; 
};


class TTTC
{
public:
    TTTC(int* &id)    
        : m_id(id)
    {
        m_id = new int(30);
    }

private:
    int* &m_id; 
};

class TTTB
{
public:
    TTTB(int* id)    
        : m_id(id)
    {
        m_id = new int(20);
    }

private:
    int* &m_id; 
};

class TTTA
{
public:
    TTTA(int** id)    
        : m_id(id)
    {
        *m_id = new int(10);
    }

private:
    int** m_id; 
};


int main()
{
    //////////////////////////////////////////////////////////////////////////
    int *pA(NULL);
    TTTA a(&pA);
    cout << *pA << endl; // 10

    //////////////////////////////////////////////////////////////////////////
    int *pB(NULL);
    TTTB b(pB);
    //cout << *pB << endl; // wrong

    //////////////////////////////////////////////////////////////////////////
    int *pC(NULL);
    TTTC c(pC);
    cout << *pC << endl; // 30

    //////////////////////////////////////////////////////////////////////////
    int *pD(NULL);
    TTTD d(pD);
    cout << *pD << endl; // wrong
}

Answer 1

两者都以糟糕的方式崩溃。

TTTA 存储对存储在堆栈中的变量(参数 id)的引用。
TTTB 存储指向存储在堆栈中的变量的指针。

这两次，当构造函数返回时，变量超出范围。

编辑:由于您希望修改值，最简单的解决方法是将指针作为引用；这将使 TTTC 引用实际指针，而不是将指针作为非引用参数时所做的本地拷贝；

class TTTC : boost::noncopyable
{
public:
    explicit TTTA(void *&id)    // Take as reference, do not copy to stack.
        : m_id(id)
...
private:
    void* &m_id; // have to store the value in order to release in destructor
}

破坏版本的简单测试是向类添加一个print 方法来打印指针值并执行；

int main() {

  void* a = (void*)0x200;
  void* b = (void*)0x300;

  {
    TTTA ta(a);
    TTTA tb(b);

    ta.print();
    tb.print();
  }
}

TTTA 和 TTTB 在我的机器上都打印为 0x300。当然，结果真的是UB；所以你的结果可能会有所不同。