Does Erasing Pointers from a Vector in C Destroy the Referenced Objects?

Does Erasing Objects from a Vector of Pointers Destroy the Objects Themselves?

When handling vectors of pointers to objects, it's important to understand the implications of using the erase() function. While erase() removes an element from a vector and calls its destructor, this does not automatically destroy the referenced object.

Implications for Object Pointers in Vectors

In the context of object pointers, erase() merely detaches the pointer from the vector but doesn't take ownership of destroying the underlying object. To ensure proper resource management, you must explicitly call delete on each pointer to delete the referenced object.

Suggested Approach to Safely Erasing Pointers

To safely erase pointers and their associated objects from a vector, you can use the following approach:

<code class="cpp">void clearVectorContents(std::vector<YourClass*> &a) {
    for (int i = 0; i < a.size(); i++) {
        delete a[i]; // Delete the object pointed to by each pointer
    }
    a.clear(); // Remove pointers from the vector
}

Alternative Approach Using Shared Pointers

For a more elegant and generic solution, consider using boost::shared_ptr. Shared pointers automatically manage resource ownership and deletion, making it safer and easier to handle vectors of pointers.

Enhanced Solution Using Templates and Functors

This improved solution employs templates and functors to simplify the pointer deletion process:

<code class="cpp">template<class T> class DeleteVector {
    public:
    // Delete pointer
    bool operator()(T x) const { delete x; return true; }
};</code>

Usage:

<code class="cpp">for_each(myclassVector.begin(), myclassVector.end(), DeleteVector<myclass*>());</code>

Example Code

The following example demonstrates the usage of the enhanced solution:

<code class="cpp">#include <functional>
#include <vector>
#include <algorithm>
#include <iostream>

// Your class
class myclass {
    public:
    int i;
    myclass(): i(10) {}
};

int main() {
    // Vector of pointers to myclass objects
    std::vector<myclass*> myclassVector;
    
    // Add objects to vector
    for (int i = 0; i < 10; ++i) myclassVector.push_back(new myclass);

    // Print initial vector contents
    for (auto& obj : myclassVector) std::cout << " " << obj->i;

    // Delete vector contents using enhanced solution
    for_each(myclassVector.begin(), myclassVector.end(), DeleteVector<myclass*>());

    // Clear vector
    myclassVector.clear();

    // Print vector size after deletion
    std::cout << "\n" << myclassVector.size();
    
    return 0;
}</code>

By utilizing these approaches, you can safely remove elements from vectors containing object pointers while ensuring proper resource management and object destruction.

The above is the detailed content of Does Erasing Pointers from a Vector in C Destroy the Referenced Objects?. For more information, please follow other related articles on the PHP Chinese website!