Tag: API

I read an interesting old question about the transition from software to Software Engineering SE std :: auto_ptr, So I wrote a wrapper around the general subset of std :: auto_ptr and std :: unique_ptr,

The task of the wrapper at runtime is to clean up the pointers you have created New when the scope ends, regardless of how the scope is exited. Its task at compile time is to make the compilation as informative as possible, though fake_autoptr is used in a way that is not at the lowest common denominator.

fake_autoptr should facilitate the transition from std :: auto_ptr and support both C ++ 11 and C ++ 03 until the support for C ++ 03 is dropped. It should behave the same way if it is supported by one auto_ptr or a unique_ptr,

The example in the old question is this. This example does not use many of the things that one auto_ptr can do. I think I am not 100% sure that the auto_ptr# 39; s job here is just to run Clear when his destructor is called and steals no resources from others auto_ptrs.

// DO NOT CHECK MINE

Foo * GetFoo ()
{
auto_ptr ptr (new foo);

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

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

return ptr.release ();
}

Here's the wrapper I came up with.

#ifndef FAKE_AUTOPTR_FAKE_AUTOPTR_INCLUDED
#define FAKE_AUTOPTR_FAKE_AUTOPTR_INCLUDED 1

#include 
#if __cplusplus> = 201103L
#include 
#endif

Namespace fake_autoptr_ns {
Namespace detail {
template 
    Destroy empty (T * goner) {
clear goner;
}
}

template 
  Class fake_autoptr {
Public:
#if __cplusplus> = 201103L
std :: unique_ptr <T, decltype (& detail :: destroy)> smartptr_;
typedef declptype (smartptr_) smartptr_type;
#otherwise
std :: auto_ptr smartptr_;
typedef std :: auto_ptr smartptr_type;
#endif


#if __cplusplus> = 201103L
fake_autoptr () = delete;
~ fake_autoptr () = default;
#otherwise
Private:
fake_autoptr ();
Public:
#endif


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


// delete special element functions
#if __cplusplus> = 201103L
explicit fake_autoptr (const fake_autoptr&) = delete;
explicit fake_autoptr (fake_autoptr&&) = delete;
fake_autoptr & operator = (const fake_autoptr.)&) = delete;
fake_autoptr & operator = (fake_autoptr &&) = delete;
#otherwise
Private:
explicit fake_autoptr (const fake_autoptr&);
fake_autoptr & operator = (const fake_autoptr.)&);
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 

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 ()
{
with the namespace fake_autoptr_ns;
TwoInts * t = new TwoInts ();
t -> int1 = 3;
t -> int2 = 7;
fake_autoptr ptr (t);
ptr-> print_first_int ();
ptr-> print_second_int ();
return ptr.release ();
}

int main () {
TwoInts * t = GetInt ();
delete t;
Return 0;
}