R>int main()
R>{
R>    auto_ptr();
R>0040109A  call        auto_ptr (401060h) 
R>    by_hand();
R>0040109F  call        auto_ptr (401060h) 
R>}
R>004010A4  xor         eax,eax 
R>004010A6  ret

R>Он даже не стал генерировать разных функций

__declspec(noinline) void auto_ptr()
{
    std::auto_ptr<int> i /*(new int(5))*/;
}
>__declspec(noinline) void by_hand()
{
    int* i /*= new int(5)*/;
    //delete i;
}

int main()
{
    auto_ptr();
    by_hand();
}

; Function compile flags: /Ogspy

?by_hand@@YAXXZ PROC                    ; by_hand
    ret 0
?by_hand@@YAXXZ ENDP                    ; by_hand

?auto_ptr@@YAXXZ PROC                   ; auto_ptr
    push    0
    call    ??3@YAXPAX@Z                ; operator delete
    pop ecx
    ret 0
?auto_ptr@@YAXXZ ENDP                   ; auto_ptr

_main   PROC
    call    ?auto_ptr@@YAXXZ            ; auto_ptr
    xor eax, eax
    ret 0
_main   ENDP

__declspec(noinline) void auto_ptr()
{
    std::auto_ptr<int> i;
    int* i2 = new int(5);
    i.reset(i2);
}

__declspec(noinline) void by_hand()
{
    int* i;
    int* i2 = new int(5);
    i = i2;
    delete i;
}

int main()
{
    auto_ptr();
    by_hand();
}

; Function compile flags: /Ogspy

?by_hand@@YAXXZ PROC                    ; by_hand
    push    4
    call    ??2@YAPAXI@Z                ; operator new
    test    eax, eax
    pop ecx
    je  SHORT $LN3@by_hand
    mov DWORD PTR [eax], 5
    jmp SHORT $LN4@by_hand
$LN3@by_hand:
    xor eax, eax
$LN4@by_hand:
    push    eax
    call    ??3@YAXPAX@Z                ; operator delete
    pop ecx
    ret 0
?by_hand@@YAXXZ ENDP                    ; by_hand

?auto_ptr@@YAXXZ PROC                   ; auto_ptr
    push    esi
    push    4
    call    ??2@YAPAXI@Z                ; operator new
    test    eax, eax
    pop ecx
    je  SHORT $LN3@auto_ptr
    mov DWORD PTR [eax], 5
    mov esi, eax
    jmp SHORT $LN4@auto_ptr
$LN3@auto_ptr:
    xor esi, esi
$LN4@auto_ptr:
    test    esi, esi
    je  SHORT $LN7@auto_ptr
    push    0
    call    ??3@YAXPAX@Z                ; operator delete
    pop ecx
$LN7@auto_ptr:
    push    esi
    call    ??3@YAXPAX@Z                ; operator delete
    pop ecx
    pop esi
    ret 0
?auto_ptr@@YAXXZ ENDP                   ; auto_ptr

; Function compile flags: /Ogspy
?auto_ptr@@YGXXZ PROC                  ; auto_ptr, COMDAT
    ret 0
?auto_ptr2@@YGXXZ ENDP                  ; auto_ptr

; Function compile flags: /Ogspy
;   COMDAT ?by_hand@@YGXXZ
_TEXT   SEGMENT
?by_hand@@YGXXZ PROC                    ; by_hand, COMDAT
; заинлайнен new:
    push    esi
    mov esi, 1280593503             ; 4c544e5fH
    push    esi
    push    4
    push    1
    call    DWORD PTR __imp__ExAllocatePoolWithTag@12
    test    eax, eax
    je  SHORT $LN3@by_hand
    mov DWORD PTR [eax], 5
    jmp SHORT $LN4@by_hand
$LN3@by_hand:
    xor eax, eax
$LN4@by_hand:
    test    eax, eax
    je  SHORT $LN12@by_hand
; заинлайнен delete
    push    esi
    push    eax
    call    DWORD PTR __imp__ExFreePoolWithTag@8
$LN12@by_hand:
    pop esi
    ret 0
?by_hand@@YGXXZ ENDP                    ; by_hand

?auto_ptr@@YGXXZ PROC                  ; auto_ptr, COMDAT
; заинлайнен new:
    push    esi
    mov esi, 1280593503             ; 4c544e5fH
    push    esi
    push    4
    push    1
    call    DWORD PTR __imp__ExAllocatePoolWithTag@12
    test    eax, eax
    je  SHORT $LN3@auto_ptr
    mov DWORD PTR [eax], 5
    jmp SHORT $LN23@auto_ptr
$LN3@auto_ptr:
    xor eax, eax
$LN23@auto_ptr:
    test    eax, eax
    je  SHORT $LN37@auto_ptr
; заинлайнен delete
    push    esi
    push    eax
    call    DWORD PTR __imp__ExFreePoolWithTag@8
$LN37@auto_ptr:
    pop esi
    ret 0
?auto_ptr@@YGXXZ ENDP                  ; auto_ptr

template<class Y> struct auto_ptr_ref;

/// Class template auto_ptr [20.4.5 lib.auto.ptr]
template<class X>
class auto_ptr
{
  ///////////////////////////////////////////////////////////////////////////
  public:

    typedef X element_type;

    ///\name  construct/copy/destroy [20.4.5.1]

    explicit auto_ptr(X * p = 0)  throw() : ptr(p) {}

    auto_ptr(auto_ptr & a)        throw() : ptr(a.release()) {}

    template<class Y>
    auto_ptr(auto_ptr<Y> & a)     throw() : ptr(a.release()) {}

    __forceinline
    auto_ptr & operator=(auto_ptr & a) throw()
    {
      reset(a.release());
      return *this;
    }

    template<class Y>
    auto_ptr & operator=(auto_ptr<Y> & a) throw()
    {
      reset(a.release());
      return *this;
    }

    __forceinline
    ~auto_ptr() throw() { if ( get() ) delete get(); }

    ///\name  members [20.4.5.2]

    X & operator* ()  const throw() { return *get(); }
    X * operator->()  const throw() { return get(); }
    X * get()         const throw() { return ptr; }
    X * release()           throw() { X * tmp = get(); set(0); return tmp; }

    __forceinline
    void reset(X * p = 0)   throw()
    { 
      if ( get() && get() != p ) delete get();
      set(p);
    }

    ///\name  conversions [20.4.5.3]

    auto_ptr(auto_ptr_ref<X> r) throw() : ptr(r.ptr.release()) {}

    __forceinline
    auto_ptr & operator=(auto_ptr_ref<X> r) throw() { return *this = r.ptr; }

    template<class Y>
    operator auto_ptr_ref<Y>()  throw() { return auto_ptr_ref<Y>(*this); }

    template<class Y>
    operator auto_ptr<Y>()      throw() { return auto_ptr<Y>(release()); }

    ///@}

  ///////////////////////////////////////////////////////////////////////////
  private:
  
    X * ptr;
    void set(X * p) { ptr = p; }
};

template<class Y>
struct auto_ptr_ref
{
    auto_ptr_ref(auto_ptr<Y> & a) throw() : ptr(a) {}
    auto_ptr<Y> & ptr;
  private:
    auto_ptr_ref<Y> & operator=(const auto_ptr_ref<Y> &);
};

"Вы поставили знак минус вместо знака плюс"