Click here to Skip to main content
15,936,897 members
Articles / Programming Languages / C++

CAutoNativePtr - A managed smart pointer for using native objects in managed code

Rate me:
Please Sign up or sign in to vote.
4.98/5 (31 votes)
20 Jan 2006Ms-PL3 min read 76.3K   929   35   6
CAutoNativePtr is a managed template class that acts as a smart pointer, and is handy for using native objects in managed code.


CAutoNativePtr is a managed template class that acts as a smart pointer, and is handy for using native objects in managed code.

  typename T
ref class CAutoNativePtr

Here, T is the native type that's wrapped. The class manages a smart pointer, which will automatically free the native resource when it falls out of scope or the containing managed object is finalized during garbage collection. The copy constructors and assignment operators transfer ownership, which means that only one CAutoNativePtr can own a specific native object at any time (unless you write buggy code that directly overrides this rule).

Using the class

Here's some sample code that shows how the class can be used.

class Native
    void F()

class Derived : public Native{};

void SomeFunc(Native){} //Function takes a Native object
void SomeOtherFunc(Native*){} //Function takes a Native*

ref class Ref
    CAutoNativePtr<Native> m_native; //Declare the smart pointer object

    Ref(Native* pN) : m_native(pN) //Constructor that takes a T*

    //Copy constructor comes into play here
    Ref(CAutoNativePtr<Native> pN) : m_native(pN)

    //Assigning from a T*
    void Change(Native* pNew)
        m_native = pNew;

    //Assigning from another smart pointer
    void Change(CAutoNativePtr<Native> pNew)
        m_native = pNew;

    void DoStuff()
        if(!m_native) // Logical NOT applied via T* cast
            m_native->F(); //-> operator at work here
            SomeFunc(*m_native); //The T* cast at work
            SomeOtherFunc(m_native); //The T* cast at work

    bool DoComparisons(CAutoNativePtr<Native> a1, 
        CAutoNativePtr<Native> a2, CAutoNativePtr<Native> a3)
        //Operators == and != applied via T* cast
        return (a1 == a2) && (a1 != a3);		

    void Close()
        m_native.Destroy(); //Free native resource

int main()
    CAutoNativePtr<Derived> d1(new Derived); 
    CAutoNativePtr<Derived> d2(new Derived);

    //Specialized constructor for derived types is called here
    CAutoNativePtr<Native> n1(d1);

    //Specialized assignment operator for derived types is called here
    n1 = d2;

    return 0;

Class Reference


CAutoNativePtr - The constructor

There are four overloads that you can use.

  • CAutoNativePtr()
  • CAutoNativePtr(T* t)
  • CAutoNativePtr(CAutoNativePtr<T>% an)
  • template<typename TDERIVED> CAutoNativePtr(CAutoNativePtr<TDERIVED>% an)

The parameter-less constructor creates a CAutoNativePtr that wraps a nullptr object of type T. The overload that takes a T* can be used to wrap an existing pointer. Then, there are two copy constructor overloads, where one of them is to copy construct from a CAutoNativePtr<T> (same type) and the other is to copy construct from a CAutoNativePtr<TDERIVED> (which wraps a derived type of T). When you copy construct a CAutoNativePtr object, the source object's T* is detached, because only one CAutoNativePtr should own a T* at any given time, else we end up with double deletion.

~CAutoNativePtr/!CAutoNativePtr - Destructor and Finalizer

  • !CAutoNativePtr()
  • ~CAutoNativePtr()

The allocated object (if any) is freed. By having the destructor invoke the finalizer, both stack semantics and non-deterministic garbage collection are supported.

Attach - To take over an existing T*

  • void Attach(T* t)

The CAutoNativePtr will take ownership of the T*, and if there's an existing T*, it will be deleted.

Detach - Release the T*

  • T* Detach()

The underlying T* is released, and it's up to the caller to free the object now.

Destroy - Delete the underlying T*

  • void Destroy()

The underlying T* is deleted. Once you make this call, the CAutoNativePtr does not own any object any more.


operator-> - Pointer to member operator

  • static T* operator->(CAutoNativePtr<T>% an)

This returns the underlying T* object and allows the user to access T methods and fields by using the -> operator.

operator T* - Cast to T*

  • static operator T*(CAutoNativePtr<T>% an)

This is a cast to the underlying T*. This means you can pass a CAutoNativePtr object where a T* is expected, which is pretty convenient.

operator= - Assignment operator

There are three overloads for the assignment operator.

  • CAutoNativePtr<T>% operator=(T* t)
  • CAutoNativePtr<T>% operator=(CAutoNativePtr<T>% an)
  • template<typename TDERIVED> CAutoNativePtr<T>% operator=(CAutoNativePtr<TDERIVED>% an)

The first one takes a T*. If the CAutoNativePtr currently owns a T*, that's released before ownership of the new T* is taken. The other two overloads are for assignment from CAutoNativePtr objects, where one of them is specialized to handle a CAutoNativePtr object that owns a T derived object. When ownership is taken, it's transferred, which means the source objects loses ownership of the T*, and this is done to avoid double-deletion.


  • January 19th, 2006 : Article and code first published


This article, along with any associated source code and files, is licensed under The Microsoft Public License (Ms-PL)

Written By
United States United States
Nish Nishant is a technology enthusiast from Columbus, Ohio. He has over 20 years of software industry experience in various roles including Chief Technology Officer, Senior Solution Architect, Lead Software Architect, Principal Software Engineer, and Engineering/Architecture Team Leader. Nish is a 14-time recipient of the Microsoft Visual C++ MVP Award.

Nish authored C++/CLI in Action for Manning Publications in 2005, and co-authored Extending MFC Applications with the .NET Framework for Addison Wesley in 2003. In addition, he has over 140 published technology articles on and another 250+ blog articles on his WordPress blog. Nish is experienced in technology leadership, solution architecture, software architecture, cloud development (AWS and Azure), REST services, software engineering best practices, CI/CD, mentoring, and directing all stages of software development.

Nish's Technology Blog :

Comments and Discussions

QuestionCatch with delete Pin
guy_montag15-Nov-17 23:42
guy_montag15-Nov-17 23:42 
Generalmissing namespace Pin
hofingerandi13-May-11 0:13
hofingerandi13-May-11 0:13 
GeneralExport CAutoNativePtr from one C++/CLI DLL to another Pin
andyb197922-May-09 5:56
andyb197922-May-09 5:56 
GeneralRef class usage Pin
Robin Imrie22-Feb-06 6:05
professionalRobin Imrie22-Feb-06 6:05 
Newsmsclr::auto_ptr (STL-like solution) Pin
DS2-Feb-06 1:03
DS2-Feb-06 1:03 
GeneralRe: msclr::auto_ptr (STL-like solution) Pin
Nish Nishant2-Feb-06 1:42
sitebuilderNish Nishant2-Feb-06 1:42 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.