c++ - 想知道我是否可以为此使用 STL 智能指针

Question

我目前有一个 C++ 类如下:

template<class T>
class MyQueue {
   T** m_pBuffer;
   unsigned int m_uSize;
   unsigned int m_uPendingCount;
   unsigned int m_uAvailableIdx;
   unsigned int m_uPendingndex;
public:
    MyQueue(): m_pBuffer(NULL), m_uSize(0), m_uPendingCount(0),   m_uAvailableIdx(0),
            m_uPendingndex(0)
    {
    }

    ~MyQueue()
    {
        delete[] m_pBuffer;
    }

    bool Initialize(T *pItems, unsigned int uSize)
    {
        m_uSize = uSize;
        m_uPendingCount = 0;
        m_uAvailableIdx = 0;
        m_uPendingndex = 0;
        m_pBuffer = new T *[m_uSize];
        for (unsigned int i = 0; i < m_uSize; i++)
        {
            m_pBuffer[i] = &pItems[i];
        }
        return true;
    }
};

所以，我有这个指向数组 m_pBuffer 对象的指针，我想知道是否可以用 c++ 智能指针替换这种处理方式？我知道我可以做这样的事情:

std::unique_ptr<T> buffer(new T[size]);

使用智能指针 vector 是可行的方法吗？这是推荐的和安全的吗？

[编辑] 根据答案和评论，我尝试制作一个线程安全的缓冲区数组。这里是。请评论。

#ifndef __BUFFER_ARRAY_H__
#define __BUFFER_ARRAY_H__

#include <memory>
#include <vector>
#include <mutex>
#include <thread>
#include "macros.h"

template<class T>
class BufferArray
{
public:
    class BufferArray()
        :num_pending_items(0), pending_index(0), available_index(0)
    {}

    // This method is not thread-safe. 
    // Add an item to our buffer list
    void add(T * buffer)
    {
        buffer_array.push_back(std::unique_ptr<T>(buffer));
    }

    // Returns a naked pointer to an available buffer. Should not be
    // deleted by the caller. 
    T * get_available()
    {
        std::lock_guard<std::mutex> lock(buffer_array_mutex);
        if (num_pending_items == buffer_array.size()) {
            return NULL;
        }       
        T * buffer = buffer_array[available_index].get();
        // Update the indexes.
        available_index = (available_index + 1) % buffer_array.size();
        num_pending_items += 1;
        return buffer;
    }

    T * get_pending()
    {
        std::lock_guard<std::mutex> lock(buffer_array_mutex);
        if (num_pending_items == 0) {
            return NULL;
        }

        T * buffer = buffer_array[pending_index].get();
        pending_index = (pending_index + 1) % buffer_array.size();
        num_pending_items -= 1;
    }


private:
    std::vector<std::unique_ptr<T> >    buffer_array;
    std::mutex                          buffer_array_mutex;
    unsigned int                        num_pending_items;
    unsigned int                        pending_index;
    unsigned int                        available_index;

    // No copy semantics
    BufferArray(const BufferArray &) = delete;
    void operator=(const BufferArray &) = delete;
};

#endif

Answer 1

智能指针 vector 是个好主意。它在您的类中足够安全 - 提供了自动内存释放。

虽然它不是线程安全的，并且在处理由简单指针提供给您的外部内存方面也不安全。

请注意，您当前的实现不会在析构函数中删除 pItems 内存，因此如果重构后您模仿此类，则不应使用智能指针 vector ，因为它们会删除其指针引用的内存。

另一方面，您不能保证外面的任何人都不会为提供给您的 Initialize 的 pItems 释放内存。如果你想使用智能指针 vector ，你应该为这个函数制定契约，明确说明你的类声明这个内存等 - 然后你应该修改调用你的类的外部代码以适应新的契约。 如果您不想更改内存处理，则可以使用简单指针 vector 。然而，这段代码太简单了，没有 vector 的真正好处。

请注意，这里的开销是为每个缓冲区创建智能指针类和创建 vector 类。 vector 的重新分配会占用更多内存，并且无需您直接控制即可发生。