How to delete vector c

vector erase() and clear() in C++

Vectors are same as dynamic arrays with the ability to resize itself automatically when an element is inserted or deleted, with their storage being handled automatically by the container.

clear() function is used to remove all the elements of the vector container, thus making it size 0.

Syntax :

Examples:

Errors and Exceptions
1. It has a no exception throw guarantee.
2. Shows error when a parameter is passed.

Output:

Time Complexity: O(N)
All elements are destroyed one by one.

erase() function is used to remove elements from a container from the specified position or range.
Syntax :

Errors and Exceptions
1. It has a no exception throw guarantee if the position is valid.
2. Shows undefined behavior otherwise.
Removing an element from a particular position:

Output:

Removing elements within a range:

Output:

Application
Given a list of integers, remove all the even elements from the vector and print the vector.

Algorithm
1. Run a loop till the size of the vector.
2. Check if the element at each position is divisible by 2, if yes, remove the element and decrement iterator.
3. Print the final vector.

Output:

Time Complexity: O(N) in the worst case as an erase takes linear time.

clear() removes all the elements from a vector container, thus making its size 0. All the elements of the vector are removed using clear() function.
erase() function, on the other hand, is used to remove specific elements from the container or a range of elements from the container, thus reducing its size by the number of elements removed.

How do I erase an element from std::vector<> by index?

16 Answers 16

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

To delete a single element, you could do:

Or, to delete more than one element at once:

The erase method on std::vector is overloaded, so it’s probably clearer to call

when you only want to erase a single element.

The erase method will be used in two ways:

Erasing single element:

Erasing range of elements:

Erase an element with index :

Erase an element with value:

Actually, the erase function works for two profiles:

Removing a single element

Removing a range of elements

Since std::vec.begin() marks the start of container and if we want to delete the ith element in our vector, we can use:

If you look closely, vec.begin() is just a pointer to the starting position of our vector and adding the value of i to it increments the pointer to i position, so instead we can access the pointer to the ith element by:

So we can write:

If you have an unordered vector you can take advantage of the fact that it’s unordered and use something I saw from Dan Higgins at CPPCON

Since the list order doesn’t matter, just take the last element in the list and copy it over the top of the item you want to remove, then pop and delete the last item.

It may seem obvious to some people, but to elaborate on the above answers:

If you are doing removal of std::vector elements using erase in a loop over the whole vector, you should process your vector in reverse order, that is to say using

instead of (the classical)

Below is a simple example illustrating this where I want to remove all the odds element of an int vector;

Note that on the second version with increasing indices, even numbers are not displayed as they are skipped because of i++

How to really delete vectors

I am quite new to C++ memory management because unlike C, there are more hurdles to freeing all memory.

I am trying to successfully delete a pointer to vector of any type (i.e. vector * data)

However, I get a memory leak after using valgrind

How can I be able to get rid of all traces of memory leaks with pointer to vector (i.e. at runtime)?

4 Answers 4

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

For starters, I don’t believe there is a leak. Did you properly read the Leak Summary you posted for the program?:

You’ve lost 0 bytes in 0 blocks. valgrind can’t find any definite, indirect, or possible leaks. Your program is just fine.

As an aside: You. really shouldn’t be using new or delete in this situation with that vector. C++, exactly like C, has things that come into and go out of scope on the stack if you declare them as regular variables. The following code achieves exactly what you did in your question, without the use of new and delete:

The stack will clean itself up magically, because std::vector has a destructor that cleans up its resources when it goes out of scope. You don’t need to make it dynamic and put it on the heap / free-store area of program memory, when the stack will do it just fine.

Also, it sounds like you come from C, so I’ll take the time to say: Welcome to C++. 😀

C++ delete vector, objects, free memory

I am totally confused with regards to deleting things in C++. If I declare an array of objects and if I use the clear() member function. Can I be sure that the memory was released?

Can I safely call clear to free up all the memory? Or do I need to iterate through to delete one by one?

If this scenario is changed to a pointer of objects, will the answer be the same as above?

7 Answers 7

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

You can call clear, and that will destroy all the objects, but that will not free the memory. Looping through the individual elements will not help either (what action would you even propose to take on the objects?) What you can do is this:

That will create an empty vector with no memory allocated and swap it with tempVector, effectively deallocating the memory.

There are two separate things here:

If I change the example so v becomes a pointer to a dynamically-allocated vector, you need to explicitly delete it, as the pointer going out of scope at 2 doesn’t do that for you. It’s better to use something like std::unique_ptr in that case, but if you don’t and v is leaked, the storage it allocated will be leaked as well. As above, you need to make sure v is deleted, and calling clear isn’t sufficient.

Can You Delete a Vector in C++?

Yes! Yes, but it does not go without constraints. There are two ways of deleting a vector. Again they do not go without constraints. One way of deleting a vector is to use the destructor of the vector. In this case, all the elements are deleted, but the name of the vector is not deleted. The second way to delete a vector is just to let it go out of scope. Normally, any non-static object declared in a scope dies when it goes out of scope. This means that the object cannot be accessed in a nesting scope (block). A nesting scope is an outer scope (block). A nested scope is an inner scope, which is still part of the scope of interest. These two ways of deleting a vector are discussed in this article.

In order to use a vector in C++, the program should begin with:

using namespace std ;

Article Content

Destroying the Vector

Any object created is in some scope. The vector is created and destroyed in the main() function scope in this section of the article. The syntax to destroy a vector is:

where ‘a’ is the name of the vector, and X is the class name of the vector. The vector is a data structure instantiated from a class. The name of the vector class is “vector”, with all characters in lowercase. If the name of the vector is vtr, then the vector would be destroyed with,

The following program deletes the vector:

#include
#include
using namespace std ;

for ( int i = 0 ; i vtr. size ( ) ; i ++ ) <
cout vtr [ i ] ‘ ‘ ;
>
cout endl ;

The output is nothing, indicating that all the vector elements, except the name of the vector, have been erased. That is fine. The above output was displayed by referencing the supposed elements. What if the output is displayed using the iterator? Consider the following program:

using namespace std ;

vector char > :: iterator it = vtr. begin ( ) ;

The output is still nothing. At this stage, it is safe to really conclude that when a vector is destroyed, all its elements are destroyed, except its name.

Vector Name not Destroyed

Since the vector name is not destroyed with the destructor, the name can still be reused in the same scope. The following program illustrates this:

using namespace std ;

for ( int i = 0 ; i vtr. size ( ) ; i ++ ) <

The original content of the vector had 5 characters. The 5 elements were all erased. As the vector name was reused, new 5 characters were given as content to the vector. The output showed the new content to be correct.

However, there is still a nuance. If the new content is given with the push_back() member function, the output may be incomplete, and there may be new characters in the vector. The following program illustrates this:

using namespace std ;

vtr. push_back ( ‘F’ ) ;

vtr. push_back ( ‘G’ ) ;

vtr. push_back ( ‘H’ ) ;

vtr. push_back ( ‘I’ ) ;

vtr. push_back ( ‘J’ ) ;

for ( int i = 0 ; i vtr. size ( ) ; i ++ ) <

‘F’ is missing in the output, and there are strange characters. Initially, the vector content is given using the assignment operator. The vector is destroyed and new content assigned again with the assignment operator. The vector is destroyed again, and this time the content is given with the push_back() member function. ‘F’ is missing in the output, and there are strange characters. This needs explanation:

When a vector is destroyed, all its elements are officially erased. What happens is that the elements are simply considered not to belong to the vector with immediate effect, and their memory locations are earmarked as reusable by any other code, with immediate effect. If this scheme is not perfectly carried out internally, as with the last program above, then there will be trouble, and the kind of output obtained above may result.

const vector

When a vector declaration is preceded by const, for constant, it can still be destroyed, as explained above. The following program illustrates this:

using namespace std ;

for ( int i = 0 ; i vtr. size ( ) ; i ++ ) <

The output is nothing. However, under this condition (const vector), no element can be erased using the erase() member function.

Using the name in a nested Scope

Destroying a vector with

vector destroys the content (elements) but not the vector name. The name can still be used in an inner scope, which is still part of the scope of interest. The following program illustrates this:

using namespace std ;

for ( int i = 0 ; i vtr. size ( ) ; i ++ )

Note: if a vector name is to be reused, it should not be re-declared.

Let go out of Scope

When any declared object goes out of its scope, it can no longer be accessed out of its scope. This means it can no longer be accessed in a nesting scope. However, it can be accessed in a nested scope. A nested scope is still part of the scope in question.

Access in and out of Scope

The following program illustrates how a vector is accessed in scope:

using namespace std ;

for ( int i = 0 ; i vtr. size ( ) ; i ++ )

The main() function scope nests the if-block scope. vtr declared in the if-block scope can be accessed only in the if-block scope. It cannot be accessed outside the if-block scope. It cannot be accessed outside in the main() function block that nests the if-block. The following program will not compile, as an attempt is made to access the vector outside its scope:

using namespace std ;

for ( int i = 0 ; i vtr. size ( ) ; i ++ )

cout vtr [ 1 ] endl ;

If the reader tried to compile the program, an error message would have been issued.

Nested Scope

A nested scope is still part of the scope in question. The following program illustrates how a vector can be accessed in a nested scope:

using namespace std ;

for ( int i = 0 ; i vtr. size ( ) ; i ++ )

The main() function block nests the first if-block, which nests the second if-block. The vector is declared in the first if-block. It has been accessed in the nested (inner) if-block.

The approach of letting the vector die as it goes out of scope looks preferable compared to using the destructor. When the vector goes out of scope, its name also dies. However, it is not all the time that the programmer would want the vector to die by going out of scope. So the destructor will have to be used occasionally. Both ways have their constraints.

Conclusion

One way of deleting a vector is to use the destructor of the vector. In this case, all the elements are deleted, but the name of the vector is not deleted. The second way to delete a vector is just to let it go out of scope. Normally, any non-static object declared in a scope dies when it goes out of scope. This means that the object cannot be accessed in a nesting scope (block). A nesting scope is an outer scope (block). However, it can be accessed in a nested scope. A nested scope is an inner scope, which is still part of the scope of interest. Both ways have constraints. A vector in an inner scope does not need to be destroyed with

vector before letting it go out of scope to die.