smart array ptr that reliquishes ownership
 

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.

Re: smart array ptr that reliquishes ownership
 

On 9/19/2011 10:31 AM, Nick Keighley wrote:
> 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
--
I do not respond to top-posted replies, please don't ask

Re: smart array ptr that reliquishes ownership
 

On Sep 19, 3:36*pm, Victor Bazarov <v.baza...@comcast.invalid> wrote:
> On 9/19/2011 10:31 AM, Nick Keighley wrote:
>
>
>
>
>
> > 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();
}

Re: smart array ptr that reliquishes ownership
 

On 9/19/2011 11:37 AM, Nick Keighley wrote:
> On Sep 19, 3:36 pm, Victor Bazarov<v.baza...@comcast.invalid> wrote:
>> On 9/19/2011 10:31 AM, Nick Keighley wrote:
>>
>>
>>
>>
>>
>>> 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
--
I do not respond to top-posted replies, please don't ask

Re: smart array ptr that reliquishes ownership
 

On Monday, September 19, 2011 5:37:46 PM UTC+2, Nick Keighley wrote:
> On Sep 19, 3:36*pm, Victor Bazarov <v.baza...@comcast.invalid> wrote:
> > On 9/19/2011 10:31 AM, Nick Keighley wrote:
> >
> >
> >
> >
> >
> > > 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

Re: smart array ptr that reliquishes ownership
 

On Sep 19, 11:37*am, Nick Keighley <nick_keighley_nos...@hotmail.com>
wrote:

> 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

Re: smart array ptr that reliquishes ownership
 

On Sep 19, 4:31*pm, Nick Keighley <nick_keighley_nos...@hotmail.com>
wrote:
> 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.

Re: smart array ptr that reliquishes ownership
 

On Sep 19, 6:23 pm, Victor Bazarov <v.baza...@comcast.invalid> wrote:
> On 9/19/2011 11:37 AM, Nick Keighley wrote:
> > On Sep 19, 3:36 pm, Victor Bazarov<v.baza...@comcast.invalid> wrote:
> >> 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.


> >>> 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.

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.

Re: smart array ptr that reliquishes ownership
 

On Sep 20, 8:10*am, Goran <goran.pu...@gmail.com> wrote:
> On Sep 19, 4:31*pm, Nick Keighley <nick_keighley_nos...@hotmail.com>
> wrote:
>
> > 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...

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

Re: smart array ptr that reliquishes ownership
 

On 9/20/2011 3:52 AM, Nick Keighley wrote:
> On Sep 20, 8:10 am, Goran<goran.pu...@gmail.com> wrote:
>> On Sep 19, 4:31 pm, Nick Keighley<nick_keighley_nos...@hotmail.com>
>> wrote:
>>
>>> 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?

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

V
--
I do not respond to top-posted replies, please don't ask