Auto ptr

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:
        using element_type = X;

        // 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>) 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();
    };

}

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:

#include <iostream>
#include <memory>

using std::auto_ptr;
 
int main(int argc, char* argv[]) {
    int* a = new int[10];
    auto_ptr<int[]> x(a);
    auto_ptr<int[]> y;
    
    y = x;
    
    std::cout << x.get() << std::endl; // Print NULL
    std::cout << y.get() << std::endl; // Print non-NULL address of a

    return 0;
}

This code will print a NULL address for the first auto_ptr object and some non-NULL 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. In fact, new int could be passed directly into x, eliminating the need for i.

Notice that the object pointed by an auto_ptr is destroyed 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 pointers to arrays (because arrays are allocated by operator new[] and must be deallocated by operator delete[]).

Because of its copy semantics, auto_ptr may not be used in STL containers that may perform element copies in their operations.

References

References

1. "auto_ptr Class". Microsoft.
2. (2014). "Effective Modern C++: 42 specific ways to improve your use of C++11 and C++14".
3. (2004-07-01). "Collecting Shared Objects". Dr. Dobb's.