I am C++11-ing some code. I have
class X { /* */ };
class A {
std::vector<X*> va_x;
};
class B {
std::vector<X*> vb_x;
std::vector<A> vb_a;
};
The X*s of "va_x" inside my class A point to objects that are also pointed to by the X*s of "vb_x" inside my class B.
Now I would like to use smart pointers. For me, it seems clear that class B has the ownership of the objects pointed by the X* (in particular because my A instances belong to B)
So I should use a unique_ptr for X inside B:
class B {
std::vector<unique_ptr<X>> vb_x;
std::vector<A> vb_a;
};
My question is, what should I do for class A? Should I keep raw pointers? By doing so, in my unit tests, I must admit that it leads to awkward things (imo), for instance (don't worry about encapsulation, that's not the point):
unique_ptr<X> x(new X());
A a;
a.va_x.push_back(&(*x)); //awkward, but what else can I do?
A.vb_a.push_back(a); //ok
B.vb_x.push_back(move(x)); //ok
You can use x.get()
, which will return the internal pointer.
Other than that, yes, using raw pointers to handle non-owning references is the way to go, see also this question.