Question

Hy, I would like to ask a question that puzzles me.

I’ve a class like this:

class A { 

private:
std::vector<Object*>* my_array_;

...

public
std::vector<Object*>& my_array(); // getter
void my_array(const std::vector<Object*>& other_array); // setter
};

I wanted to ask you, based on your experience, what is the correct way of implementing the setter and getter in a (possible) SAFE manner.

The first solution came to my mind is the following.

First, when I do implement the setter, I should:
A) check the input is not a referring to the data structure I already hold;
B) release the memory of ALL objects pointed by my_array_
C) copy each object pointed by other_array and add its copy to my_array_
D) finally end the function.

The getter may produce a copy of the inner array, just in case.

The questions are many:
– is this strategy overkilling?
– does it really avoid problems?
– somebody really uses it or are there better approaches?

I’ve tried to look for the answer to this question, but found nothing so particularly focused on this problem.

---

That of using smart pointers is a very good answer, i thank you both.. it seems I can not give “useful answer” to more than one so I apologize in advance. 🙂

From your answers however a new doubt has raised.
When i use a vector containing unique_ptr to objects, I will have to define a deep copy constructor. Is there a better way than using an iterator to copy each element in the vector of objects, given that now we are using smart pointers?

Answer 1

I’d normally recommend not using a pointer to a vector as a member, but from your question it seems like it’s shared between multiple instances.

That said, I’d go with:

class A { 
private:
   std::shared_ptr<std::vector<std::unique_ptr<Object> > > my_array_;

public
   std::shared_ptr<std::vector<std::unique_ptr<Object> > >  my_array(); // getter
   void my_array(std::shared_ptr<std::vector<std::unique_ptr<Object> > >  other_array); // setter
};

No checks necessary, no memory management issues.

If the inner Objects are also shared, use a std::shared_ptr instead of the std::unique_ptr.