5
\$\begingroup\$

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 %d\n", int1);
  }
  void print_second_int() {
    printf("2nd %d\n", 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;
}
\$\endgroup\$
  • \$\begingroup\$ Can you explain your use-case better? When would I want to use fake_autoptr<T> in preference to std::unique_ptr<T>? The only advantage to std::auto_ptr is that it compiles as C++03... but your fake_autoptr is C++11-only, so that's not why you're using it. Why not just use std::unique_ptr? \$\endgroup\$ – Quuxplusone Mar 20 at 1:30
  • \$\begingroup\$ @Quuxplusone, I've edited the code so it compiles as either C++11 or C++03 ... \$\endgroup\$ – Gregory Nisbet Mar 20 at 2:30
1
\$\begingroup\$

I'm not a 100% convinced that you should put effort in supporting C++98/03. Especially since you can upgrade your code with Clang tidy modernize However, I see the arguments on moving slowly.

That said, your code looks good. However, I do have some remarks.

#ifdef is used a lot. So often, that one can wonder whether it makes sense to use a single ifdef with separate class definitions. It might improve the readability.

I really like the deleted methods and the shadow private variants. It can help a lot in ensuring the compatibility.

Looking at the stored unique_ptr, you use a helper function to delete the stored instance. WHY? This is what the default already does with a better implementation. (No extra memory needed) I don't see a compatibility argument as you don't use it with the auto_ptr.

I see the templated constructor, however, I don't see the point of having it as a template. Instead you could just use T* directly in the wrapper?

The thing I find the strangest is your operator-> which doesn't return a raw pointer. Instead you expose the underlying storage in that signature.

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.