The auto_ptr class supports normal pointer operations like =, *, and ->, as well as two functions TYPE* get() and TYPE* release(). The get() function returns a pointer to the object that the auto_ptr points to. The release() function acts similarily to the get() function, but also relieves the auto_ptr of its memory destruction duties.
What happened when you copy an auto_ptr?
An auto_ptr owns the object that it holds a pointer to, and only one auto_ptr may own an object at a time. When you copy an auto_ptr, you automatically transfer ownership from the source auto_ptr to the target auto_ptr; if the target auto_ptr already owns an object, that object is first freed. After the copy, only the target auto_ptr owns the pointer and will delete it in due time, while the source is set back to a null state and can no longer be used to refer to the owned object.
Example:
Things without using auto_ptr:
class MyClass {
public:
MyClass() {}
~MyClass() {}
void myFunc() {}
};
void function() {
MyClass* ptr = new MyClass();
// do some operation
.........
.........
delete ptr;
}
Now consider that you are performing big operation (more than 10 lines of code) and got some exception in between. So delete will never get called and will result a memory leak.
Yes, you can use try-catch and inside catch block you can delete the pointer. But most of the cases we forgot to take care of all these things. auto_ptr will solve this as it will take care of releasing the memory.
#include
using namespace std;
class MyClass {
public:
MyClass() {}
~MyClass() {}
void myFunc() {}
};
int main() {
auto_ptr
ptr2 = ptr1;// now ptr2 owns the pointer,ptr1 does not
ptr2->myFunc();
MyClass* ptr = ptr2.get(); //returns a pointer to the objects it points to
ptr->myFunc();
return 0;
}// as we go out of scope, ptr2's destructor deletes the pointer, but ptr1's does nothing
Problem with auto_ptr:
It is never safe to put auto_ptrs into standard containers, because copies of auto_ptrs are not equivalent.
