Waardeklassen en structs (C++/CX)

Een waardestruct of waardeklasse is een met Windows Runtime compatibele POD ('gewone oude gegevensstructuur'). Het heeft een vaste grootte en bestaat alleen uit velden; in tegenstelling tot een referentieklasse heeft het geen eigenschappen.

In de volgende voorbeelden ziet u hoe u waardestructs declareert en initialiseert.

// in mainpage.xaml.h:
    value struct TestStruct
    {
        Platform::String^ str;
        int i;
    };

    value struct TestStruct2
    {
        TestStruct ts;
        Platform::String^ str;
        int i;
    };

// in mainpage.cpp:
    // Initialize a value struct with an int and String
    TestStruct ts = {"I am a TestStruct", 1};

    // Initialize a value struct that contains
    // another value struct, an int and a String
    TestStruct2 ts2 = {{"I am a TestStruct", 1}, "I am a TestStruct2", 2};

    // Initialize value struct members individually.
    TestStruct ts3;
    ts3.i = 108;
    ts3.str = "Another way to init a value struct.";

Wanneer een variabele van een waardetype wordt toegewezen aan een andere variabele, wordt de waarde gekopieerd, zodat elk van de twee variabelen een eigen kopie van de gegevens heeft. Een waarde struct is een structuur met vaste grootte die alleen openbare gegevensvelden bevat en wordt gedeclareerd met behulp van het value struct trefwoord.

Een waardeklasse is net als een value struct, behalve dat de velden expliciet openbare toegankelijkheid moeten krijgen. Deze wordt gedeclareerd met behulp van het value class trefwoord.

Een waardestruct of waardeklasse kan alleen fundamentele numerieke typen, opsommingsklassen, Platform::String^, of Platform::IBox <T>^ bevatten als velden, waarbij T een numeriek type, een opsommingsklasse, een waardeklasse, of -struct is. Een IBox<T>^ veld kan een waarde hebben van nullptr. Dit is hoe C++ het concept van null-waardetypenimplementeert.

Een waardeklasse of waardestruct die een type Platform::String^ of IBox<T>^ als onderdeel heeft, kan niet memcpyworden.

Omdat alle leden van een value class of value struct openbaar zijn en in metagegevens worden verzonden, zijn standaard C++-typen niet toegestaan als leden. Dit verschilt van ref-klassen, die mogelijk standaard C++-typen zoals private of internal kunnen bevatten.

Het volgende codefragment declareert de Coordinates en City typen als waardestructs. Merk op dat één van de City-gegevensleden van het GeoCoordinates-type is. Een value struct kan andere waarde structuren bevatten als elementen.

public enum class Continent 
{  
    Africa,
    Asia,
    Australia,
    Europe,
    NorthAmerica,
    SouthAmerica,
    Antarctica 
};

value struct GeoCoordinates
{
    double Latitude; //or float64 if you prefer
    double Longitude;
};

value struct City
{
    Platform::String^ Name;
    int Population;
    double AverageTemperature;
    GeoCoordinates Coordinates;
    Continent continent;
};

Parameter doorgeven voor waardetypen

Als u een waardetype als functie- of methodeparameter hebt, wordt dit normaal gesproken doorgegeven door een waarde. Voor grotere objecten kan dit een prestatieprobleem veroorzaken. In Visual Studio 2013 en eerder werden waardetypen in C++/CX altijd als waarde doorgegeven. In Visual Studio 2015 en hoger kunt u waardetypen doorgeven op basis van verwijzing of op waarde.

Als u een parameter wilt declareren die een waardetype op waarde doorgeeft, gebruikt u code als de volgende:

void Method1(MyValueType obj);

Als u een parameter wilt declareren die een waardetype doorgeeft per verwijzing, gebruikt u het verwijzingssymbool (&), zoals in het volgende:

void Method2(MyValueType& obj);

Het type in Method2 is een verwijzing naar MyValueType en werkt op dezelfde manier als een verwijzingstype in standaard C++.

Wanneer u Method1 aanroept vanuit een andere taal, zoals C#, hoeft u het trefwoord ref of out niet te gebruiken. Wanneer u Method2 aanroept, gebruikt u het trefwoord ref.

Method2(ref obj);

U kunt ook een aanwijzersymbool (*) gebruiken om een waardetype per verwijzing door te geven. Het gedrag met betrekking tot bellers in andere talen is hetzelfde (bellers in C# gebruiken het ref trefwoord), maar in de methode is het type een aanwijzer naar het waardetype.

Typen null-waarden

Zoals eerder vermeld, kan een waarde-klasse of waarde-struct een veld hebben van het type Platform::IBox<T>^— bijvoorbeeld IBox<int>^. Een dergelijk veld kan elke numerieke waarde hebben die geldig is voor het type int of kan een waarde van nullptrhebben. U kunt een nulwaardeveld als argument doorgeven aan een methode waarvan de parameter als optioneel is gedeclareerd, of ergens anders waar voor een waardetype geen waarde vereist is.

In het volgende voorbeeld ziet u hoe u een struct initialiseert met een null-veld.

public value struct Student
{
    Platform::String^ Name;
    int EnrollmentYear;
    Platform::IBox<int>^ GraduationYear; // Null if not yet graduated.
};
//To create a Student struct, one must populate the nullable type.
MainPage::MainPage()
{
    InitializeComponent();

    Student A;
    A.Name = "Alice";
    A.EnrollmentYear = 2008;
    A.GraduationYear = ref new Platform::Box<int>(2012);

    Student B;
    B.Name = "Bob";
    B.EnrollmentYear = 2011;
    B.GraduationYear = nullptr;

    IsCurrentlyEnrolled(A);
    IsCurrentlyEnrolled(B);
}
bool MainPage::IsCurrentlyEnrolled(Student s)
{
    if (s.GraduationYear == nullptr)
    {
        return true;
    }
    return false;
}

Een waardestruct zelf kan op dezelfde manier null worden gemaakt, zoals hier wordt weergegeven:

public value struct MyStruct
{
public:
    int i;
    Platform::String^ s;
};

public ref class MyClass sealed
{
public:
    property Platform::IBox<MyStruct>^ myNullableStruct;
};

Zie ook

Typesysteem (C++/CX)
C++/CX Taalreferentie
verwijzing naar naamruimten
Referentieklassen en -structs (C++/CX)