带有 POD 数组和未初始化值的 auto_ptr

Question

这与auto_ptr for arrays 非常相似。但是，我的问题是我不想要一个初始化数组，这是 vector 将提供的（const T& value = T()）：

explicit vector(size_type count,
    const T& value = T(),
    const Allocator& alloc = Allocator());

我不希望数组初始化，因为它是一个大数组，并且值将被立即丢弃。

我目前正在使用以下内容对其进行破解，但感觉好像有问题：

//! deletes an array on the heap.
template <class T>
class AutoCleanup
{
public:
    AutoCleanup(T*& ptr) : m_ptr(ptr) { }
    ~AutoCleanup() { if (m_ptr) { delete[] m_ptr; m_ptr = NULL; }}

private:
    T*& m_ptr;
};

还有：

// AutoCleanup due to Enterprise Analysis finding on the stack based array.
byte* plaintext = new byte[20480];
AutoCleanup<byte> cleanup(plaintext);

// Do something that could throw...

C++ 为未初始化并正确删除的 POD 类型数组提供什么？

---

项目是C++03，没有像Boost这样的外部依赖。

Answer 1

根据您的问题，要解释您实际需要什么并不容易。但我猜你想要一个受堆栈保护（即绑定到堆栈的生存期）、堆分配、未初始化、动态或静态大小并与 C++11 之前的编译器兼容的数组。

auto_ptr 无法处理数组（因为它在其析构函数中不调用delete[]，而是调用delete）。

相反，我会使用 boost::scoped_array 和 new[]（它不会初始化 POD 类型 afaik）。

boost::scoped_array<MyPodType> a(new MyPodType[20480]);

如果你不想使用 boost，你可以很容易地重新实现 scoped_array，方法是将这个类包含的来自 boost 库的代码粘贴在一起：

#include <cassert>
#include <cstddef>

// From <boost/checked_delete.hpp>:
template<class T>
inline void checked_array_delete(T * x)                                                                          
{
    typedef char type_must_be_complete[sizeof(T) ? 1 : -1];
    (void) sizeof(type_must_be_complete);
    delete [] x;
}

// From <boost/smartptr/scoped_array.hpp>:
template<class T>
class scoped_array
{
private:
    T * px;

    // Make this smart pointer non-copyable
    scoped_array(scoped_array const &);
    scoped_array & operator=(scoped_array const &);

    typedef scoped_array<T> this_type;

public:
    typedef T element_type;

    explicit scoped_array(T * p = 0) : px(p)  { }

    ~scoped_array() {
        checked_array_delete(px);
    }

    void reset(T * p = 0) {
        assert(p == 0 || p != px); // catch self-reset errors
        this_type(p).swap(*this);
    }

    T & operator[](std::ptrdiff_t i) const {
        assert(px != 0);
        assert(i >= 0);
        return px[i];
    }

    T * get() const {
        return px;
    }

    operator bool () const {
        return px != 0;
    }

    bool operator ! () const {
        return px == 0;
    }

    void swap(scoped_array & b) {
        T * tmp = b.px;
        b.px = px;
        px = tmp;
    }
};