Greetings. I've been wrestling with some legacy C code which makes heavy use of raw arrays of pointers-- typically pointers to quasi-OO C structures which have specific "constructor" and "destructor" functions. Here's a contrived example: struct OldStuff { ... }; OldStuff* CreateOldStuff(); void DestroyOldStuff(OldStuff*); Then there are functions which return zero or more of these structures as output via an array of pointers: bool FiddleWithStuff(OldStuff** output, size_t count, ...); It's the callers responsibility to properly dispose of the results returned in 'output' by calling DestroyOldStuff() on each element. What I'd like to be able to do is provide a wrapper for functions like this which provide automatic management for the output values. Here's an example using ptr_vector: struct OldStuff_Destroyer { // What's up with the const pointer to deallocate?!? static void deallocate_clone(const OldStuff* p) { DestroyOldStuff(const_cast<OldStuff*>(p)); } }; typedef boost::ptr_vector< boost::nullable<OldStuff>, OldStuff_Destroyer> StuffVec_t; bool Wrapper(StuffVec_t& output, size_t count, ...); The pointer containers like ptr_vector seem to be a good fit, particularly given the customizable cloning behavior and is a very natural transition from an array of pointers. The problem I'm having is how to couple ptr_vector to the legacy code which expects to use arrays of pointers. Here's what I'd like to do: bool Wrapper(StuffVec_t& output, size_t count, ...) { // Won't work: resize() isn't supported output.resize(count); // Won't work: no way to get to raw storage return FiddleWithStuff(&output[0], count, ...); } As noted, this won't work for a couple of reasons. The pointer containers have an aversion to containing NULL pointers, which is why I imagine resize() isn't supported. And there's no way to get a pointer to the raw storage for the pointers to provide a buffer for the legacy code to write into. I do understand why the pointer containers don't support what I'm trying to do here, and the restrictions are entirely reasonable to provide additional safety. But... Using a container of smart pointers isn't an option, either, for the same reason: the need to have legacy code write into the storage as if it were an array. Does anyone have any suggestions on how to encapsulate a collection of pointers and some associated deletion logic? Obviously I could write my own pointer collection that satisfies my requirements, but I was hoping to use off-the-shelf bits. Thanks for any ideas. -Chris