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

 
 
Victor Bazarov
Guest
Posts: n/a
 
      09-20-2011
On 9/20/2011 3:52 AM, Nick Keighley wrote:
> 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;


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
--
I do not respond to top-posted replies, please don't ask
 
Reply With Quote
 
 
 
 
Nick Keighley
Guest
Posts: n/a
 
      09-20-2011
On Sep 20, 1:20*pm, Victor Bazarov <(E-Mail Removed)> wrote:
> On 9/20/2011 3:52 AM, Nick Keighley wrote:
> > 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.


<snip>

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

> > * * *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?


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