Auto ptr

From Wikipedia, the free encyclopedia

The title of this article should be auto_ptr. The initial letter is capitalized and an underscore is substituted or omitted because of technical restrictions.

auto_ptr is a template class available in the C++ Standard Library (declared in <memory>) that provides some basic RAII features for C++ raw pointers.

The auto_ptr template class describes an object that stores a pointer to an allocated object of type Type* that ensures that the object to which it points gets destroyed automatically when control leaves a scope.^[1]

The shared_ptr template class proposed in Technical Report 1 and available in the Boost library is preferred in most situations.^[2]

1 Declaration
2 Semantics
3 External links
4 References

[edit] Declaration

The auto_ptr class is declared in ISO/IEC 14882, section 20.4.5 as:

namespace std {

    template <class Y> struct auto_ptr_ref {};


    template<class X>
    class auto_ptr {
    public:
        typedef X element_type;

        // 20.4.5.1 construct/copy/destroy:
        explicit           auto_ptr(X* p =0) throw();
                           auto_ptr(auto_ptr&) throw();
        template<class Y>  auto_ptr(auto_ptr<Y>&) throw();

        auto_ptr&                      operator=(auto_ptr&) throw();
        template<class Y> auto_ptr&    operator=(auto_ptr<Y>&) throw();
        auto_ptr&                      operator=(auto_ptr_ref<X> r) throw();

        ~auto_ptr() throw();

        // 20.4.5.2 members:
        X&     operator*() const throw();
        X*     operator->() const throw();
        X*     get() const throw();
        X*     release() throw();
        void   reset(X* p =0) throw();

        // 20.4.5.3 conversions:
                                   auto_ptr(auto_ptr_ref<X>) throw();
        template<class Y> operator auto_ptr_ref<Y>() throw();
        template<class Y> operator auto_ptr<Y>() throw();
    };

}

[edit] Semantics

The auto_ptr has semantics of strict ownership, meaning that the auto_ptr instance is the sole entity responsible for the object's lifetime. If an auto_ptr is copied, the source loses the reference. For example:

       int *i = new int;
       auto_ptr<int> x(i);
       auto_ptr<int> y;

       y = x;

       cout << x.get() << endl;
       cout << y.get() << endl;

This code will print a NULL address for the first auto_ptr object and some address for the second, showing that the source object lost the reference during the assignment (=). The raw pointer i in the example should not be deleted, as it will be deleted by the auto_ptr that owns the reference.

Notice that the object pointed by an auto_ptr is destructed using operator delete; this means that you should only use auto_ptr for pointers obtained with operator new. This excludes pointers returned by malloc/calloc/realloc and operator new[].