auto_handle, classe
Gestion automatique des ressources, qui peut être utilisée pour incorporer un handle virtuel dans un type managé.
Syntaxe
template<typename _element_type>
ref class auto_handle;
Paramètres
_element_type
Type managé à incorporer.
Membres
Constructeurs publics
Nom | Description |
---|---|
auto_handle::auto_handle | Constructeur auto_handle . |
auto_handle::~auto_handle | Destructeur auto_handle . |
Méthodes publiques
Nom | Description |
---|---|
auto_handle::get | Obtient l’objet contenu. |
auto_handle::release | Libère l’objet de auto_handle la gestion. |
auto_handle::reset | Détruisez l’objet détenu actuel et prenez éventuellement possession d’un nouvel objet. |
auto_handle::swap | Échange des objets avec un autre auto_handle . |
Opérateurs publics
Nom | Description |
---|---|
auto_handle::operator-> |
Opérateur d’accès membre. |
auto_handle::operator= | Opérateur d'assignation. |
auto_handle::operator auto_handle | Opérateur de cast de type entre auto_handle les types compatibles. |
auto_handle::operator bool | Opérateur à utiliser auto_handle dans une expression conditionnelle. |
auto_handle::operator! | Opérateur à utiliser auto_handle dans une expression conditionnelle. |
Spécifications
Fichier d’en-tête<msclr\auto_handle.h>
Espace de noms msclr
auto_handle::auto_handle
Constructeur auto_handle
.
auto_handle();
auto_handle(
_element_type ^ _ptr
);
auto_handle(
auto_handle<_element_type> % _right
);
template<typename _other_type>
auto_handle(
auto_handle<_other_type> % _right
);
Paramètres
_Ptr
Objet à posséder.
_Oui
auto_handle
existant.
Exemple
// msl_auto_handle_auto_handle.cpp
// compile with: /clr
#include "msclr\auto_handle.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 );
}
};
int main()
{
{
auto_handle<RefClassA> a(gcnew RefClassA( "first" ) );
a->PrintHello();
}
{
auto_handle<RefClassB> b(gcnew RefClassB( "second" ) );
b->PrintHello();
auto_handle<RefClassA> a(b); //construct from derived type
a->PrintHello();
auto_handle<RefClassA> a2(a); //construct from same type
a2->PrintHello();
}
Console::WriteLine("done");
}
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_handle::~auto_handle
Destructeur auto_handle
.
~auto_handle();
Notes
Le destructeur détruit également l’objet appartenant.
Exemple
// msl_auto_handle_dtor.cpp
// compile with: /clr
#include "msclr\auto_handle.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_handle<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_handle::get
Obtient l’objet contenu.
_element_type ^ get();
Valeur retournée
Objet contenu.
Exemple
// msl_auto_handle_get.cpp
// compile with: /clr
#include "msclr\auto_handle.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_handle<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_handle::release
Libère l’objet de auto_handle
la gestion.
_element_type ^ release();
Valeur retournée
Objet libéré.
Exemple
// msl_auto_handle_release.cpp
// compile with: /clr
#include <msclr\auto_handle.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_handle<ClassA> agc1 = gcnew ClassA( "first" );
auto_handle<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_handle::reset
Détruisez l’objet détenu actuel et prenez éventuellement possession d’un nouvel objet.
void reset(
_element_type ^ _new_ptr
);
void reset();
Paramètres
_new_ptr
(Facultatif) Nouvel objet.
Exemple
// msl_auto_handle_reset.cpp
// compile with: /clr
#include <msclr\auto_handle.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_handle<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_handle::swap
Échange des objets avec un autre auto_handle
.
void swap(
auto_handle<_element_type> % _right
);
Paramètres
_Oui
auto_handle
Avec lequel échanger des objets.
Exemple
// msl_auto_handle_swap.cpp
// compile with: /clr
#include <msclr\auto_handle.h>
using namespace System;
using namespace msclr;
int main() {
auto_handle<String> s1 = "string one";
auto_handle<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_handle::operator->
Opérateur d’accès membre.
_element_type ^ operator->();
Valeur retournée
Objet encapsulé par auto_handle
.
Exemple
// msl_auto_handle_op_arrow.cpp
// compile with: /clr
#include <msclr\auto_handle.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_handle<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_handle::operator=
Opérateur d'assignation.
auto_handle<_element_type> % operator=(
auto_handle<_element_type> % _right
);
template<typename _other_type>
auto_handle<_element_type> % operator=(
auto_handle<_other_type> % _right
);
Paramètres
_Oui
à auto_handle
affecter au fichier actif auto_handle
.
Valeur retournée
Le courant auto_handle
, maintenant propriétaire _right
.
Exemple
// msl_auto_handle_op_assign.cpp
// compile with: /clr
#include <msclr\auto_handle.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_handle<ClassA> a;
auto_handle<ClassA> a2(gcnew ClassA( "first" ) );
a = a2; // assign from same type
a->PrintHello();
auto_handle<ClassB> b(gcnew ClassB( "second" ) );
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
Hello from second B!
in ClassA destructor: first
Hello from second A!
done
in ClassA destructor: second
auto_handle::operator auto_handle
Opérateur de cast de type entre auto_handle
les types compatibles.
template<typename _other_type>
operator auto_handle<_other_type>();
Valeur retournée
Cast actuel auto_handle
sur auto_handle<_other_type>
.
Exemple
// msl_auto_handle_op_auto_handle.cpp
// compile with: /clr
#include <msclr\auto_handle.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_handle<ClassB> b = gcnew ClassB("first");
b->PrintHello();
auto_handle<ClassA> a = (auto_handle<ClassA>)b;
a->PrintHello();
}
Hello from first B!
Hello from first A!
auto_handle::operator bool
Opérateur à utiliser auto_handle
dans une expression conditionnelle.
operator bool();
Valeur retournée
true
si l’objet encapsulé est valide ; false
Sinon.
Notes
Cet opérateur se convertit en fait en _detail_class::_safe_bool
plus sûr que bool
parce qu’il ne peut pas être converti en type intégral.
Exemple
// msl_auto_handle_operator_bool.cpp
// compile with: /clr
#include <msclr\auto_handle.h>
using namespace System;
using namespace msclr;
int main() {
auto_handle<String> s1;
auto_handle<String> s2 = "hi";
if ( s1 ) Console::WriteLine( "s1 is valid" );
if ( !s1 ) Console::WriteLine( "s1 is invalid" );
if ( s2 ) Console::WriteLine( "s2 is valid" );
if ( !s2 ) Console::WriteLine( "s2 is invalid" );
s2.reset();
if ( s2 ) Console::WriteLine( "s2 is now valid" );
if ( !s2 ) Console::WriteLine( "s2 is now invalid" );
}
s1 is invalid
s2 is valid
s2 is now invalid
auto_handle::operator!
Opérateur à utiliser auto_handle
dans une expression conditionnelle.
bool operator!();
Valeur retournée
true
si l’objet encapsulé n’est pas valide ; false
Sinon.
Exemple
// msl_auto_handle_operator_not.cpp
// compile with: /clr
#include <msclr\auto_handle.h>
using namespace System;
using namespace msclr;
int main() {
auto_handle<String> s1;
auto_handle<String> s2 = "something";
if ( s1) Console::WriteLine( "s1 is valid" );
if ( !s1 ) Console::WriteLine( "s1 is invalid" );
if ( s2 ) Console::WriteLine( "s2 is valid" );
if ( !s2 ) Console::WriteLine( "s2 is invalid" );
s2.reset();
if ( s2 ) Console::WriteLine( "s2 is now valid" );
if ( !s2 ) Console::WriteLine( "s2 is now invalid" );
}
s1 is invalid
s2 is valid
s2 is now invalid
Commentaires
https://aka.ms/ContentUserFeedback.
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultezEnvoyer et afficher des commentaires pour