指向向量元素的C ++指针，元素已删除

Question

Simple question I hope..

I have a vector of elements. The elements are of my own class type. I maintain a pointer to a particular member of that vector.

Question is: If I remove the element from the vector, what happens to the pointer?

Sub-questions :

• When iterating through the vector, is there any way I can check to see if the iterator is pointing to the element to which I currently have the pointer? Would vIterator == pElement do it?
• Is there any way of erasing the element from the vector, with only a pointer to that element? If the answer to the previous question is yes, then I guess I can do it with a loop.

Thanks in advance!

Answer 1

1. It will now point to invalid memory ^a or to a different object. In general, using that pointer is now undefined behavior.

2.  if(&*vIterator == ptr) ... 

   Where * gets a reference to the object from the iterator, & gives you its address. Notice that, although &* is a no-op on pointers, here we need it because iterators overload * .

3. You can do with a linear search, but it's needlessly inefficient. You can take advantage from the fact that storage is contiguous, and do:

    vec.erase(vec.begin()+(ptr-&vec[0])); 

   ptr-&vec[0] gives you the index in the vector due to usual pointer arithmetic, and adding it to the begin iterator results in an iterator to it.

---

a. Technically the vector isn't allowed to deallocate memory on element removal, so it may be more correct to say that it may point to an invalid (=already destroyed) object.

Answer 2

Pointer to removed object

That highly depends on how actually do you store the classes in the vector. Let's suppose, that you're doing it in the following way:

std::vector<MyClass> classes;

If you look into std::vector 's constructor, you'll see, that it takes also another parameter, the allocator. This is because vector is responsible for taking care of allocating and deallocating memory for items, which it holds.

In case if you use the mentioned notation, the vector allocates memory each time you add item to it and deallocates, when you remove. So if you keep a pointer to some element in the vector and remove it, the pointer will then point to invalid memory (to deallocated object) and you should not use it anymore.

Situation changes, if you keep objects in the following way:

std::vector<MyClass *> classes;

In such case, vector is responsible only for keeping pointers to classes and will allocate and deallocate pointers (not thinking about what do they point to). You are then responsible for creating and destroying elements pointed to pointers kept in the vector.

Iterating

There is a simple way to check, whether iterator points to specific object. First, dereference the iterator to get the actual object: (*iter) Then ask for address of that object: &(*iter) and check, if it matches object you have a pointer to.

Erasing

Yes, you can - simply using the loop, for instance. The option Matteo suggested will work if you keep the actual objects in the vector (the first option I mentioned). This is because vector is supposed to keep all its data in a continuous block of memory and it is easy to evaluate the index of the object, when you have a pointer to it (pointer arithmetics).

Answer 3

Your vector owns the objects but you also want to be able to delete them using their pointers. You can't achieve this clearly if you store them directly in the vector since as you suspected the vector may do a reallocation when changing it's size and an insertion or deletion in the middle of the vectors will invalidate all pointers that point to the next elements.

This is where std::unique_ptr comes into play. By keeping smart pointers in your vector, you still retain ownership without having to deal with memory management and invalidation is not a problem:

std::vector<std::unique_ptr<CustomClass>> objects;
std::unique_ptr<CustomClass> object(new CustomClass());
objects.push_back(std::move(object));

Now assuming that object_pointer has the address of one of your objects you can remove that object without worrying about invalidation:

objects.erase(
     std::remove_if(objects.begin(), m_objects.end(),
        [&](const std::unique_ptr<CustomClass>& ptr) { return ptr.get() == object_pointer; }),
     objects.end()
);

Answer 4

Question If I remove the element from the vector, what happens to the pointer?

Answer

Here's the documentation on std::vector:erase

Erase elements

Removes from the vector either a single element ( position ) or a range of elements ( [first,last) ).

This effectively reduces the container size by the number of elements removed, which are destroyed.

Because vector s use an array as their underlying storage, erasing elements in positions other than the vector end causes the container to relocate all the elements after the segment erased to their new positions. This is generally an inefficient operation compared to the one performed for the same operation by other kinds of sequence containers (such as list or forward_list ).

It isn't clear to me whether the elements are required to be relocated to the existing memory or a compiler is free to allocate new memory for the elements and relocate the elements to the new memory, then delete the old memory.

Best case scenario is the elements are relocated to existing memory. Even then...

If you have a pointer to the n-th element of the vector before elements were erased from it and the size of the vector is less than n after elements have been erased, you are holding on to a dangling pointer. If you access the pointer, you are likely to get undefined behavior. If number of elements in the vector is greater or equal to n , you are pointing to a new object but it is still a valid object.

Question When iterating through the vector, is there any way I can check to see if the iterator is pointing to the element to which I currently have the pointer? Would vIterator == pElement do it?

Answer You can check whether you have the address of an element using:

if ( myptr == &(*iter) )

Question Is there any way of erasing the element from the vector, with only a pointer to that element?

Answer Since the answer to the previous question is "Yes", the answer to this question is also "yes".