Boxing (C++/CLI und C++/CX)

  • Artikel

Die Konvertierung von Werttypen in Objekte wird als Boxing bezeichnet, und die Konvertierung von Objekten in Werttypen als Unboxing.

Alle Laufzeiten

(Es gibt keine Hinweise für diese Sprachfunktion, die für alle Laufzeiten gültig sind.)

Windows-Runtime

C++/CX unterstützt eine Kurzsyntax für Boxing-Werttypen und Unboxing-Verweistypen. Ein Werttyp mittels Boxing konvertiert, wenn sie einer Variable des Typs Object zugewiesen wird. Eine Object-Variable wird mittels Unboxing konvertiert, wenn sie einer Werttypvariable zugeordnet ist und der Unboxing-Typ in Klammern angegeben wird; d. h., wenn die Objektvariable in einen Werttyp umgewandelt wird.

  Platform::Object^
  object_variable  = value_variable;
value_variable = (value_type) object_variable;

Anforderungen

Compileroption: /ZW

Beispiele

Im folgenden Beispiel wird ein DateTime-Wert mittels Boxing und Unboxing konvertiert. Zunächst ruft das Beispiel einen DateTime-Wert ab, der das aktuelle Datum und die Uhrzeit darstellt, und weist ihm eine DateTime-Variable zu. Anschließend wird DateTime durch Zuweisen zu einer Object-Variablen mittels Boxing konvertiert. Schließlich wird der Boxing-Wert mittels Unboxing zurückkonvertiert, indem ihm eine andere DateTime-Variable zugewiesen wird.

Um das Beispiel zu testen, erstellen Sie ein BlankApplication-Projekt, ersetzen Sie die BlankPage::OnNavigatedTo()-Methode, und geben Sie dann bei der schließenden Klammer Haltepunkte und die Zuweisung zur Variablen str1 an. Wenn im Beispiel die schließende Klammer erreicht wird, untersuchen Sie str1.

void BlankPage::OnNavigatedTo(NavigationEventArgs^ e)
{
    using namespace Windows::Globalization::DateTimeFormatting;

    Windows::Foundation::DateTime dt, dtAnother;
    Platform::Object^ obj1;

    Windows::Globalization::Calendar^ c =
        ref new Windows::Globalization::Calendar;
    c->SetToNow();
    dt = c->GetDateTime();
    auto dtf = ref new DateTimeFormatter(
                           YearFormat::Full,
                           MonthFormat::Numeric,
                           DayFormat::Default,
                           DayOfWeekFormat::None);
    String^ str1 = dtf->Format(dt);
    OutputDebugString(str1->Data());
    OutputDebugString(L"\r\n");

    // Box the value type and assign to a reference type.
    obj1 = dt;
    // Unbox the reference type and assign to a value type.
    dtAnother = (Windows::Foundation::DateTime) obj1;

    // Format the DateTime for display.
    String^ str2 = dtf->Format(dtAnother);
    OutputDebugString(str2->Data());
}

Weitere Informationen finden Sie unter Boxing (C++/CX).

Übersicht: Common Language Runtime (CLR)

Der Compiler konvertiert Werttypen durch Boxing in Object. Dies ist möglich durch eine compiler-definierte Konvertierung zur Konvertierung von Werttypen in Object.

Mit Boxing und Unboxing können Werttypen wie Objekte behandelt werden. Werttypen, einschließlich Strukturtypen und integrierten Typen wie int, können in und aus dem Typ Object konvertiert werden.

Weitere Informationen finden Sie unter:

Anforderungen

Compileroption: /clr

Beispiele

Das folgende Beispiel zeigt wie implizites Boxing funktioniert.

// vcmcppv2_explicit_boxing2.cpp
// compile with: /clr
using namespace System;

ref class A {
public:
   void func(System::Object^ o){Console::WriteLine("in A");}
};

value class V {};

interface struct IFace {
   void func();
};

value class V1 : public IFace {
public:
   virtual void func() {
      Console::WriteLine("Interface function");
   }
};

value struct V2 {
   // conversion operator to System::Object
   static operator System::Object^(V2 v2) {
      Console::WriteLine("operator System::Object^");
      return (V2^)v2;
   }
};

void func1(System::Object^){Console::WriteLine("in void func1(System::Object^)");}
void func1(V2^){Console::WriteLine("in func1(V2^)");}

void func2(System::ValueType^){Console::WriteLine("in func2(System::ValueType^)");}
void func2(System::Object^){Console::WriteLine("in func2(System::Object^)");}

int main() {
   // example 1 simple implicit boxing
   Int32^ bi = 1;
   Console::WriteLine(bi);

   // example 2 calling a member with implicit boxing
   Int32 n = 10;
   Console::WriteLine("xx = {0}", n.ToString());

   // example 3 implicit boxing for function calls
   A^ a = gcnew A;
   a->func(n);

   // example 4 implicit boxing for WriteLine function call
   V v;
   Console::WriteLine("Class {0} passed using implicit boxing", v);
   Console::WriteLine("Class {0} passed with forced boxing", (V^)(v));   // force boxing

   // example 5 casting to a base with implicit boxing
   V1 v1;
   IFace ^ iface = v1;
   iface->func();

   // example 6 user-defined conversion preferred over implicit boxing for function-call parameter matching
   V2 v2;
   func1(v2);   // user defined conversion from V2 to System::Object preferred over implicit boxing
                // Will call void func1(System::Object^);

   func2(v2);   // OK: Calls "static V2::operator System::Object^(V2 v2)"
   func2((V2^)v2);   // Using explicit boxing: calls func2(System::ValueType^)
}

1

xx = 10

in A

Class V passed using implicit boxing

Class V passed with forced boxing

Interface function

in func1(V2^)

in func2(System::ValueType^)

in func2(System::ValueType^)

Siehe auch

Komponentenerweiterungen für .NET und UWP