Boxing (Estensioni del componente C++)

Il compilatore di Visual C++ può convertire i tipi di valore in oggetti con un processo chiamato boxing e può convertire oggetti in tipi di valore con un processo chiamato unboxing.

Tutti i runtime

(Non esistono note per questa funzionalità del linguaggio che si applichino a tutti i runtime).

Windows Runtime

C++/CX supporta una sintassi abbreviata per eseguire il boxing di tipi di valore e l'unboxing di tipi di riferimento.Un tipo di valore viene sottoposto al boxing quando viene assegnato a una variabile di tipo Object.Viene eseguito l'unboxing su una variabile Object quando questa viene assegnata ad una variabile di tipo di valore e il tipo di unboxed viene specificato tra parentesi, ovvero quando la variabile oggetto subisce il cast a un tipo di valore.

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

Requisiti

Opzione del compilatore: /ZW

Esempi

Nell'esempio di codice seguente si esegue il boxing e l'unboxing di valore DateTime.Innanzitutto, l'esempio ottiene un valore DateTime che rappresenta la data e l'ora corrente e lo assegna ad una variabile DateTime.Il DateTime viene poi sottoposto al boxing assegnandolo ad una variabile Object.Infine, il valore boxed subisce l'unboxing assegnandolo ad un'altra variabile DateTime.

Per testare l'esempio, creare un progetto BlankApplication, sostituire il metodo BlankPage::OnNavigatedTo() e quindi specificare i punti di interruzione alla parentesi di chiusura e all'assegnamento alla variabile str1.Quando viene raggiunta la parentesi di chiusura, esaminare 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());
}

Per ulteriori informazioni, vedere la pagina relativa a boxing (C++/CX).

Common Language Runtime

Il compilatore di Visual C++ attualmente esegue il boxing dei tipi di valore a Object.Questo è possibile grazie a una conversione definita dal compilatore ai tipi di valore in Object.

Le conversioni boxing e unboxing consentono ai tipi di valore di essere considerati come oggetti.I tipi di valore, inclusi tipi struct e tipi incorporati come int, possono essere convertiti in e dal tipo Object.

Per ulteriori informazioni, vedere:

• Procedura: In modo esplicito conversione boxing di richiesta

• Procedura: Gcnew di utilizzo per creare tipi di valore e utilizzare il boxing implicito

• Procedura: Conversione unboxing

• Conversioni standard e il boxing implicito

Requisiti

Opzione del compilatore: /clr

Esempi

Esempio

Il seguente codice di esempio mostra come lavora un boxing implicito.

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

Output

Vedere anche

Concetti

Estensioni componenti per le piattaforme runtime