auto_gcroot osztály

Automatikus erőforrás-kezelés (például auto_ptr osztály), amely egy virtuális leíró natív típusba való beágyazására használható.

Szintaxis

template<typename _element_type>
class auto_gcroot;

Paraméterek

_element_type
A beágyazandó felügyelt típus.

Tagok

Nyilvános konstruktorok

Név	Leírás
auto_gcroot::auto_gcroot	A `auto_gcroot` konstruktor.
auto_gcroot::~auto_gcroot	A `auto_gcroot` destruktor.

Nyilvános metódusok

Név	Leírás
auto_gcroot:: csatolása	`auto_gcroot` csatolása egy objektumhoz.
auto_gcroot::get	Lekéri a tartalmazott objektumot.
auto_gcroot::kiadási	Felszabadítja az objektumot `auto_gcroot` felügyeletből.
auto_gcroot:: visszaállítása	Megsemmisíti a jelenlegi tulajdonban lévő objektumot, és opcionálisan birtokba vesz egy új objektumot.
auto_gcroot:: felcserélése	Objektumok felcserélése másik `auto_gcroot`.

Nyilvános operátorok

Név	Leírás
`auto_gcroot::operator->`	A taghozzáférés-operátor.
auto_gcroot::operátor=	Hozzárendelés-operátor.
auto_gcroot::operátor auto_gcroot	Típus-öntött operátor `auto_gcroot` és kompatibilis típusok között.
auto_gcroot::operátori bool	Operátor a `auto_gcroot` feltételes kifejezésben való használatához.
auto_gcroot::operátor!	Operátor a `auto_gcroot` feltételes kifejezésben való használatához.

Követelmények

fejlécfájl<msclr\auto_gcroot.h>

névtér msclr

auto_gcroot::auto_gcroot

A auto_gcroot konstruktor.

auto_gcroot(
   _element_type _ptr = nullptr
);
auto_gcroot(
   auto_gcroot<_element_type> & _right
);
template<typename _other_type>
auto_gcroot(
   auto_gcroot<_other_type> & _right
);

Paraméterek

_ptr
A tulajdonban lévő objektum.

_right
Meglévő auto_gcroot.

Megjegyzések

Meglévő auto_gcrootauto_gcroot létrehozásakor a meglévő auto_gcroot az objektum tulajdonjogának az új auto_gcrootvaló átadása előtt felszabadítja az objektumot .

Példa

// msl_auto_gcroot_auto_gcroot.cpp
// compile with: /clr
#include <msclr\auto_gcroot.h>

using namespace System;
using namespace msclr;

ref class RefClassA {
protected:
   String^ m_s;
public:
   RefClassA(String^ s) : m_s(s) {
      Console::WriteLine( "in RefClassA constructor: " + m_s );
   }
   ~RefClassA() {
      Console::WriteLine( "in RefClassA destructor: " + m_s );
   }

   virtual void PrintHello() {
      Console::WriteLine( "Hello from {0} A!", m_s );
   }
};

ref class RefClassB : RefClassA {
public:
   RefClassB( String^ s ) : RefClassA( s ) {}
   virtual void PrintHello() new {
      Console::WriteLine( "Hello from {0} B!", m_s );
   }
};

class ClassA { //unmanaged class
private:
   auto_gcroot<RefClassA^> m_a;

public:
   ClassA() : m_a( gcnew RefClassA( "unmanaged" ) ) {}
   ~ClassA() {} //no need to delete m_a

   void DoSomething() {
      m_a->PrintHello();
   }
};

int main()
{
   {
      ClassA a;
      a.DoSomething();
   } // a.m_a is automatically destroyed as a goes out of scope

   {
      auto_gcroot<RefClassA^> a(gcnew RefClassA( "first" ) );
      a->PrintHello();
   }

   {
      auto_gcroot<RefClassB^> b(gcnew RefClassB( "second" ) );
      b->PrintHello();
      auto_gcroot<RefClassA^> a(b); //construct from derived type
      a->PrintHello();
      auto_gcroot<RefClassA^> a2(a); //construct from same type
      a2->PrintHello();
   }

   Console::WriteLine("done");
}

in RefClassA constructor: unmanaged
Hello from unmanaged A!
in RefClassA destructor: unmanaged
in RefClassA constructor: first
Hello from first A!
in RefClassA destructor: first
in RefClassA constructor: second
Hello from second B!
Hello from second A!
Hello from second A!
in RefClassA destructor: second
done

auto_gcroot::~auto_gcroot

A auto_gcroot destruktor.

~auto_gcroot();

Megjegyzések

A destruktor a saját objektumot is elpusztítja.

Példa

// msl_auto_gcroot_dtor.cpp
// compile with: /clr
#include <msclr\auto_gcroot.h>

using namespace System;
using namespace msclr;

ref class ClassA {
public:
   ClassA() { Console::WriteLine( "ClassA constructor" ); }
   ~ClassA() { Console::WriteLine( "ClassA destructor" ); }
};

int main()
{
   // create a new scope for a:
   {
      auto_gcroot<ClassA^> a = gcnew ClassA;
   }
   // a goes out of scope here, invoking its destructor
   // which in turns destructs the ClassA object.

   Console::WriteLine( "done" );
}

ClassA constructor
ClassA destructor
done

auto_gcroot::csatolás

auto_gcroot csatolása egy objektumhoz.

auto_gcroot<_element_type> & attach(
   _element_type _right
);
auto_gcroot<_element_type> & attach(
   auto_gcroot<_element_type> & _right
);
template<typename _other_type>
auto_gcroot<_element_type> & attach(
   auto_gcroot<_other_type> & _right
);

Paraméterek

_right
A csatolandó objektum vagy a csatolandó objektumot tartalmazó auto_gcroot.

Visszaadott érték

Az aktuális auto_gcroot.

Megjegyzések

Ha _right egy auto_gcroot, az objektum tulajdonjogát ad ki, mielőtt az objektum az aktuális auto_gcrootcsatlakozik.

Példa

// msl_auto_gcroot_attach.cpp
// compile with: /clr
#include <msclr\auto_gcroot.h>

using namespace System;
using namespace msclr;

ref class ClassA {
protected:
   String^ m_s;
public:
   ClassA( String^ s ) : m_s( s ) {
      Console::WriteLine( "in ClassA constructor:" + m_s );
   }
   ~ClassA() {
      Console::WriteLine( "in ClassA destructor:" + m_s );
   }

   virtual void PrintHello() {
      Console::WriteLine( "Hello from {0} A!", m_s );
   }
};

ref class ClassB : ClassA {
public:
   ClassB( String ^ s) : ClassA( s ) {}
   virtual void PrintHello() new {
      Console::WriteLine( "Hello from {0} B!", m_s );
   }
};

int main() {
   auto_gcroot<ClassA^> a( gcnew ClassA( "first" ) );
   a->PrintHello();
   a.attach( gcnew ClassA( "second" ) ); // attach same type
   a->PrintHello();
   ClassA^ ha = gcnew ClassA( "third" );
   a.attach( ha ); // attach raw handle
   a->PrintHello();
   auto_gcroot<ClassB^> b( gcnew ClassB("fourth") );
   b->PrintHello();
   a.attach( b ); // attach derived type
   a->PrintHello();
}

in ClassA constructor:first
Hello from first A!
in ClassA constructor:second
in ClassA destructor:first
Hello from second A!
in ClassA constructor:third
in ClassA destructor:second
Hello from third A!
in ClassA constructor:fourth
Hello from fourth B!
in ClassA destructor:third
Hello from fourth A!
in ClassA destructor:fourth

auto_gcroot::get

Lekéri a tartalmazott objektumot.

_element_type get() const;

Visszaadott érték

A tartalmazott objektum.

Példa

// msl_auto_gcroot_get.cpp
// compile with: /clr
#include <msclr\auto_gcroot.h>

using namespace System;
using namespace msclr;

ref class ClassA {
   String^ m_s;
public:
   ClassA( String^ s ) : m_s( s ){
      Console::WriteLine( "in ClassA constructor:" + m_s );
   }
   ~ClassA() {
      Console::WriteLine( "in ClassA destructor:" + m_s );
   }

   void PrintHello() {
      Console::WriteLine( "Hello from {0} A!", m_s );
   }
};

void PrintA( ClassA^ a ) {
   a->PrintHello();
}

int main() {
   auto_gcroot<ClassA^> a = gcnew ClassA( "first" );
   a->PrintHello();

   ClassA^ a2 = a.get();
   a2->PrintHello();

   PrintA( a.get() );
}

in ClassA constructor:first
Hello from first A!
Hello from first A!
Hello from first A!
in ClassA destructor:first

auto_gcroot::release

Felszabadítja az objektumot auto_gcroot felügyeletből.

_element_type release();

Visszaadott érték

A kibocsátott objektum.

Példa

// msl_auto_gcroot_release.cpp
// compile with: /clr
#include <msclr\auto_gcroot.h>

using namespace System;
using namespace msclr;

ref class ClassA {
   String^ m_s;
public:
   ClassA( String^ s ) : m_s( s ) {
      Console::WriteLine( "ClassA constructor: " + m_s );
   }
   ~ClassA() {
      Console::WriteLine( "ClassA destructor: " + m_s );
   }

   void PrintHello() {
      Console::WriteLine( "Hello from {0} A!", m_s );
   }
};

int main()
{
   ClassA^ a;

   // create a new scope:
   {
      auto_gcroot<ClassA^> agc1 = gcnew ClassA( "first" );
      auto_gcroot<ClassA^> agc2 = gcnew ClassA( "second" );
      a = agc1.release();
   }
   // agc1 and agc2 go out of scope here

   a->PrintHello();

   Console::WriteLine( "done" );
}

ClassA constructor: first
ClassA constructor: second
ClassA destructor: second
Hello from first A!
done

auto_gcroot::reset

Megsemmisíti a jelenlegi tulajdonban lévő objektumot, és opcionálisan birtokba vesz egy új objektumot.

void reset(
   _element_type _new_ptr = nullptr
);

Paraméterek

_new_ptr
(Nem kötelező) Az új objektum.

Példa

// msl_auto_gcroot_reset.cpp
// compile with: /clr
#include <msclr\auto_gcroot.h>

using namespace System;
using namespace msclr;

ref class ClassA {
   String^ m_s;
public:
   ClassA( String^ s ) : m_s( s ) {
      Console::WriteLine( "ClassA constructor: " + m_s );
   }
   ~ClassA() {
      Console::WriteLine( "ClassA destructor: " + m_s );
   }

   void PrintHello() {
      Console::WriteLine( "Hello from {0} A!", m_s );
   }
};

int main()
{
   auto_gcroot<ClassA^> agc1 = gcnew ClassA( "first" );
   agc1->PrintHello();

   ClassA^ ha = gcnew ClassA( "second" );
   agc1.reset( ha ); // release first object, reference second
   agc1->PrintHello();

   agc1.reset(); // release second object, set to nullptr

   Console::WriteLine( "done" );
}

ClassA constructor: first
Hello from first A!
ClassA constructor: second
ClassA destructor: first
Hello from second A!
ClassA destructor: second
done

auto_gcroot::swap

Objektumok felcserélése másik auto_gcroot.

void swap(
   auto_gcroot<_element_type> & _right
);

Paraméterek

_right
Az objektumok felcserélésére szolgáló auto_gcroot.

Példa

// msl_auto_gcroot_swap.cpp
// compile with: /clr
#include <msclr\auto_gcroot.h>

using namespace System;
using namespace msclr;

int main() {
   auto_gcroot<String^> s1 = "string one";
   auto_gcroot<String^> s2 = "string two";

   Console::WriteLine( "s1 = '{0}', s2 = '{1}'",
      s1->ToString(), s2->ToString() );
   s1.swap( s2 );
   Console::WriteLine( "s1 = '{0}', s2 = '{1}'",
      s1->ToString(), s2->ToString() );
}

s1 = 'string one', s2 = 'string two'
s1 = 'string two', s2 = 'string one'

`auto_gcroot::operator->`

A taghozzáférés-operátor.

_element_type operator->() const;

Visszaadott érték

A auto_gcrootáltal becsomagolt objektum.

Példa

// msl_auto_gcroot_op_arrow.cpp
// compile with: /clr
#include <msclr\auto_gcroot.h>

using namespace System;
using namespace msclr;

ref class ClassA {
protected:
   String^ m_s;
public:
   ClassA( String^ s ) : m_s( s ) {}

   virtual void PrintHello() {
      Console::WriteLine( "Hello from {0} A!", m_s );
   }

   int m_i;
};

int main() {
   auto_gcroot<ClassA^> a( gcnew ClassA( "first" ) );
   a->PrintHello();

   a->m_i = 5;
   Console::WriteLine( "a->m_i = {0}", a->m_i );
}

Hello from first A!
a->m_i = 5

auto_gcroot::operátor=

Hozzárendelés-operátor.

auto_gcroot<_element_type> & operator=(
   _element_type _right
);
auto_gcroot<_element_type> & operator=(
   auto_gcroot<_element_type> & _right
);
template<typename _other_type>
auto_gcroot<_element_type> & operator=(
   auto_gcroot<_other_type> & _right
);

Paraméterek

_right
Az aktuális auto_gcroothozzárendelendő objektum vagy auto_gcroot.

Visszaadott érték

A jelenlegi auto_gcroot, amely most _righttulajdonosa .

Példa

// msl_auto_gcroot_operator_equals.cpp
// compile with: /clr
#include <msclr\auto_gcroot.h>

using namespace System;
using namespace msclr;

ref class ClassA {
protected:
   String^ m_s;
public:
   ClassA(String^ s) : m_s(s) {
      Console::WriteLine( "in ClassA constructor: " + m_s );
   }
   ~ClassA() {
      Console::WriteLine( "in ClassA destructor: " + m_s );
   }

   virtual void PrintHello() {
      Console::WriteLine( "Hello from {0} A!", m_s );
   }
};

ref class ClassB : ClassA {
public:
   ClassB( String^ s ) : ClassA( s ) {}
   virtual void PrintHello() new {
      Console::WriteLine( "Hello from {0} B!", m_s );
   }
};

int main()
{
   auto_gcroot<ClassA^> a;
   auto_gcroot<ClassA^> a2(gcnew ClassA( "first" ) );
   a = a2; // assign from same type
   a->PrintHello();

   ClassA^ ha = gcnew ClassA( "second" );
   a = ha; // assign from raw handle

   auto_gcroot<ClassB^> b(gcnew ClassB( "third" ) );
   b->PrintHello();
   a = b; // assign from derived type
   a->PrintHello();

   Console::WriteLine("done");
}

in ClassA constructor: first
Hello from first A!
in ClassA constructor: second
in ClassA destructor: first
in ClassA constructor: third
Hello from third B!
in ClassA destructor: second
Hello from third A!
done
in ClassA destructor: third

auto_gcroot::operátor auto_gcroot

Típus-öntött operátor auto_gcroot és kompatibilis típusok között.

template<typename _other_type>
operator auto_gcroot<_other_type>();

Visszaadott érték

Az aktuális auto_gcrootauto_gcroot<_other_type>.

Példa

// msl_auto_gcroot_op_auto_gcroot.cpp
// compile with: /clr
#include <msclr\auto_gcroot.h>

using namespace System;
using namespace msclr;

ref class ClassA {
protected:
   String^ m_s;
public:
   ClassA( String^ s ) : m_s( s ) {}

   virtual void PrintHello() {
      Console::WriteLine( "Hello from {0} A!", m_s );
   }
};

ref class ClassB : ClassA {
public:
   ClassB( String ^ s) : ClassA( s ) {}
   virtual void PrintHello() new {
      Console::WriteLine( "Hello from {0} B!", m_s );
   }
};

int main() {
   auto_gcroot<ClassB^> b = gcnew ClassB("first");
   b->PrintHello();
   auto_gcroot<ClassA^> a = (auto_gcroot<ClassA^>)b;
   a->PrintHello();
}

Hello from first B!
Hello from first A!

auto_gcroot::operátor bool

Operátor a auto_gcroot feltételes kifejezésben való használatához.

operator bool() const;

Visszaadott érték

true, hogy a becsomagolt objektum érvényes-e; máskülönben false.

Megjegyzések

Ez az operátor valójában _detail_class::_safe_boollesz, ami biztonságosabb, mint bool, mert nem konvertálható integrált típussá.

Példa

// msl_auto_gcroot_operator_bool.cpp
// compile with: /clr
#include <msclr\auto_gcroot.h>

using namespace System;
using namespace msclr;

int main() {
   auto_gcroot<String^> s;
   if ( s ) Console::WriteLine( "s is valid" );
   if ( !s ) Console::WriteLine( "s is invalid" );
   s = "something";
   if ( s ) Console::WriteLine( "now s is valid" );
   if ( !s ) Console::WriteLine( "now s is invalid" );
   s.reset();
   if ( s ) Console::WriteLine( "now s is valid" );
   if ( !s ) Console::WriteLine( "now s is invalid" );
}

s is invalid
now s is valid
now s is invalid

auto_gcroot::operátor!

Operátor a auto_gcroot feltételes kifejezésben való használatához.

bool operator!() const;

Visszaadott érték

true, ha a burkolt objektum érvénytelen; máskülönben false.

Példa

// msl_auto_gcroot_operator_not.cpp
// compile with: /clr
#include <msclr\auto_gcroot.h>

using namespace System;
using namespace msclr;

int main() {
   auto_gcroot<String^> s;
   if ( s ) Console::WriteLine( "s is valid" );
   if ( !s ) Console::WriteLine( "s is invalid" );
   s = "something";
   if ( s ) Console::WriteLine( "now s is valid" );
   if ( !s ) Console::WriteLine( "now s is invalid" );
   s.reset();
   if ( s ) Console::WriteLine( "now s is valid" );
   if ( !s ) Console::WriteLine( "now s is invalid" );
}

s is invalid
now s is valid
now s is invalid

Visszacsatolás

Hasznos volt ez az oldal?

Last updated on 2025-11-07

Megosztás:

auto_gcroot osztály

Szintaxis

Paraméterek

Tagok

Nyilvános konstruktorok

Nyilvános metódusok

Nyilvános operátorok

Követelmények

auto_gcroot::auto_gcroot

Paraméterek

Megjegyzések

Példa

auto_gcroot::~auto_gcroot

Megjegyzések

Példa

auto_gcroot::csatolás

Paraméterek

Visszaadott érték

Megjegyzések

Példa

auto_gcroot::get

Visszaadott érték

Példa

auto_gcroot::release

Visszaadott érték

Példa

auto_gcroot::reset

Paraméterek

Példa

auto_gcroot::swap

Paraméterek

Példa

auto_gcroot::operator->

Visszaadott érték

Példa

auto_gcroot::operátor=

Paraméterek

Visszaadott érték

Példa

auto_gcroot::operátor auto_gcroot

Visszaadott érték

Példa

auto_gcroot::operátor bool

Visszaadott érték

Megjegyzések

Példa

auto_gcroot::operátor!

Visszaadott érték

Példa

Visszacsatolás

További források

`auto_gcroot::operator->`