Question

这与auto_ptr for arrays非常相似。但是，我的皱纹是我不想要一个初始化的数组，这是simulator is already running提供的（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;
};

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，可以通过将此类包含的代码放在boost库中来轻松地重新实现scoped_array：

#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;
    }
};

auto_ptr，包含POD和未初始化值的数组

1 个答案: