Thread: Use of auto_ptr? I can't find one.

Hello,

i read a bit about stl::auto_ptr. Most tutorials show the big advantages refering to exception safety and avoiding memory leaks on an example like this:

Code:

void foo()
{
  T* t = new T();
  // exception
  delete t;
}

So here someone allocate heap in a function foo and deallocate it before t is going out of scope and the memory is lost.
The better way should be:

Code:

void foo()
{
  auto_ptr<T*> t( new T() );
  // exception
  // t is auto freed while going out of scope
}

My question what hold my awake this night is:
Why should someone declare a pointer T* and allocate heap, if he just delete it at the and of the same scope? The sens, for my understanding, of declaring a pointer and allocating heap is to append the live of a fraction of memory beyond the actual scope?!
So nobody would use the about example but just write:

Code:

void foo()
{
  T t();
  // exception
  // t is auto freed while going out of scope
}

or, if t should be available outside the scope of foo:

Code:

T* foo()
{
  T* t = new T();
  return t;
}

What did I get wrong, where is the reasonable sens of auto_ptr?
Thanks in advance.

Originally Posted by pheres

Why should someone declare a pointer T* and allocate heap, if he just delete it at the and of the same scope? The sens, for my understanding, of declaring a pointer and allocating heap is to append the live of a fraction of memory beyond the actual scope?!

What if the object would be a really big one ? Say holding some 5 mb of Bitmap data. No chance to allocate that on the stack.
Kurt

Originally Posted by pheres

Code:

void foo()
{
  auto_ptr<T*> t( new T() );
  // exception
  // t is auto freed while going out of scope
}

Mario seems to have answered your question quite well. I'll just point out a minor error in the example quoted here. The variable t should be of type auto_ptr<T>, not of type auto_ptr<T*>.

ok thank you all. one question remains:

Originally Posted by Mario F.

No, because at the end of the scope in which it was declared, it will be destroyed. With or without delete. That is the same of every other variable.

fractions of memory allocated on the heap get destroyed?
why does something like this work then?

Code:

string* foo()
{
  return( new string("hello") );
}
int main()
{
  cout << *foo(); // prints "hello"
}

Originally Posted by vart

and also leaves a memory leak

uhm ok, but

Code:

string* foo()
{
  return( new string("hello") );
}
int main()
{
  string* s = foo();
  cout << *s; // prints "hello"
  delete s;
}

should do better i guess.

@mario:
oh I didn't thought on the physical bits in pc memory, more on the "allocated by the OS"-thing of memory which lives beyond the scope of all pointers pointing to it till one delete it. if that couldn't work there would also be no mem-leaks i think.

Originally Posted by Mario F.

But I'm sure we understand each other.

I hope so, but I'm still not as familiar with c++ memory management as I wish, so I better ask twice

ok that finally cleared things up (for today :-) ) thank you mario.