Handling vectors of objects containing dynamically allocated members

Question

Let's assume I have a class which contains a dynamically allocated member, as shown below:

class example
{
  private:
          otherClass * pointer;
  public:
          example(int foo){ pointer = new otherClass(foo); }
          ~example(){delete pointer;}
};
//defining template parameter
example template(1);

Now lets assume that I want to dynamically push_back that template object into a vector, as shown below:

std::vector<example> myVector;
for(int i=0; i<5; i++)
   myVector.push_back(template);
myVector.erase(myVector.begin());

My question is: How do I prepare the class to handle dynamically allocated pointers? I know I need to overload the copy constructor, but do I also need to overload the copy assignment? what about move constryctor or move assignment? Are there any other precautions that I forgot about?

I suggest you pick another name for the class, as it could be confused with C++ templates. — Some programmer dude, Mar 16 '14 at 18:48
Have a look at shared_ptr or unique_ptr depending on your use case. — Eric Fortin, Mar 16 '14 at 18:49
And read about [the rule of three](http://en.wikipedia.org/wiki/Rule_of_three_%28C%2B%2B_programming%29). — Some programmer dude, Mar 16 '14 at 18:49
You would have to make your class follow [*the rule of three*](http://stackoverflow.com/questions/4172722/what-is-the-rule-of-three), or design it in a way that it doesn't have to do resource management directly. — juanchopanza, Mar 16 '14 at 18:49
`template` is a keyword so actually it is illegal to try to use it as an identifier. — M.M, Mar 16 '14 at 20:50

score 0 · Answer 1 · answered Mar 16 '14 at 21:11

I am not sure I understood well your problem, so I will start first by telling what I undrestood.

Your vector after the for loop contains 5 objects. Each of those objects points to the same oject of otherClass.
Once you will erase one object, the destructor will be automatically called and the object of otherClass will be deleted.

The problem is that the 4 remaining objects in vector point now to some memory that was already deleted.

the solution to your problem in my opinion is to change the definition of your class and use Reference Counting Smart Pointers.

class example
{
  private:
      std::shared_ptr<otherClass> pointer;
  public:
      example(int foo) : pointer(new otherClass(foo)){ }
      ~example(){}
};

This way, only deleting the 5th object from your vector will delete the object of otherClass.

score 0 · Accepted Answer · answered Mar 16 '14 at 21:23

How do I prepare the class to handle dynamically allocated pointers? I know I need to overload the copy constructor, but do I also need to overload the copy assignment? what about move constryctor or move assignment?

There are three choices how to implement copying of the dynamically allocated members:

Disable copying by making the copy constructor and assignment operator non-private or deleted.
Shallow copy of the pointer members by using pointers with shared ownership semantics, such as std::shared_ptr. Use the compiler generated copy constructor and assignment.
Deep copy. By storing members by value and using the compiler generated copy constructor and assignment, or, for pointer members, allocating new copies in the user defined copy constructor and assignment operator along with the move overloads.

Handling vectors of objects containing dynamically allocated members

2 Answers2