Question

正如标题所说，我想知道在将vector<T> a移动到vector<T> a时，这是否是阻止vector<T> b中取消分配的正确方法。

矢量标头：

template<class T, class A = std::allocator<T>>
class vector
{
    typedef typename A::size_type size_type;

    A alloc;
    T* start;
    T* end;

    public:

            explicit vector(size_type n, const T& val = T(), const A& =A());
            vector(vector&&);
            ~vector();

};

构造函数：

注意： allocate可以抛出std::bad_alloc。

template<class T, class A>
vector<T,A>::vector(size_type n, const T& val, const A& a)
    : alloc(a)
{

    start = alloc.allocate(n); //allocate memory for n elements.
    end = start + n;

    for(auto p = start; p!=end; p++)
            alloc.construct(p, val); //construct val at allocated memory.

}

移动构造函数：

问题：这是移动向量v的正确方法吗？

template<class T, class A>
vector<T,A>::vector(vector&& v)
    :alloc(v.alloc)             // copy the allocator in v.
{

    start = std::move(v.start); // move the pointer previously returned by allocator. 
    end = std::move(v.end);     // same boundary value.
    v.start = v.end = nullptr;  // nullptr to prevent deallocation when v is destroyed.
}

析构函数：

问题：根据cppreference，allocator::deallocate(p, n)从先前由allocator返回的指针释放内存，而n必须等于该数字分配给的元素。如果不是这样怎么办？我的答案是allocator::deallocate如果指针或元素数量n不等于先前对allocator::allocate(n)的调用，则不执行任何操作。这是真的？

template<class T, class A>
vector<T, A>::~vector()
{
    for(auto p = start; p!=end; p++)
            alloc.destroy(p);           //Destroy objects pointed to by alloc. 

    alloc.deallocate(start, end-start); //Deallocate memory.
}

Answer 1

这是移动向量v的正确方法吗？

看起来很好，但是std::move是多余的指针。此外，您无法取消分配end，因此您无需将其设置为空。

如果不是这样的话怎么办？我的答案是，如果指针或元素数n不等于之前对allocator :: allocate（n）的调用，则allocator :: deallocate不执行任何操作。这是真的吗？

不，行为未定义。您必须传递相同的n。

使用std :: allocator和std :: move

1 个答案: