Add elements and clear a vector of pointers in C++

Question

I would like to add 2 elements to a vector<Node*> and then clear all the elements and release the memory.
Does this code do that in a right way?

#include <stdlib.h>
#include <iostream>
#include <vector>

using namespace std;

class Node {
public:
    int value;
    // ...and some other fields and methods...
};

int main(int argc, char** argv) {
    Node* n = new Node;
    n->value = 20;
    vector<Node*> v;
    v.push_back(n);
    n = new Node;
    n->value = 52;
    v.push_back(n);
    for (vector<Node*>::iterator i = v.begin(); i != v.end(); i++) {
        cout << (*i)->value << endl;
        delete *i;
        *i = NULL;
    }
    v.clear();
    return (EXIT_SUCCESS);
}

Answer 1

It looks fine to me. There are a few things that I'd change (subjectively):

*i = NULL;  // This is unnecessary.

Then I'd avoid reusing n (actually, I'd avoid it entirely):

v.push_back(new Node);
v.back()->value = 20;
v.push_back(new Node);
v.back()->value = 52;

Also, you may want to consider smart pointers to track your memory for you. See shared_ptr and ptr_vector.

Answer 2

That will do what you expect. However, clear() is totally unnecessary since the vector will be destroyed right after that when you leave the current scope (which also happens to be the end of the function and the end of the program in this case). If you were planning on keeping the vector around to do more with it, then clear() would remove all of the pointers from the vector. As it is, the vector is being destroyed right after, so there's no point in calling clear().

Also, the nitpicker in me wants to say that you should use ++i in your loop instead of i++ since i++ creates a temporary that the compiler can't optimize away (since you're dealing with an overloaded operator). Also, since you're just going to destroy the vector right after deleting everything in it, there's not much point in setting all of it's elements to NULL. If you were going to re-use the elements rather than clear or destroy the vector, then that would be a good idea. But in this case, it's just inefficient.

Answer 3

Yes that works.

Some remarks :

• Instead of including stdlib.h, the c++ equivalent is cstdlib.
• Your vector could be vector<Node> if you don't really need pointers; and it would be better to use smart pointers if you need them.