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 std::unique_ptr that exposes a subset of std::auto_ptr's API.

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 when the code is compiled as C++11 or later.

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>
#include <type_traits>


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

 template <class T>
 class fake_autoptr 
 public:
 std::unique_ptr<T, decltype(&detail::destroy<T>)> uniqptr_;
 using my_uniqptr = decltype(uniqptr_);

 fake_autoptr() = delete;
 ~fake_autoptr() = default;

 template <class CtorArg>
 explicit fake_autoptr(CtorArg something) : uniqptr_(something, detail::destroy<T>) 
 static_assert(std::is_same<T*, CtorArg>::value, "constructor argument must be T*");
 


 // delete special member functions
 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;

 T& operator*() = delete;
 T* get() = delete;

 const std::unique_ptr<T>& operator->() const 
 return uniqptr_;
 

 my_uniqptr& operator->() 
 return uniqptr_;
 

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

 const T* release() const = delete;

 void reset() = delete;

 void reset() const = delete;
 ;


#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;
 fake_autoptr<TwoInts> ptr(new TwoInts3, 7);
 ptr->print_first_int();
 ptr->print_second_int();
 return ptr.release();


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