Question

Maybe I’m overcomplicating things, but then again, I do sort of like clean interfaces. Let’s say I want a specialization of auto_ptr for an fstream – I want a default fstream for the generic case, but allow a replacement pointer?

 template <> 
 class auto_ptr<fstream> {
     static fstream myfStream; 
     fstream* ptr; 

 public: 
     auto_ptr() { 
         // set ptr to &myfStream;
     }
     reset(fstream* newPtr) {
         // free old ptr if not the static one. 
         ptr = newPtr 
     };
  } 

Would you consider something different or more elegant? And how would you keep something like the above from propagating outside this particular compilation unit?

[The actual template is a boost::scoped_ptr.]

EDIT:

It’s a contrived example. Ignore the fstream – it’s about providing a default instance of object for an auto_ptr. I may not want to provide a specialized instance, but would like to keep the auto_ptr semantics for this static default object.

class UserClass { 
public:
    auto_ptr<fstream> ptr; 
    UserClass() {  }
} 

I may not provide an dynamic object at construction time – I still want it to have a meaningful default. Since I’m not looking at ownership-transfer semantics, it really shouldn’t matter that my pointer class is pointing to a statically allocated object, no?

Answer 1

This wouldn’t end up good. The biggest problem is that std::auto_ptr deletes the underlying object in its destructor. This means your default parameter can’t be static. The only choice you can make is to do a lot of hacks there and IMHO the price you’ll pay while maintaining all that crappy code isn’t worth the small advantage you’d have.