What does the standard say about how calling clear on a vector changes the capacity?

by

Depending on the version of the standard you are looking at,
clear is defined as the equivalent of erase(begin(), end()), or (in C++11):
“Destroys all elements in a. Invalidates all
references, pointers, and iterators referring to
the elements of a and may invalidate the
past-the-end iterator.”

In neither case is it allowed to modify
the capacity; the following code is guaranteed safe by the
standard:

std::vector<int> v;
for (int i = 0; i != 5; ++ i) {
    v.push_back(i);
}
assert(v.capacity() >= 5);
v.clear();
assert(v.capacity() >= 5);
v.push_back(10);
v.push_back(11);
std::vector<int>::iterator i = v.begin() + 1;
v.push_back(12);
v.push_back(13);
*i = 42;        //  i must still be valid, because none of 
                //  the push_back would have required an
                //  increase of capacity

(The reason for the change in wording in C++11: the committee
didn’t want to require MoveAssignable for clear, which would
have been the case if it were defined in terms of erase.)

More Related Contents:

  1. Is a moved-from vector always empty?
  2. Is it safe to push_back an element from the same vector?
  3. Erasing vector::end from vector
  4. Appending std::vector to itself, undefined behavior?
  5. Array of vectors
  6. How do I print out the contents of a vector?
  7. Order of evaluation of arguments using std::cout
  8. How do I sort a std::vector by the values of a different std::vector?
  9. Do distinct functions have distinct addresses?
  10. Is it safe to assume that STL vector storage is always contiguous?
  11. Efficient way of reading a file into an std::vector?
  12. Why class data members can’t be initialized by direct initialization syntax?
  13. Is a pointer with the right address and type still always a valid pointer since C++17?
  14. Why is it OK to return a ‘vector’ from a function?
  15. std::vector and contiguous memory of multidimensional arrays
  16. What is the C++ compiler required to do with ill-formed programs according to the Standard?
  17. Does not evaluating the expression to which sizeof is applied make it legal to dereference a null or invalid pointer inside sizeof in C++?
  18. C++ compile time error: expected identifier before numeric constant
  19. In C++11, does `i += ++i + 1` exhibit undefined behavior?
  20. Sorting a std::vector by the string?
  21. How to pass a vector of strings to execv
  22. Does accessing a declared non-volatile object through a volatile reference/pointer confer volatile rules upon said accesses?
  23. When instantiating a template, should members of its incomplete argument types be visible?
  24. How can an incomplete type be used as a template parameter to vector here?
  25. Vector.erase(Iterator) causes bad memory access
  26. Is there some meaningful statistical data to justify keeping signed integer arithmetic overflow undefined?
  27. How to erase & delete pointers to objects stored in a vector?
  28. C++ trying to swap values in a vector
  29. Overload resolution with ref-qualifiers
  30. Does the standard mandate an lvalue-to-rvalue conversion of the pointer variable when applying indirection?

Leave a Comment