Gfrktyl

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;

}