Fast way to implement pop_front to a std::vector

Question

I'm using some classes and several utility methods that use std:: vector.

Now I need to use each frame a pop_front - push_back method on one of those classes (but they are all linked, and work together so I can't change only one).

Most of the operations are iterate over all element and push_back operations, so what I should do for the best work is: fork the repository of those classes and utilities, template everything, and use deque or list.

But this means a lot of code rewriting and a lot of testing that will make me miss the deadline.

So I need advice to write an efficient pop_front to a static-size vector (the size will not change).

I've found here a way:

template<typename T>
void pop_front(std::vector<T>& vec)
{
   vec.front() = vec.back();
   vec.pop_back();
   vec.front() = vec.back();  // but should this work?
}

And another idea should be:

template<typename T>
void pop_front(std::vector<T>& vec, already_allocated_vector vec1)
{
   vec1.clear();
   copy(vec.begin(), vec.end()-1, vec1.begin());
   copy(vec1.begin(), vec1.end(), vec.begin());
}

What is the faster of these two solutions? Any other solutions?

What do you mean by "the size will not change"? After doing the pop_front, the vector will be the same size as before? If so, should the last element be garbage? — Vaughn Cato, Feb 25 '12 at 15:48
the vector have the same size, because after a pop i suddenly do a push. each frame i made a pop and a push in the same method so before and after this method the vector is of the same size — nkint, Feb 25 '12 at 16:42
Before worrying about speed, worry about **correctness**. All the speed in the world means nothing if the result you get is just plain wrong, and as far as I can tell, both your candidates are wrong. The first one should be named `pop_back_and_overwrite_front_with_penultimate`, and the second one should be named `invoke_undefined_behavior_and_pop_back`. (Writing to `vec1.begin()` is undefined because `vec1` is empty; you'd need to write `vec1.resize(vec.size() - 1)` instead of `vec1.clear()`.) When I'm dealing with vector operations, I sometimes draw a picture. Maybe that would help you, too. — Rob Kennedy, Feb 25 '12 at 18:25
heard of `std::deque`? is as good as `std::vector`, but can `pop_front()` — Sebastian Mach, Feb 27 '12 at 11:08
@SebastianMach I also looking for the same thing. unlike `std::vector`, `std::deque` is not continuous memory. — JustWe, Feb 11 '20 at 06:42

Mankarse · Accepted Answer · 2012-02-25T15:48:23.670

52

I would expect:

template<typename T>
void pop_front(std::vector<T>& vec)
{
    assert(!vec.empty());
    vec.front() = std::move(vec.back());
    vec.pop_back();
}

to be the most efficient way of doing this, but it does not maintain the order of the elements in the vector.

If you need to maintain the order of the remaining elements in vec, you can do:

template<typename T>
void pop_front(std::vector<T>& vec)
{
    assert(!vec.empty());
    vec.erase(vec.begin());
}

This will have linear time in the number of elements in vec, but it is the best you can do without changing your data structure.

Neither of these functions will maintain the vector at a constant size, because a pop_front operation will by definition remove an element from a container.

edited Feb 25 '12 at 15:48

answered Feb 25 '12 at 15:33

Mankarse

39,818
11
97
141

I think it is assumed that the order has to be preserved since `std::vector::pop_back` preserves order. – HelloGoodbye Jun 12 '15 at 20:26
isn't it better to include `vec.push_back(new_value) vec.shrink_to_fit()` after? – Jorrit Smit Nov 08 '15 at 23:05

Kerrek SB · Answer 2 · 2012-02-25T15:41:48.037

9

Since pop_front() only erases the first element, the direct implementation is this:

template <typename V>
void pop_front(V & v)
{
    assert(!v.empty());
    v.erase(v.begin());
}

Don't worry about speed for now. If you want to go back and optimize code, ask for dedicated project time.

edited Feb 25 '12 at 15:41

answered Feb 25 '12 at 15:34

Kerrek SB

464,522
92
875
1,084

sorry i don't understand your code it shoudn't keeo only the first element? i want to erase only the first element, shouldn't it be: v.erase(v.begin(), v.begin()+1); ? – nkint Feb 25 '12 at 15:41

score 2 · Answer 3 · answered Aug 17 '19 at 09:16

I also have a way... Not so good tho..

This looks like @0xPwn's solution, but he didn't reverse the vector the second time. You will probably understand this code, so i will not explain it.

#include <algorithm>
#include <vector>
template <typename T>
void pop_front(std::vector<T>& vec){
    std::reverse(vec.begin(),vec.end()); // first becomes last, reverses the vector
    vec.pop_back(); // pop last
    std::reverse(vec.begin(),vec.end()); // reverses it again, so the elements are in the same order as before

}

can it BE more inefficient? – Kennet Celeste Oct 18 '21 at 00:51 — Kennet Celeste, Oct 18 '21 at 00:51

score 1 · Answer 4 · answered Jul 06 '16 at 07:37

if you just try to erase the first element then in the function use:

if (my_vector.size()){ //check if there any elements in the vector array
    my_vector.erase(my_vector.begin()); //erase the firs element
}

if you want to emulate pop front for the entire vector array ( you want to keep pop out every element from start to end) , i suggest on:

reverse(my_vector.begin(),my_vector.end());  // reverse the order of the vector array
my_vector.pop_back();   // now just simple pop_back will give you the results

Fast way to implement pop_front to a std::vector

4 Answers4

Linked