Reputation: 31569
I have a class to do a computation using some callbacks. those callbacks need to allocate data (dynamic arrays) that needs to live outside of the callback scope but not after the class destructs. I thought about make a vector
of auto_ptr
that will just get destructed automatically when the class destructs:
class MyClass
{
vector<auto_ptr<MyObject>> ThingsToDie;
};
The problem is I have a lot of objects allocated and they don't share a base type so I can't use one vector
for this, and making a vector for every type is a lot of work.
A hierarchy like the following:
auto_ptr_base (virtual destructor)
|
auto_ptr<T>
Will solve my problem because I could do something like
class MyClass
{
vector<auto_ptr_base> ThingsToDie;
};
and the destruction will be virtually dispatched to each specialized type automatically.
The problem is that the STL doesn't have that hierarchy and I don't want to re-implement auto_ptr.
Is there any other solution for this?
Upvotes: 1
Views: 137
Reputation: 49221
You could use a vector<shared_ptr<void>>
.
Read this: Why do std::shared_ptr<void> work
Upvotes: 5