Re: shared_ptr problems
cpisztest@gmail.com wrote:
I know about boost::weak_ptr and would use that if the problem was
limited to classes A and B, but C has a public accessor that gives
away shared_ptrs to As and I don't know what to do there. I was
thinking of trying to guarentee that Bs and Cs are only created by
As and seeing if the compiler complained or not (unknown code
base). If I can guarentee that Bs and Cs are only created by and
used by As, then I can safely use weak_ptrs...I think. I could do
that by hiding constructors of Bs and Cs making them private and
friending them to A....I think.
I'm actually not sure what exactly you are asking here? Are you
asking how to fix the code so that the objects are not leaked?
As they are, the classes you pasted are improperly implemented.
For example:
class A : public boost::enable_shared_from_this<A>
{
public:
typedef boost::shared_ptr<A> SharedPtr;
A();
~A();
void Foo();
private:
std::list<B *> m_collectionOfBs;
void CleanupBs();
};
It immediately stands out that m_collectionOfBs contains raw pointers
to dynamically allocated 'B' objects, yet the 'A' class has neither
disabled its copy constructor/assignment operator, nor implemented them.
This is the pathway to disaster.
The first question you need to ask is: Does 'A' *really* need to handle
dynamically allocated objects of type 'B', or could it simply handle them
by value?
The major reason why you would need to handle them by pointer is if
m_collectionOfBs can actually contain many different types of objects
(inherited from B). Is this the case? Some other, more minor reasons
could be that B is very heavy to handle by value, or you need to share
pointers to the objects among several other objects.
If none of that is the case, then the easiest, safest and most efficient
solution is to handle them by value instead of by pointer:
std::list<B> m_collectionOfBs;
(Also: Does it really need to be a list? Could a vector do? It's more
efficient.)
If 'A' *really* needs to handle them by pointer, then the second easiest
solution is to handle smart pointers instead:
std::list<boost::shared_ptr<B> > m_collectionOfBs;
(You don't need the full definition of 'B' to do that.)
Both of these solutions free you from the need to implement a copy
constructor and assignment operator for your class 'A'.
If neither solution can be used for some reason, it becomes slightly
more complicated.
--- news://freenews.netfront.net/ - complaints: news@netfront.net ---