Ref-klassen en -structs (C++/CX)

De C++/CX ondersteunt door de gebruiker gedefinieerde verw-klassen en verw-structs, en door de gebruiker gedefinieerde waardeklassen en waardestructs. Deze gegevensstructuren zijn de primaire containers waarmee C++/CX het Windows Runtime-typesysteem ondersteunt. De inhoud wordt verzonden naar metagegevens volgens bepaalde specifieke regels. Hierdoor kunnen ze worden doorgegeven tussen Windows Runtime-onderdelen en Universal Windows Platform-apps die zijn geschreven in C++ of andere talen.

Een verw-klasse of verw-struct heeft de volgende essentiële kenmerken:

Deze moet worden gedeclareerd binnen een naamruimte, bij het bereik van de naamruimte en in die naamruimte heeft deze mogelijk openbare of persoonlijke toegankelijkheid. Alleen openbare typen worden verzonden naar metagegevens. Geneste openbare klassedefinities zijn niet toegestaan, inclusief geneste openbare enumklassen . Zie Naamruimten en Zichtbaarheid van type voor meer informatie.
Het kan bestaan als leden C++/CX, inclusief refklassen, waardeklassen, verw-structs, waardestructs of structs voor null-waarden. Het kan ook scalaire typen bevatten, zoals float64, boolenzovoort. Het kan ook standaard C++-typen bevatten, zoals std::vector of een aangepaste klasse, zolang ze niet openbaar zijn. C++/CX-constructies hebben publicmogelijk , protectedof privateinternalprotected private toegankelijkheid. Alle public leden of protected leden worden verzonden naar metagegevens. Standaard C++-typen moeten over of internalprotected private toegankelijkheid beschikkenprivate, waardoor ze niet naar metagegevens kunnen worden verzonden.
Het kan een of meer interfaceklassen of interface-structs implementeren.
Het kan overnemen van één basisklasse en basisklassen zelf hebben extra beperkingen. Overname in openbare verw-klassenhiërarchieën heeft meer beperkingen dan overname in privéverwijzingsklassen.
Deze wordt mogelijk niet als algemeen gedeclareerd. Als deze persoonlijke toegankelijkheid heeft, kan het een sjabloon zijn.
De levensduur wordt beheerd door het automatisch tellen van verwijzingen.

Verklaring

Het volgende codefragment declareert de Person verw-klasse. U ziet dat het standaardtype C++ std::map wordt gebruikt in de privéleden en dat de Windows Runtime-interface IMapView wordt gebruikt in de openbare interface. U ziet ook dat ^wordt toegevoegd aan declaraties van referentietypen.

// #include <map>
namespace WFC = Windows::Foundation::Collections;
namespace WFM = Windows::Foundation::Metadata;

[WFM::WebHostHidden]
ref class Person sealed
{
public:
    Person(Platform::String^ name);
    void AddPhoneNumber(Platform::String^ type, Platform::String^ number);
    property WFC::IMapView<Platform::String^, Platform::String^>^ PhoneNumbers
    { 
        WFC::IMapView<Platform::String^, Platform::String^>^ get();
    }
private:
    Platform::String^ m_name;
    std::map<Platform::String^, Platform::String^> m_numbers;
};

Implementatie

In dit codevoorbeeld ziet u een implementatie van de Person verw-klasse:

#include <collection.h>
using namespace Windows::Foundation::Collections;
using namespace Platform;
using namespace Platform::Collections;

Person::Person(String^ name): m_name(name) { }
void Person::AddPhoneNumber(String^ type, String^ number)
{
    m_numbers[type] = number;
}
IMapView< String^, String^>^ Person::PhoneNumbers::get()
{
    // Simple implementation. 
    return ref new MapView< String^, String^>(m_numbers);
}

Gebruik

In het volgende codevoorbeeld ziet u hoe clientcode gebruikmaakt van de Person verw-klasse.

using namespace Platform;

Person^ p = ref new Person("Clark Kent");
p->AddPhoneNumber("Home", "425-555-4567");
p->AddPhoneNumber("Work", "206-555-9999");
String^ workphone = p->PhoneNumbers->Lookup("Work");

U kunt ook stack-semantiek gebruiken om een lokale verw-klassevariabele te declareren. Een dergelijk object gedraagt zich als een op stack gebaseerde variabele, ook al wordt het geheugen nog steeds dynamisch toegewezen. Een belangrijk verschil is dat u geen traceringsreferentie (%) kunt toewijzen aan een variabele die wordt gedeclareerd met behulp van stack-semantiek; dit garandeert dat het aantal verwijzingen wordt afgebroken tot nul wanneer de functie wordt afgesloten. In dit voorbeeld ziet u een eenvoudige verw-klasse Urien een functie die deze gebruikt met stack-semantiek:

void DoSomething()
{
    Windows::Foundation::Uri docs("http://docs.microsoft.com");
    Windows::Foundation::Uri^ devCenter = docs.CombineUri("/windows/");
    // ... 
} // both variables cleaned up here.

Geheugenbeheer

U wijst een verw-klasse toe in dynamisch geheugen met behulp van het ref new trefwoord.

MyRefClass^ myClass = ref new MyRefClass();

De handle-to-object-operator ^ wordt een hoed genoemd en is in wezen een C++-slimme aanwijzer. Het geheugen dat naar verwijst, wordt automatisch vernietigd wanneer de laatste hoed buiten het bereik valt of expliciet is ingesteld op nullptr.

Een verw-klasse heeft per definitie verwijzingssemantiek. Wanneer u een verw-klassevariabele toewijst, is dit de greep die wordt gekopieerd, niet het object zelf. In het volgende voorbeeld verwijzen beide na de toewijzing beide myClassmyClass2 naar dezelfde geheugenlocatie.

MyRefClass^ myClass = ref new MyRefClass();
MyRefClass^ myClass2 = myClass;

Wanneer een C++/CX-refklasse wordt geïnstantieerd, wordt het geheugen nul geïnitialiseerd voordat de constructor wordt aangeroepen; daarom is het niet nodig om afzonderlijke leden met nul te initialiseren, inclusief eigenschappen. Als de C++/CX-klasse is afgeleid van een WINDOWS Runtime C++-bibliotheekklasse (WRL), wordt alleen het C++/CX-afgeleide klassegedeelte nul geïnitialiseerd.

Leden

Een verw-klasse kan functieleden bevattenpublicprotected, private alleen public en protected leden worden verzonden in metagegevens. Geneste klassen en refklassen zijn toegestaan, maar kunnen niet.public Openbare velden zijn niet toegestaan; leden van openbare gegevens moeten worden gedeclareerd als eigenschappen. Leden van persoonlijke of beveiligde interne gegevens kunnen velden zijn. Standaard is privatede toegankelijkheid van alle leden in een verw-klasse.

Een verw-struct is hetzelfde als een verwijzingsklasse, behalve dat de leden standaard toegankelijkheid hebben public .

Een public verwklasse of verw-struct wordt verzonden in metagegevens, maar moet kunnen worden gebruikt vanuit andere universele Windows-platform-apps en Windows Runtime-onderdelen die ten minste één openbare of beveiligde constructor hebben. Een openbare verw-klasse met een openbare constructor moet ook worden gedeclareerd sealed om verdere afleiding via de binaire interface van de toepassing (ABI) te voorkomen.

Openbare leden worden mogelijk niet gedeclareerd omdat const het Windows Runtime-typesysteem geen ondersteuning biedt voor const. U kunt een statische eigenschap gebruiken om een openbaar gegevenslid met een constante waarde te declareren.

Wanneer u een openbare verw-klasse of -struct definieert, past de compiler de vereiste kenmerken toe op de klasse en slaat deze informatie op in het .winmd-bestand van de app. Wanneer u echter een openbare niet-verzegelde verw-klasse definieert, past u het Windows::Foundation::Metadata::WebHostHidden kenmerk handmatig toe om ervoor te zorgen dat de klasse niet zichtbaar is voor Universal Windows Platform-apps die zijn geschreven in JavaScript.

Een verw-klasse kan standaard C++-typen hebben, waaronder const typen, in elke private, internalof protected private leden.

Openbare ref-klassen met typeparameters zijn niet toegestaan. Door de gebruiker gedefinieerde algemene verw-klassen zijn niet toegestaan. Een persoonlijke, interne of beveiligde privéverw-klasse kan een sjabloon zijn.

Destructoren

In C++/CX delete roept een openbare destructor destructor aan, ongeacht het aantal verwijzingen van het object. Met dit gedrag kunt u een destructor definiëren die op een deterministische manier aangepaste opschoning van niet-RAII-resources uitvoert. Zelfs in dit geval wordt het object zelf echter niet uit het geheugen verwijderd. Het geheugen voor het object wordt alleen vrijgemaakt wanneer het aantal verwijzingen nul bereikt.

Als de destructor van een klasse niet openbaar is, wordt deze alleen aangeroepen wanneer het aantal verwijzingen nul bereikt. Als u een object aanroept delete dat een privédestructor heeft, roept de compiler waarschuwing C4493 op, met de tekst 'verwijderexpressie heeft geen effect omdat de destructor van <het typenaam> geen 'openbare' toegankelijkheid heeft.

Verw-klassedestructors kunnen alleen als volgt worden gedeclareerd:

openbaar en virtueel (toegestaan voor verzegelde of niet-verzegelde typen)
beveiligd privé en niet-virtueel (alleen toegestaan voor niet-verzegelde typen)
privé en niet-virtueel (alleen toegestaan voor verzegelde typen)

Er is geen andere combinatie van toegankelijkheid, virtualisatie en verzegeling toegestaan. Als u niet expliciet een destructor declareert, genereert de compiler een openbare virtuele destructor als de basisklasse van het type of een lid een openbare destructor heeft. Anders genereert de compiler een beveiligde niet-virtuele destructor voor niet-verzegelde typen of een privé-niet-virtuele destructor voor verzegelde typen.

Het gedrag is niet gedefinieerd als u probeert toegang te krijgen tot leden van een klasse die al destructor heeft uitgevoerd; dit zal waarschijnlijk ertoe leiden dat het programma vastloopt. Het aanroepen van delete t een type dat geen openbare destructor heeft, heeft geen effect. Het aanroepen van delete this een type of basisklasse met een bekende private of protected private destructor vanuit de typehiërarchie heeft ook geen effect.

Wanneer u een openbare destructor declareert, genereert de compiler de code, zodat de verw-klasse wordt geïmplementeerd Platform::IDisposable en de destructor de Dispose methode implementeert. Platform::IDisposable is de C++/CX-projectie van Windows::Foundation::IClosable. Implementeer deze interfaces nooit expliciet.

Erfenis

Platform::Object is de universele basisklasse voor alle refklassen. Alle verw-klassen zijn impliciet converteerbaar naar Platform::Object en kunnen Object::ToString overschrijven. Het Windows Runtime-overnamemodel is echter niet bedoeld als een algemeen overnamemodel; in C++/CX betekent dit dat een door de gebruiker gedefinieerde openbare verw-klasse niet als basisklasse kan fungeren.

Als u een XAML-gebruikersbesturingselement maakt en het object deelneemt aan het afhankelijkheidseigenschapssysteem, kunt u dit als basisklasse gebruiken Windows::UI::Xaml::DependencyObject .

Nadat u een niet-verzegelde klasse MyBase hebt gedefinieerd die wordt overgenomen van DependencyObject, kunnen andere openbare of privéverw-klassen in uw onderdeel of app overnemen van MyBase. Overname in openbare verw-klassen mag alleen worden uitgevoerd ter ondersteuning van onderdrukkingen van virtuele methoden, polymorfe identiteit en inkapseling.

Een privébasisverwklasse is niet vereist om af te leiden van een bestaande niet-verzegelde klasse. Als u een objecthiërarchie nodig hebt om uw eigen programmastructuur te modelleren of code opnieuw te gebruiken, gebruikt u persoonlijke of interne refklassen, of nog beter, standaard C++-klassen. U kunt de functionaliteit van de privéobjecthiërarchie beschikbaar maken via een openbare verzegelde verw-klasse-wrapper.

Een verw-klasse met een openbare of beveiligde constructor in C++/CX moet worden gedeclareerd als verzegeld. Deze beperking betekent dat er geen manier is voor klassen die zijn geschreven in andere talen, zoals C# of Visual Basic, om over te nemen van typen die u declareert in een Windows Runtime-onderdeel dat is geschreven in C++/CX.

Dit zijn de basisregels voor overname in C++/CX:

Verw-klassen kunnen rechtstreeks overnemen van maximaal één basisverwklasse, maar kunnen een willekeurig aantal interfaces implementeren.
Als een klasse een openbare constructor heeft, moet deze worden gedeclareerd als verzegeld om verdere afleiding te voorkomen.
U kunt openbare niet-verzegelde basisklassen maken met interne of beveiligde privéconstructors, mits de basisklasse rechtstreeks of indirect is afgeleid van een bestaande niet-verzegelde basisklasse, zoals Windows::UI::Xaml::DependencyObject. Overname van door de gebruiker gedefinieerde verw-klassen voor .winmd-bestanden wordt niet ondersteund; Een verw-klasse kan echter overnemen van een interface die is gedefinieerd in een ander .winmd-bestand. U kunt afgeleide klassen maken op basis van een door de gebruiker gedefinieerde basisverwklasse alleen binnen hetzelfde Windows Runtime-onderdeel of de Universal Windows Platform-app.

Voor verw-klassen wordt alleen openbare overname ondersteund.

ref class C{};
public ref class D : private C //Error C3628
{};

In het volgende voorbeeld ziet u hoe u een openbare verw-klasse kunt weergeven die is afgeleid van andere verw-klassen in een overnamehiërarchie.

namespace InheritanceTest2 
{
    namespace WFM = Windows::Foundation::Metadata;

    // Base class. No public constructor.
    [WFM::WebHostHidden]
    public ref class Base : Windows::UI::Xaml::DependencyObject
    {
    internal:
        Base(){}
    protected:
        virtual void DoSomething (){}
        property Windows::UI::Xaml::DependencyProperty^ WidthProperty;
    };

    // Class intended for use by client code across ABI.
    // Declared as sealed with public constructor.
    public ref class MyPublicClass sealed : Base
    {
    public:
        MyPublicClass(){}
        //...
    };
}

Zie ook

Typesysteem
Waardeklassen en structs
Naslaginformatie over C++/CX-taal
Naslaginformatie over naamruimten

Feedback

Is deze pagina nuttig?

Last updated on 2025-11-07