msclr::gcroot< T > Struct Template Reference

#include <msclr/gcroot.h>

Public Types
typedef System::Runtime::InteropServices::GCHandle	GCHandle

Public Member Functions
	gcroot ()
	gcroot (T t)
	gcroot (const gcroot &r)
	~gcroot ()
gcroot &	operator= (T t)
gcroot &	operator= (const gcroot &r)
void	swap (gcroot< T > &_right)
	operator T () const
T	operator-> () const

Private Member Functions
T *	operator& ()

Private Attributes
void *	_handle

Member Typedef Documentation

template<class T>

typedef System::Runtime::InteropServices::GCHandle msclr::gcroot< T >::GCHandle

Constructor & Destructor Documentation

template<class T>

msclr::gcroot< T >::gcroot ( )

inline

                 {
                _handle = __GCHANDLE_TO_VOIDPTR(GCHandle::Alloc(__NULLPTR));
        }

template<class T>

msclr::gcroot< T >::gcroot ( T  t )

inline

                    {
                _handle = __GCHANDLE_TO_VOIDPTR(GCHandle::Alloc(t));
        }

template<class T>

msclr::gcroot< T >::gcroot ( const gcroot< T > &  r )

inline

                                {
                // don't copy a handle, copy what it points to (see above)
                _handle = __GCHANDLE_TO_VOIDPTR(
                                                GCHandle::Alloc(
                                                        __VOIDPTR_TO_GCHANDLE(r._handle).Target ));
        }

template<class T>

msclr::gcroot< T >::~gcroot ( )

inline

                  {
                GCHandle g = __VOIDPTR_TO_GCHANDLE(_handle);
                g.Free();
                _handle = 0; // should fail if reconstituted
        }

Member Function Documentation

template<class T>

msclr::gcroot< T >::operator T ( ) const

inline

                            {
                // gcroot is typesafe, so use static_cast
                return static_cast<T>( __VOIDPTR_TO_GCHANDLE(_handle).Target );
        }

template<class T>

T* msclr::gcroot< T >::operator& ( )

private

template<class T>

T msclr::gcroot< T >::operator-> ( ) const

inline

                             {
                // gcroot is typesafe, so use static_cast
                return static_cast<T>(__VOIDPTR_TO_GCHANDLE(_handle).Target);
        }

template<class T>

gcroot& msclr::gcroot< T >::operator= ( T  t )

inline

                               {
                // no need to check for valid handle; was allocated in ctor
                __VOIDPTR_TO_GCHANDLE(_handle).Target = t;
                return *this;
        }

template<class T>

gcroot& msclr::gcroot< T >::operator= ( const gcroot< T > &  r )

inline

                                           {
                // no need to check for valid handle; was allocated in ctor
                T t = (T)r;
                __VOIDPTR_TO_GCHANDLE(_handle).Target = t;
                return *this;
        }

template<class T>

void msclr::gcroot< T >::swap ( gcroot< T > &  _right )

inline

        {
                using std::swap;
                swap( _handle, _right._handle );
        }

Member Data Documentation

template<class T>

void* msclr::gcroot< T >::_handle

private

---

The documentation for this struct was generated from the following file:

• VS2013/inc/msclr/gcroot.h