smart array ptr that reliquishes ownership

[Nick Keighley]

Hi!

I'm looking for something that allows me transfer ownership away from
a smart array ptr. I basically want the semantics that auto_ptr
provided.

auto_ptr<T> myT (new T);
do_stuff_with_myT;
anotherT = myT.get();
myT.release();

I'd like a smart pointer that did the same but used new[] and delete[]
internally.

boost::shared_array doesn't seem to be what I want as it deletes the
original array when release is called.

 

[Victor Bazarov]

Hi!

I'm looking for something that allows me transfer ownership away from
a smart array ptr. I basically want the semantics that auto_ptr
provided.

auto_ptr<T> myT (new T);
do_stuff_with_myT;
anotherT = myT.get();
myT.release();

I'd like a smart pointer that did the same but used new[] and delete[]
internally.

boost::shared_array doesn't seem to be what I want as it deletes the
original array when release is called.

I think that smart pointers should transfer the ownership only if you
assign them instead of doing '.get()' followed by '.release()'...

Basically something like this:

auto_ptr<T> myT(new T):
...
anotherT = myT;

and nothing else.

V

 

[Nick Keighley]

Hi!

I'm looking for something that allows me transfer ownership away from
a smart array ptr. I basically want the semantics that auto_ptr
provided.

    auto_ptr<T>  myT (new T);
    do_stuff_with_myT;
    anotherT = myT.get();
    myT.release();

I'd like a smart pointer that did the same but used new[] and delete[]
internally.

boost::shared_array doesn't seem to be what I want as it deletes the
original array when release is called.

I think that smart pointers should transfer the ownership only if you
assign them instead of doing '.get()' followed by '.release()'...

Basically something like this:

     auto_ptr<T> myT(new T):
     ...
     anotherT = myT;

and nothing else.

I should have been clearer. I want anotherT to be an ordinary dumb
pointer (I known not a good thing to use, but it's an existign code-
base and I can't rewrite all at once).

upDatePtr (T* uP)
{
auto_ptr<T> myT(new T):
some_stuff_that_might_go_wrong;
uP = myT.get();
myT.release();
}

 

[Victor Bazarov]

Hi!

I'm looking for something that allows me transfer ownership away from
a smart array ptr. I basically want the semantics that auto_ptr
provided.

auto_ptr<T> myT (new T);
do_stuff_with_myT;
anotherT = myT.get();
myT.release();

I'd like a smart pointer that did the same but used new[] and delete[]
internally.

boost::shared_array doesn't seem to be what I want as it deletes the
original array when release is called.

I think that smart pointers should transfer the ownership only if you
assign them instead of doing '.get()' followed by '.release()'...

Basically something like this:

auto_ptr<T> myT(new T):
...
anotherT = myT;

and nothing else.

I should have been clearer. I want anotherT to be an ordinary dumb
pointer (I known not a good thing to use, but it's an existign code-
base and I can't rewrite all at once).

upDatePtr (T* uP)
{
auto_ptr<T> myT(new T):
some_stuff_that_might_go_wrong;
uP = myT.get();
myT.release();
}

Let's agree on posting real code. If you meant

void upDatePtr(T* uP)
{

(and then as written), then changing the value of 'uP' seems gratuitous
because the value is lost (memory leak) when the function returns.

Perhaps you meant

void updatePtr(T*& uP)

which means the value is retained beyond the body of the function.

In that case you need to make use of 'release's return value:

void updatePtr(T*& uP)
{
auto_ptr<T> myT(new T);
..
uP = myT.release();
}

Note that 'std::auto_ptr::release' does *not* delete the pointer.

V

 

[Fulvio Esposito]

Hi!

I'm looking for something that allows me transfer ownership away from
a smart array ptr. I basically want the semantics that auto_ptr
provided.

    auto_ptr<T>  myT (new T);
    do_stuff_with_myT;
    anotherT = myT.get();
    myT.release();

I'd like a smart pointer that did the same but used new[] and delete[]
internally.

boost::shared_array doesn't seem to be what I want as it deletes the
original array when release is called.

I think that smart pointers should transfer the ownership only if you
assign them instead of doing '.get()' followed by '.release()'...

Basically something like this:

     auto_ptr<T> myT(new T):
     ...
     anotherT = myT;

and nothing else.

I should have been clearer. I want anotherT to be an ordinary dumb
pointer (I known not a good thing to use, but it's an existign code-
base and I can't rewrite all at once).

upDatePtr (T* uP)
{
auto_ptr<T> myT(new T):
some_stuff_that_might_go_wrong;
uP = myT.get();
myT.release();
}

Maybe you can use the new C++0x std::unique_ptr< T > in replacement of the deprecated std::auto_ptr< T > that provides a specialization for T[] that calls delete[].

upDatePtr( T*& uP )
{
std::unique_ptr< T[] > myT( new T[ SIZE ] );
some_stuff_that_might_go_wrong;
uP = myT.get();
myT.release();
}

Cheers,
Fulvio Esposito

 

[Howard Hinnant]

I should have been clearer. I want anotherT to be an ordinary dumb
pointer (I known not a good thing to use, but it's an existign code-
base and I can't rewrite all at once).

upDatePtr (T* uP)
{
      auto_ptr<T> myT(new T):
      some_stuff_that_might_go_wrong;
      uP = myT.get();
      myT.release();
}

You're looking for std::unique_ptr which is new in C++11 and lives in
<memory>

upDatePtr (T*& uP)
{
      std::unique_ptr<T[]> myT(new T[3]):
      some_stuff_that_might_go_wrong;
      uP = myT.get();
      myT.release();
}

If you've got an up-to-date compiler, there's a good chance you have
unique_ptr.

Howard

 

[Goran]

Hi!

I'm looking for something that allows me transfer ownership away from
a smart array ptr. I basically want the semantics that auto_ptr
provided.

   auto_ptr<T> myT (new T);
   do_stuff_with_myT;
   anotherT = myT.get();
   myT.release();

I'd like a smart pointer that did the same but used new[] and delete[]
internally.

Erm... Not new[], that's your part of work.

boost::shared_array doesn't seem to be what I want as it deletes the
original array when release is called.

Some time ago, I copy-pasted auto_ptr into (what I called)
auto_ptr_vec, for that exact purpose, and to get that "delete[]".

Alternatively, +1 for unique_ptr (if available to you).

Goran.

 

[Nick Keighley]

I'm looking for something that allows me transfer ownership away from
a smart array ptr. I basically want the semantics that auto_ptr
provided.
auto_ptr<T> myT (new T);
do_stuff_with_myT;
anotherT = myT.get();
myT.release();
I'd like a smart pointer that did the same but used new[] and delete[]
internally.

note well. auto_ptr is *not* what I want.

Let's agree on posting real code.

fair point...

If you meant

void upDatePtr(T* uP)
{

(and then as written), then changing the value of 'uP' seems gratuitous
because the value is lost (memory leak) when the function returns.

Perhaps you meant

void updatePtr(T*& uP)

which means the value is retained beyond the body of the function.

In that case you need to make use of 'release's return value:

void updatePtr(T*& uP)
{
auto_ptr<T> myT(new T);
..
uP = myT.release();
}

Note that 'std::auto_ptr::release' does *not* delete the pointer.

but boost::shared_array does...

Ok. This is nearer the spirit of the real code (and compiles and runs
to boot)



struct T
{
int data [127];
};

struct Params
{
T* arrayOfT;
};

bool mayGoWrong ()
{
return true;
}

void allocate (Params* paramsArg)
{
T* temp = new T[10];
if (mayGoWrong ())
return; // leaks!

if (paramsArg->arrayOfT != 0)
delete[] paramsArg->arrayOfT;

paramsArg->arrayOfT = temp;
}

int main ()
{
Params params;
params.arrayOfT = 0;
allocate (&params);
return 0;
}


Yes there's lots wrong with this but it's not going to get re-written
right now.

the simple fix is to bung in a
delete[] temp;
but I was hoping there was some well-known smart pointer that could
handle this.

 

[Nick Keighley]

Hi!

I'm looking for something that allows me transfer ownership away from
a smart array ptr. I basically want the semantics that auto_ptr
provided.

   auto_ptr<T> myT (new T);
   do_stuff_with_myT;
   anotherT = myT.get();
   myT.release();

I'd like a smart pointer that did the same but used new[] and delete[]
internally.

Erm... Not new[], that's your part of work.

boost::shared_array doesn't seem to be what I want as it deletes the
original array when release is called.

Some time ago, I copy-pasted auto_ptr into (what I called)
auto_ptr_vec, for that exact purpose, and to get that "delete[]".

I didn't think what i was tryign to do was that odd...

 

[Victor Bazarov]

Hi!

I'm looking for something that allows me transfer ownership away from
a smart array ptr. I basically want the semantics that auto_ptr
provided.

auto_ptr<T> myT (new T);
do_stuff_with_myT;
anotherT = myT.get();
myT.release();

I'd like a smart pointer that did the same but used new[] and delete[]
internally.

Erm... Not new[], that's your part of work.

boost::shared_array doesn't seem to be what I want as it deletes the
original array when release is called.

Some time ago, I copy-pasted auto_ptr into (what I called)
auto_ptr_vec, for that exact purpose, and to get that "delete[]".

I didn't think what i was tryign to do was that odd...

Odd? Yes, I guess it is.

If you need an array, 'std::vector' is for you. For a single object
there are 'std::blah_ptr' templates. With 'std::vector' in place and
now with move semantics, why bother with naked pointers?

So, why you don't want to use 'std::vector' is unclear so far. Can you
elaborate on your design decision?

V

 

[Victor Bazarov]

On 9/19/2011 10:31 AM, Nick Keighley wrote:

I'm looking for something that allows me transfer ownership away from
a smart array ptr. I basically want the semantics that auto_ptr
provided.

auto_ptr<T> myT (new T);
do_stuff_with_myT;
anotherT = myT.get();
myT.release();

I'd like a smart pointer that did the same but used new[] and delete[]
internally.

note well. auto_ptr is *not* what I want.

Let's agree on posting real code.

fair point...

If you meant

void upDatePtr(T* uP)
{

(and then as written), then changing the value of 'uP' seems gratuitous
because the value is lost (memory leak) when the function returns.

Perhaps you meant

void updatePtr(T*& uP)

which means the value is retained beyond the body of the function.

In that case you need to make use of 'release's return value:

void updatePtr(T*& uP)
{
auto_ptr<T> myT(new T);
..
uP = myT.release();
}

Note that 'std::auto_ptr::release' does *not* delete the pointer.

but boost::shared_array does...

Ok. This is nearer the spirit of the real code (and compiles and runs
to boot)



struct T
{
int data [127];
};

struct Params
{
T* arrayOfT;
};

bool mayGoWrong ()
{
return true;
}

void allocate (Params* paramsArg)
{
T* temp = new T[10];
if (mayGoWrong ())
return; // leaks!

if (paramsArg->arrayOfT != 0)
delete[] paramsArg->arrayOfT;

paramsArg->arrayOfT = temp;
}

int main ()
{
Params params;
params.arrayOfT = 0;

This is all _C_. Why don't you switch to C++?

allocate (&params);
return 0;
}


Yes there's lots wrong with this but it's not going to get re-written
right now.

Too bad. If it's not now, when?

the simple fix is to bung in a
delete[] temp;
but I was hoping there was some well-known smart pointer that could
handle this.

Yes, it's called std::vector.

I can almost hear you sighing and mumbling something about the need to
use some kind of [outdated] third-party library with a C interface.
Well, there is a clean way - repackage your data *just before calling*
those functions and *never* maintain naked pointers in your own C++ code.

You _without a doubt in my mind_ need to rethink your implementation to
make it closer to what a C++ program ought to be, not keep piling on
patches of "smart" pointers onto a badly designed one. Bite the bullet,
do it today, or it's going to be too late.

V

 

[Nick Keighley]

I'm looking for something that allows me transfer ownership away from
a smart array ptr. I basically want the semantics that auto_ptr
provided.
      auto_ptr<T>     myT (new T);
      do_stuff_with_myT;
      anotherT = myT.get();
      myT.release();
I'd like a smart pointer that did the same but used new[] and delete[]
internally.

note well. auto_ptr is *not* what I want.

Ok. This is nearer the spirit of the real code (and compiles and runs
to boot)

struct T
{
     int data [127];
};

struct Params
{
     T* arrayOfT;
};

bool mayGoWrong ()
{
     return true;
}

void allocate (Params* paramsArg)
{
     T* temp = new T[10];
     if (mayGoWrong ())
         return;    // leaks!

     if (paramsArg->arrayOfT != 0)
        delete[] paramsArg->arrayOfT;

     paramsArg->arrayOfT = temp;
}

int main ()
{
     Params params;
   params.arrayOfT = 0;

This is all _C_.  Why don't you switch to C++?

hey! its got a new in it!

Too bad.  If it's not now, when?

incrementally. I was hoping to make things a little better in an
iterative fashion.

the simple fix is to bung in a
     delete[] temp;
but I was hoping there was some well-known smart pointer that could
handle this.

Yes, it's called std::vector.

I can almost hear you sighing and mumbling something about the need to
use some kind of [outdated] third-party library with a C interface.

or rather pass the result back to the rest of the application. Yes I'd
usually replace

T* temp = new T[10];

but I want a new[] object that can have ownership transferred

Well, there is a clean way - repackage your data *just before calling*
those functions and *never* maintain naked pointers in your own C++ code.

You _without a doubt in my mind_ need to rethink your implementation to
make it closer to what a C++ program ought to be, not keep piling on
patches of "smart" pointers onto a badly designed one.  Bite the bullet,
do it today, or it's going to be too late.

I'll give it some serious thought.