Re: Better way of allocating a memory( auto_ptr vs new vs malloc)
On Dec 7, 1:32 pm, Ami <Amit.Bas...@gmail.com> wrote:
On Dec 7, 2:48 pm, James Kanze <james.ka...@gmail.com> wrote:
[...]
Thanks James and Eric for the explanation.. I have few
questions Eric you mention about passing a reference to the
auto ptr for example in the sample code , I have got now
int main ()
{
auto_ptr<T>p = (new T()) ;
func(&(p.get())); // Im passing a reference to the auto _ptr
That particular line shouldn't compile. p.get() returns a
temporary with pointer type, and the address of operator isn't
legal on temporarires. If it were legal, of course, the results
would have type T**.
(Technically---and you probably should learn the technical
vocabulary---the return value of a function is an rvalue, and
the built-in unary & operator requires an lvalue.)
p.release(); // Would free up
No. This will release ownership of the pointer from the
auto_ptr, meaning that it is up to you to delete it. One
frequent use of auto_ptr is when creating objects with arbitrary
lifetimes which will later be managed by some special type (a
transation, for example), or by the object itself (which
registers somewhere for events). In such cases, it is usual to
create the object in an auto_ptr, and then call release when the
final management method has taken over, allowing auto_ptr to
manage the object until then.
It's the destructor of auto_ptr which deletes the object, but
only if you haven't called release.
return ( EXIT_SUCESS);
}
void func(T *output)
{
output->do_Something();
}
Now if there is any exception gets thrown in the func()
what would be the behaviour of auto_ptr ??
If the exception propagates beyond the scope of the auto_ptr,
it's destructor will be called, and the object will be deleted.
Also in a function call please correct me if I am wrong I can
use * as func(*(p.get())); correct ?
If the function takes a reference, yes, but it's very
unidiomatic. What's wrong with simply *p? (Unless the function
needs to be able to take a null pointer (e.g. for an optional
argument), I'd declare it to take a reference.)
James .. My another question is
for allocating a memory to an array of structures
You mentioned about using vector like below
int main ()
{
std::vector< T > obj( n + 1 ) ;
func(obj);
return(EXIT_SUCCESS);}
void func(&obj)
{
obj->do_Something();
}
if any exception is thrown in func() .. what will the end result ?
If the exception is not caught earlier, the destructor of
std::vector<T> will be called, which will call the destructor of
all of the elements in the vector, and free up any memory the
vector uses.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34