Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C++ > smart array ptr that reliquishes ownership

Reply
Thread Tools

smart array ptr that reliquishes ownership

 
 
Nick Keighley
Guest
Posts: n/a
 
      09-19-2011
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.
 
Reply With Quote
 
 
 
 
Victor Bazarov
Guest
Posts: n/a
 
      09-19-2011
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
 
Reply With Quote
 
 
 
 
Nick Keighley
Guest
Posts: n/a
 
      09-19-2011
On Sep 19, 3:36*pm, Victor Bazarov <(E-Mail Removed)> 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();
}





 
Reply With Quote
 
Victor Bazarov
Guest
Posts: n/a
 
      09-19-2011
On 9/19/2011 11:37 AM, Nick Keighley wrote:
> On Sep 19, 3:36 pm, Victor Bazarov<(E-Mail Removed)> 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
 
Reply With Quote
 
Fulvio Esposito
Guest
Posts: n/a
 
      09-19-2011
On Monday, September 19, 2011 5:37:46 PM UTC+2, Nick Keighley wrote:
> On Sep 19, 3:36*pm, Victor Bazarov <(E-Mail Removed)> 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
 
Reply With Quote
 
Howard Hinnant
Guest
Posts: n/a
 
      09-19-2011
On Sep 19, 11:37*am, Nick Keighley <(E-Mail Removed)>
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
 
Reply With Quote
 
Goran
Guest
Posts: n/a
 
      09-20-2011
On Sep 19, 4:31*pm, Nick Keighley <(E-Mail Removed)>
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.
 
Reply With Quote
 
Nick Keighley
Guest
Posts: n/a
 
      09-20-2011
On Sep 19, 6:23 pm, Victor Bazarov <(E-Mail Removed)> wrote:
> On 9/19/2011 11:37 AM, Nick Keighley wrote:
> > On Sep 19, 3:36 pm, Victor Bazarov<(E-Mail Removed)> 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.


 
Reply With Quote
 
Nick Keighley
Guest
Posts: n/a
 
      09-20-2011
On Sep 20, 8:10*am, Goran <(E-Mail Removed)> wrote:
> On Sep 19, 4:31*pm, Nick Keighley <(E-Mail Removed)>
> 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).

 
Reply With Quote
 
Victor Bazarov
Guest
Posts: n/a
 
      09-20-2011
On 9/20/2011 3:52 AM, Nick Keighley wrote:
> On Sep 20, 8:10 am, Goran<(E-Mail Removed)> wrote:
>> On Sep 19, 4:31 pm, Nick Keighley<(E-Mail Removed)>
>> 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
 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
problem in running a basic code in python 3.3.0 that includes HTML file Satabdi Mukherjee Python 1 04-04-2013 07:48 PM
is (!ptr) or (ptr) valid way to check for NULL or NOT NULL? G Fernandes C Programming 9 02-27-2005 03:07 AM
const ptr to const ptr ? franco ziade C Programming 3 02-17-2005 04:30 AM
How to convert a double **ptr in a double const ** const ptr? Heiko Vogel C Programming 3 09-14-2004 10:23 AM
what's the difference between delete ptr and ptr=0 -dont they accomplish the same Sid C++ 5 07-29-2004 03:42 AM



Advertisments