Freigeben über

Boxing (Komponentenerweiterungen für C++)

  • Artikel

Der Visual C++-Compiler kann Werttypen auf Objekte im boxing-Prozess konvertieren und konvertiert Objekte in Werttypen im unboxing-Prozess.

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 Syntax-Kurznotation für das Boxing von Werttypen und das Unboxing von Verweistypen. Ein Werttyp wird geschachtelt, wenn er eine Variable vom Typ Object zugewiesen wird. Eine Object-Variable wird mittels Unboxing konvertiert, wenn sie einer Werttypvariable zugewiesen ist und der mittels Unboxing entpackte Typ in Klammern angegeben wird; das heißt, wenn die Objektvariable in einen Werttyp umgewandelt wird.

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

Voraussetzungen

Compileroption: /ZW

Beispiele

Im folgenden Codebeispiel wird der DateTime-Wert mittels Boxing gepackt und mittels Unboxing entpackt. Zuerst wird im Beispiel ein Datum-Uhrzeit-Wert eingefügt, der das aktuelle Datum und die Uhrzeit darstellt und einer Datum-Zeit-Variable zuweist. Anschließend wird DateTime geschachtelt, indem es einer Objektvariablen zugewiesen wird. Schließlich wird der geschachtelte Wert mittels Unboxing konvertiert, indem er einer anderen Datum-Zeit-Variable zugewiesen wird.

Um das Beispiel zu testen, erstellen Sie ein BlankApplications-Projekt, ersetzen Sie die BlankPage::OnNavigatedTo()-Methode, und geben Sie anschließend Haltepunkte an der schließende Klammer und die Zuweisung zur Variablen str1 an. Wenn das Beispiel die schließende Klammer erreicht, überprüfen 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).

Common Language Runtime

Der Visual C++-Compiler wird Werttypen jetzt mittels Boxing in Object konvertieren. Der Grund dafür ist, dass eine vom Compiler definierte Konvertierung Werttypen in Object konvertiert.

Boxing und Unboxing aktivieren Werttypen, die als Objekte behandelt werden sollen. Werttypen, einschließlich Strukturtypen und integrierte Datentypen wie int, können in und aus dem Typ Object konvertiert werden.

Weitere Informationen finden Sie unter:

Voraussetzungen

Compileroption: /clr

Beispiele

Beispiel

Im folgenden Beispiel wird gezeigt, 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^)
}

Ausgabe

1

Siehe auch

Konzepte

Komponentenerweiterungen für Laufzeitplattformen