When shrinking a container via resize, in which order are the elements destroyed?

Question

If I have a standard C++ container std::vector<Bar> and I shrink it by calling .resize() with a size smaller than the current .size(), in which order are the extra elements destroyed?

(Implementation choices are interesting if you can find two implementations which differ.)

(This was inspired by a comment from James Kanze.)

Answer 1

Based on the January 2012 working draft

The January 2012 working draft contains the C++11 standard plus minor editorial changes.

Source, working draft

For vector:

void resize(size_type sz);
Effects: If sz <= size(), equivalent to erase(begin() + sz, end());. If size() < sz, appends sz - size() value-initialized elements to the sequence.

vector::erase does not specify the order of removal. I would expect it to be in order from begin() + sz to end(), because that makes sense to me, but that is just my expectation. I can't find anything about it in the standard.

The implementation of vector distributed with Visual Studio 2013 does appear to indeed erase in that order, as does MinGW's g++ 4.8.1 as well as g++ 4.7.3 (not MinGW). These are the compilers I happen to have easy access to.

In the same standard, for list:

void resize(size_type sz);
1 Effects: If size() < sz, appends sz - size() value-initialized elements to the sequence. If sz <= size(), equivalent to

list<T>::iterator it = begin();
advance(it, sz);
erase(it, end());

and

void resize(size_type sz, const T& c);
Effects:

if (sz > size())
    insert(end(), sz-size(), c);
else if (sz < size()) {
    iterator i = begin();
    advance(i, sz);
    erase(i, end());
}
else
    ; // do nothing

It then goes on to specify absolutely nothing useful about ordering for list::erase.

The implementation of list distributed with Visual Studio 2013 does appear to erase in reverse order, while MinGW's g++ 4.8.1 and g++ 4.7.3 (not MinGW) do not.

Based on the latest working draft at the time of writing

Working draft

For vector

void resize(size_type sz);
Effects: If sz <= size(), equivalent to calling pop_back() size() - sz times. If size() < sz, appends sz - size() default-inserted elements to the sequence.

This indicates that elements are removed in reverse order.

For list:

void resize(size_type sz);
1 Effects: If size() < sz, appends sz - size() value-initialized elements to the sequence. If sz <= size(), equivalent to

list<T>::iterator it = begin();
advance(it, sz);
erase(it, end());

and

void resize(size_type sz, const T& c);
Effects:

if (sz > size())
    insert(end(), sz-size(), c);
else if (sz < size()) {
    iterator i = begin();
    advance(i, sz);
    erase(i, end());
}
else
    ; // do nothing

It then goes on to specify absolutely nothing useful about ordering for list::erase.

For deque the standard specifies the same behavior as for vector.

Answer 2

With the exception of std::basic_string and std::forward_list, the standard defines resize in terms of erase (in cases where the new size is smaller than the original size), so the question is really: does erase( begin, end ) specify any order of destruction. And all that I can find here is in Table 100, which says that erase( q1, q2 ) "Erases the elements in the range [q1, q2)". Which (to me, at least) still leaves the question open: when the standard uses the notation [q1, q2) (where q1 and q2 are iterators), does it imply in order, or not? A priori, I would think not. At least in the <algorithms> section, it explicitly states when the operations must be in order (and the fact that it explicitly states it in some specific cases sort of suggests that it isn't required in cases where it isn't specified).

For what it's worth: for std::list<>::resize(), g++ calls delete in ascending order; VS in descending order. In the case of VS, this is different than the order of destruction of std::list<>::erase (which may be legal, if the order of destruction is unspecified, and allowed to vary from one call to the next).

Answer 3

It depends on the container. For example the effect of applying resize to vectors is the following

12 Effects: If sz <= size(), equivalent to calling pop_back() size() - sz times

So for vectors the order of destroying of elemeents starts from the last element.

For lists the approach is other

Effects: If size() < sz, appends sz - size() default-inserted elements to the sequence. If sz <= size(), equivalent to list::iterator it = begin(); advance(it, sz); erase(it, end());

But there is nothing said in which order the elements are erased.