방법: C++/CLI에서 safe_cast 사용

아티클
10/12/2023

이 문서에서는 C++/CLI 애플리케이션에서 safe_cast 사용하는 방법을 보여 줍니다. C++/CX의 safe_cast 대한 자세한 내용은 safe_cast 참조하세요.

업캐스팅

업캐스트는 파생 형식에서 기본 클래스 중 하나로 캐스팅됩니다. 이 캐스트는 안전하며 명시적 캐스트 표기법이 필요하지 않습니다. 다음 샘플에서는 업캐스트 safe_cast 를 사용 및 사용하지 않고 수행하는 방법을 보여줍니다.

// 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

다운캐스팅

다운캐스트는 기본 클래스에서 기본 클래스에서 파생된 클래스로의 캐스트입니다. 다운캐스트는 런타임에 주소가 지정된 개체가 실제로 파생 클래스 개체의 주소를 지정하는 경우에만 안전합니다. 달리 static_cast동적 safe_cast 검사 수행하고 변환에 실패하면 throw합니다InvalidCastException.

// 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

다음 샘플에서는 사용자 정의 변환을 호출하는 데 사용할 safe_cast 수 있는 방법을 보여 줍니다.

// 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)

safe_cast 및 boxing 작업

boxing

Boxing은 컴파일러 삽입 사용자 정의 변환으로 정의됩니다. 따라서 CLR 힙에 값을 입력하는 데 사용할 safe_cast 수 있습니다.

다음 샘플에서는 단순 및 사용자 정의 값 형식의 boxing을 보여줍니다. safe_cast 가비지 수집 힙의 변수에 할당할 수 있도록 네이티브 스택에 있는 값 형식 변수를 상자로 지정합니다.

// 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);
}

다음 샘플에서는 boxing이 작업에서 사용자 정의 변환보다 우선 순위가 safe_cast 있음을 보여줍니다.

// 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은 컴파일러 삽입 사용자 정의 변환으로 정의됩니다. 따라서 CLR 힙에서 값을 언박싱하는 데 사용할 safe_cast 수 있습니다.

Unboxing은 사용자 정의 변환이지만 boxing과 달리 unboxing은 명시적이어야 합니다. 즉, C 스타일 캐스트에 safe_cast의해 static_cast수행되거나 unboxing을 암시적으로 수행할 수 없습니다.

// safe_cast_unboxing.cpp
// compile with: /clr
int main() {
   System::Object ^ o = 42;
   int x = safe_cast<int>(o);
}

다음 샘플에서는 값 형식 및 기본 형식을 사용하여 unboxing을 보여 줍니다.

// 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 및 제네릭 형식

다음 샘플에서는 제네릭 형식으로 다운캐스트를 수행하는 데 사용할 safe_cast 수 있는 방법을 보여줍니다.

// 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);
}

참고 항목

safe_cast