Re: smart array ptr that reliquishes ownership
On 9/20/2011 3:52 AM, Nick Keighley wrote:
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;
This is all _C_. Why don't you switch to C++?
allocate (¶ms);
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