2

I have a situation like below in which I have some problem in freeing the memory. Basically I have a vector that holds pointer to objects from classA. I have another classB that store the pointer of classA from the vector. It would make use of the objB. The problem is I need to operate on the vector to erase the pointer.

So how could I free the memory of objA as in the description below?

  1. pass by value the objA and make a copy in objB?

  2. delete the pointer to objA in the destructor of objB? ( I would not want to do that as well because it is only when the logic is fulfilled, I need to erase the pointer and delete the object. Otherwise, I would like to keep the object.

    vectorA< classA*> vt; .... storing multiple pointer to objects to vector

    classB* objB = new classB(vt.at(pos));

    some logic performed. If it is fulfilled, need to erase a particular object from vector.

    vt.erase(pos); ==> how do I free the memory if I deleted the pointer here? I could not call delete here because objB might need to use the objA later.

    classB::classB(classA* objA){ this->objA = objA; }

So there any way to free the memory using Normal pointer as of the case above? As some of the replies directed me to using smart pointer, my question is are there any penalty imposed on the performance by using smart pointer? (like C# indeterministic garbage collector is not really ideal for performance critical application).

Steveng
  • 1,451
  • 4
  • 15
  • 14
  • 6
    [Use smart pointers and RAII.](http://stackoverflow.com/questions/3681455/what-is-the-philosophy-of-managing-memory-in-c/3681471#3681471) Then you don't have to worry about managing things yourself. Really, it's much, much, much easier and far less error prone. – James McNellis Sep 30 '10 at 15:26

4 Answers4

7

At least offhand, it sounds like you're looking for shared_ptr.

Jerry Coffin
  • 476,176
  • 80
  • 629
  • 1,111
  • Thanks for the reply. So I have no way of handling it in normal pointer? This is because the vector class with the normal pointer is already in place and used... I am just trying to extend the code... – Steveng Oct 01 '10 at 13:12
  • It can be done with a raw pointer, but you're probably going to end up simulating most of the functionality of a shared_ptr (or something on that order) by the time you make it work right. – Jerry Coffin Oct 01 '10 at 13:22
1

There should be a single owner of the A objects, either vt or objB.

My inclination is towards the former.

Classes like objB who want to use the A * can use as vt.at( pos ) as you mentioned, but they should not keep a copy of the A *.

Arun
  • 19,750
  • 10
  • 51
  • 60
0

If you have Visual Studio 2008 SP1 or later then you can use std::tr1::shared_ptr. If you don't, you can use boost::shared_ptr (the same class).

Store the shared_ptr in your vector, then you don't need to worry about deallocation of memory.

Mark Ingram
  • 71,849
  • 51
  • 176
  • 230
0

As others have pointed out, perhaps before you changed your question, a shared_ptr sounds like a good idea for the vector. You might want also to use a weak_ptr in the classB reference so that the vector is in control of the lifetime (classB would have to be able to handle when the weak_ptr goes stale).

For deallocation, by default shared_ptr deletes when the reference count goes to 0. You can specify a custom deleter for your shared_ptr that gives more control over what actually happens. Check out the delayed deallocation technique for Boost shared_ptrs.

gregg
  • 1,027
  • 5
  • 6