Procédure : Utiliser safe_cast dans C++/CLI
Cet article explique comment utiliser safe_cast dans les applications C++/CLI. Pour plus d’informations sur safe_cast en C++/CX, consultez safe_cast.
Upcast
Une mise en service est un cast d’un type dérivé vers l’une de ses classes de base. Ce cast est sûr et ne nécessite pas de notation de cast explicite. L’exemple suivant montre comment effectuer une mise en service, avec safe_cast et sans elle.
// safe_upcast.cpp
// compile with: /clr
using namespace System;
interface class A {
void Test();
};
ref struct B : public A {
virtual void Test() {
Console::WriteLine("in B::Test");
}
void Test2() {
Console::WriteLine("in B::Test2");
}
};
ref struct C : public B {
virtual void Test() override {
Console::WriteLine("in C::Test");
};
};
int main() {
C ^ c = gcnew C;
// implicit upcast
B ^ b = c;
b->Test();
b->Test2();
// upcast with safe_cast
b = nullptr;
b = safe_cast<B^>(c);
b->Test();
b->Test2();
}
in C::Test
in B::Test2
in C::Test
in B::Test2
Downcast
Une panne est un cast d’une classe de base vers une classe dérivée de la classe de base. Une downcast est sécurisée uniquement si l’objet traité au moment de l’exécution traite réellement un objet de classe dérivé. Contrairement static_castà , safe_cast effectue une case activée dynamique et lève InvalidCastException si la conversion échoue.
// safe_downcast.cpp
// compile with: /clr
using namespace System;
interface class A { void Test(); };
ref struct B : public A {
virtual void Test() {
Console::WriteLine("in B::Test()");
}
void Test2() {
Console::WriteLine("in B::Test2()");
}
};
ref struct C : public B {
virtual void Test() override {
Console::WriteLine("in C::Test()");
}
};
interface class I {};
value struct V : public I {};
int main() {
A^ a = gcnew C();
a->Test();
B^ b = safe_cast<B^>(a);
b->Test();
b->Test2();
V v;
I^ i = v; // i boxes V
V^ refv = safe_cast<V^>(i);
Object^ o = gcnew B;
A^ a2= safe_cast<A^>(o);
}
in C::Test()
in C::Test()
in B::Test2()
safe_cast avec des conversions définies par l’utilisateur
L’exemple suivant montre comment appeler safe_cast des conversions définies par l’utilisateur.
// safe_cast_udc.cpp
// compile with: /clr
using namespace System;
value struct V;
ref struct R {
int x;
R() {
x = 1;
}
R(int argx) {
x = argx;
}
static operator R::V^(R^ r);
};
value struct V {
int x;
static operator R^(V& v) {
Console::WriteLine("in operator R^(V& v)");
R^ r = gcnew R();
r->x = v.x;
return r;
}
V(int argx) {
x = argx;
}
};
R::operator V^(R^ r) {
Console::WriteLine("in operator V^(R^ r)");
return gcnew V(r->x);
}
int main() {
bool fReturnVal = false;
V v(2);
R^ r = safe_cast<R^>(v); // should invoke UDC
V^ v2 = safe_cast<V^>(r); // should invoke UDC
}
in operator R^(V& v
in operator V^(R^ r)
opérations de safe_cast et de boxe
Boxing
Boxing est défini comme une conversion injectée par le compilateur et définie par l’utilisateur. Par conséquent, vous pouvez utiliser pour boxer safe_cast une valeur sur le tas CLR.
L’exemple suivant montre la boxe avec des types valeur simples et définis par l’utilisateur. Une safe_cast zone une variable de type valeur qui se trouve sur la pile native afin qu’elle puisse être affectée à une variable sur le tas collecté par le garbage.
// safe_cast_boxing.cpp
// compile with: /clr
using namespace System;
interface struct I {};
value struct V : public I {
int m_x;
V(int i) : m_x(i) {}
};
int main() {
// box a value type
V v(100);
I^ i = safe_cast<I^>(v);
int x = 100;
V^ refv = safe_cast<V^>(v);
int^ refi = safe_cast<int^>(x);
}
L’exemple suivant montre que la boxe a la priorité sur une conversion définie par l’utilisateur dans une safe_cast opération.
// safe_cast_boxing_2.cpp
// compile with: /clr
static bool fRetval = true;
interface struct I {};
value struct V : public I {
int x;
V(int argx) {
x = argx;
}
static operator I^(V v) {
fRetval = false;
I^ pi = v;
return pi;
}
};
ref struct R {
R() {}
R(V^ pv) {}
};
int main() {
V v(10);
I^ pv = safe_cast<I^>(v); // boxing will occur, not UDC "operator I^"
}
Unboxing
Unboxing est défini comme une conversion injectée par le compilateur et définie par l’utilisateur. Par conséquent, vous pouvez utiliser safe_cast pour dissocier une valeur sur le tas CLR.
Unboxing est une conversion définie par l’utilisateur, mais contrairement à la boxe, unboxing doit être explicite, c’est-à-dire qu’il doit être effectué par un static_castcast de style C ou safe_cast; unboxing ne peut pas être effectué implicitement.
// safe_cast_unboxing.cpp
// compile with: /clr
int main() {
System::Object ^ o = 42;
int x = safe_cast<int>(o);
}
L’exemple suivant montre unboxing avec des types valeur et des types primitifs.
// safe_cast_unboxing_2.cpp
// compile with: /clr
using namespace System;
interface struct I {};
value struct VI : public I {};
void test1() {
Object^ o = 5;
int x = safe_cast<Int32>(o);
}
value struct V {
int x;
String^ s;
};
void test2() {
V localv;
Object^ o = localv;
V unboxv = safe_cast<V>(o);
}
void test3() {
V localv;
V^ o2 = localv;
V unboxv2 = safe_cast<V>(o2);
}
void test4() {
I^ refi = VI();
VI vi = safe_cast<VI>(refi);
}
int main() {
test1();
test2();
test3();
test4();
}
safe_cast et types génériques
L’exemple suivant montre comment effectuer safe_cast une mise en panne avec un type générique.
// safe_cast_generic_types.cpp
// compile with: /clr
interface struct I {};
generic<class T> where T:I
ref struct Base {
T t;
void test1() {}
};
generic<class T> where T:I
ref struct Derived:public Base <T> {};
ref struct R:public I {};
typedef Base<R^> GBase_R;
typedef Derived<R^> GDerived_R;
int main() {
GBase_R^ br = gcnew GDerived_R();
GDerived_R^ dr = safe_cast<GDerived_R^>(br);
}
Voir aussi
Commentaires
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, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour