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 autoptr
s.
// 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;
}
fake_autoptr<T>
in preference tostd::unique_ptr<T>
? The only advantage tostd::auto_ptr
is that it compiles as C++03... but yourfake_autoptr
is C++11-only, so that's not why you're using it. Why not just usestd::unique_ptr
? \$\endgroup\$