Should I always call vector clear() at the end of the function?

Question

I have some simple function that uses vector like this (pseudo code):

void someFunc(void) {

    std::vector<std::string> contentVector;

    // here are some operations on the vector

    // should I call the clear() here or this could be ommited ?
    contentVector.clear();

}

Should I call the clear() or this could be ommited ?

Answer 1

If we look at the cppreference.com entry for std::vector::~vector it says:

Destructs the container. The destructors of the elements are called and the used storage is deallocated. Note, that if the elements are pointers, the pointed-to objects are not destroyed.

so no you don't have to call clear.

If we want to go to the draft standard, we have to look at section 23.2.1 General container requirements paragraph 4 which says:

In Tables 96 and 97, X denotes a container class containing objects of type T, a and b denote values of type X,[...]

and then look at Table 96 — Container requirements which has the following expression entry:

(&a)->~X()  

and the following note:

note: the destructor is applied to every element of a; all the memory is deallocated.

Update

This is RAII in action and as Bjarne Stroustrup says in Why doesn't C++ provide a "finally" construct?:

Because C++ supports an alternative that is almost always better: The "resource acquisition is initialization" technique (TC++PL3 section 14.4). The basic idea is to represent a resource by a local object, so that the local object's destructor will release the resource. That way, the programmer cannot forget to release the resource.

Answer 2

There is absolutely no need to do that. std::vector and all other containers automatically destroys their elements when they themselves would be destroyed. That means that their destructors are responsible for that action. So, don't.

The beauty of this is that containers are naturally exception safe^[1]:

void someFunc(void) {

    std::vector<std::string> contentVector;

    // here are some operations on the vector

    throw std::runtime_error("I just want to throw!");

    contentVector.clear();
}

Will the line contentVector.clear(); be called? No. But you're still safe because it is guaranteed that contentVector's destructor will be called.

From vector^[2]:

Destructs the container. The destructors of the elements are called and the used storage is deallocated. Note, that if the elements are pointers, the pointed-to objects are not destroyed.

---

^[1] _{You still need to make your elements exception safe though (have them properly free their resources whenever their destructors are called).}

^[2] _{See comments below for some thoughts on the SGI STL docs}.

Answer 3

No need, it will get cleared automatically once it is out of scope i.e destructor will destroy the container object.

Answer 4

You can omit using the .clear() function because vector's destructor runs once contentVector goes out of scope at the '}'.

This deallocates the memory that stores vector's data.

Answer 5

Since I don't think anyone else has mentioned this, but if your vector was

std::vector<std::string*> vector;

you should free the memory allocated to each element before the function finishes (unless you've passed ownership to somewhere else - such as a global variable etc)

for (auto i : vector) {
  delete i;
}