Ttykuu

I read an interesting old question on the Software Engineering SE about how to transition away from std::auto_ptr. So I wrote a wrapper around the common subset of std::auto_ptr and std::unique_ptr.

The wrapper's mission in life at runtime is to clean up pointers created with new when the scope ends regardless of how the scope is exited. Its job at compile time is to make compilation fail as informatively as possible when fake_autoptr is used in a non-lowest-common-denominator way.

fake_autoptr is supposed to make it easier to transition away from std::auto_ptr and support both C++11 and C++03 until support for C++03 is dropped. It should behave the same way whether it is backed by an auto_ptr or a unique_ptr.

The example given in the old question is this. This example is not leveraging many of the things that an autoptr can do. I think, but am not 100% certain that the autoptr's job here is just to run delete when its destructor is called and not to steal resources from other autoptrs.

// NOT MINE DO NOT REVIEW

Foo* GetFoo()

 autoptr<Foo> ptr(new Foo);

 // Initialize Foo
 ptr->Initialize(...);

 // Now configure remaining attributes
 ptr->SomeSetting(...);

 return ptr.release();

Here is the wrapper I came up with.

#ifndef FAKE_AUTOPTR_FAKE_AUTOPTR_INCLUDED
#define FAKE_AUTOPTR_FAKE_AUTOPTR_INCLUDED 1

#include <memory>
#if __cplusplus >= 201103L
#include <type_traits>
#endif

namespace fake_autoptr_ns 
 namespace detail 
 template <class T>
 void destroy(T* goner) 
 delete goner;
 
 

 template <class T>
 class fake_autoptr 
 public:
#if __cplusplus >= 201103L
 std::unique_ptr<T, decltype(&detail::destroy<T>)> smartptr_;
 typedef decltype(smartptr_) smartptr_type;
#else
 std::auto_ptr<T> smartptr_;
 typedef std::auto_ptr<T> smartptr_type;
#endif


#if __cplusplus >= 201103L
 fake_autoptr() = delete;
 ~fake_autoptr() = default;
#else
 private:
 fake_autoptr();
 public:
#endif


#if __cplusplus >= 201103L
 template <class CtorArg>
 explicit fake_autoptr(CtorArg something) : smartptr_(something, detail::destroy<T>) 
 static_assert(std::is_same<T*, CtorArg>::value, "constructor argument must be T*");
 
#else
 template <class CtorArg>
 explicit fake_autoptr(CtorArg something) : smartptr_(something) 
#endif


 // delete special member functions
#if __cplusplus >= 201103L
 explicit fake_autoptr(const fake_autoptr<T>&) = delete;
 explicit fake_autoptr(fake_autoptr<T>&&) = delete;
 fake_autoptr& operator=(const fake_autoptr<T>&) = delete;
 fake_autoptr& operator=(fake_autoptr<T> &&) = delete;
#else
 private:
 explicit fake_autoptr(const fake_autoptr<T>&);
 fake_autoptr& operator=(const fake_autoptr<T>&);
 public:
#endif

#if __cplusplus >= 201103L
 T& operator*() = delete;
 T* get() = delete;
#endif

 const smartptr_type& operator->() const 
 return smartptr_;
 

 smartptr_type& operator->() 
 return smartptr_;
 

 T* release() 
 return smartptr_.release();
 

#if __cplusplus >= 201103L
 const T* release() const = delete;

 void reset() = delete;

 void reset() const = delete;
#endif
 ;


#endif // FAKE_AUTOPTR_FAKE_AUTOPTR_INCLUDED

This is less interesting, but here's a smoke test to make sure it works

#include "fake_autoptr.hpp"
#include <cstdio>

struct TwoInts 
 int int1;
 int int2;
 void print_first_int() 
 printf("1st %dn", int1);
 
 void print_second_int() 
 printf("2nd %dn", int2);
 
;


TwoInts* GetInt()

 using namespace fake_autoptr_ns;
 TwoInts *t = new TwoInts();
 t->int1 = 3;
 t->int2 = 7;
 fake_autoptr<TwoInts> ptr(t);
 ptr->print_first_int();
 ptr->print_second_int();
 return ptr.release();


int main() 
 TwoInts *t = GetInt();
 delete t;
 return 0;