Dela via

Partiella klasser (C++/CX)

En partiell klass är en konstruktion som stöder scenarier där du ändrar en del av en klassdefinition och automatisk kodgenererande programvara, till exempel XAML-designern, också ändrar kod i samma klass. Genom att använda en partiell klass kan du förhindra att designern skriver över koden. I ett Visual Studio-projekt partial tillämpas modifieraren automatiskt på den genererade filen.

Syntax

Om du vill definiera en partiell klass använder du nyckelordet partial omedelbart före klassnyckeln för vad som annars skulle vara en normal klassdefinition. Ett nyckelord som partial ref class är ett kontextuellt nyckelord som innehåller blankstegstecken. Partiella definitioner stöds i följande konstruktioner.

  • class eller struct

  • ref class eller ref struct

  • value class eller value struct

  • enum eller enum class

  • ref interface, interface class, interface structeller __interface

  • union

Det här exemplet visar en partiell ref class:

partial ref class MyClass {/* ... */};

Innehåll

En partiell klassdefinition kan innehålla allt som den fullständiga klassdefinitionen kan innehålla om nyckelordet partial utelämnats. Med ett undantag omfattar detta alla giltiga konstruktioner som basklasser, datamedlemmar, medlemsfunktioner, uppräkningar, vändeklarationer och attribut. Och infogade definitioner av statiska datamedlemmar tillåts.

Det enda undantaget är klasstillgänglighet. Instruktionen public partial class MyInvalidClass {/* ... */}; är till exempel ett fel. Åtkomstspecificerare som används i en partiell klassdefinition för MyInvalidClass påverkar inte standardtillgängligheten i en efterföljande partiell eller fullständig klassdefinition för MyInvalidClass.

Följande kodfragment visar tillgänglighet. I den första partiella klassen Method1 är offentlig eftersom dess tillgänglighet är offentlig. I den andra partiella klassen Method2 är privat eftersom standardklassens tillgänglighet är privat.

partial ref class N 
{
public:
    int Method1(); // Method1 is public.

};
ref class N 
{   
    void Method2(); // Method2 is private.
};

Deklaration

En partiell definition av en klass, MyClass till exempel, är bara en deklaration av MyClass. Det innebär att det bara introducerar namnet MyClass. MyClass kan inte användas på ett sätt som kräver en klassdefinition, till exempel att känna till storleken på MyClass eller använda en bas eller medlem MyClassi . MyClass anses endast definieras när kompilatorn stöter på en icke-partiell definition av MyClass.

I följande exempel visas deklarationsbeteendet för en partiell klass. Efter deklaration nr 1 MyClass kan användas som om den skrevs som framåtdeklaration, ref class MyClass;. Deklaration nr 2 motsvarar deklaration nr 1. Deklaration nr 3 är giltig eftersom det är en framåtdeklaration till en klass. Men deklaration nr 4 är ogiltig eftersom

MyClass är inte helt definierad.

Deklaration nr 5 använder inte nyckelordet partial och deklarationen definierar MyClassfullständigt . Därför är deklaration nr 6 giltig.

// Declaration #1
partial ref class MyClass {};

// Declaration #2
partial ref class MyClass;

// Declaration #3
MyClass^ pMc; // OK, forward declaration.

// Declaration #4
MyClass mc; // Error, MyClass is not defined.

// Declaration #5
ref class MyClass { };

// Declaration #6
MyClass mc; // OK, now MyClass is defined.

Nummer och beställning

Det kan finnas noll eller flera partiella klassdefinitioner för varje fullständig definition av en klass.

Varje partiell klassdefinition av en klass måste lexikalt föregå den fullständiga definitionen av den klassen, men behöver inte föregå framåtriktade deklarationer för klassen. Om det inte finns någon fullständig definition av klassen kan de partiella klassdeklarationerna endast vidarebefordra deklarationer.

Alla klassnycklar som class och struct måste matcha. Det är till exempel ett fel att koda partial class X {}; struct X {};.

I följande exempel visas tal och ordning. Den sista partiella deklarationen misslyckas eftersom klassen redan har definierats.

ref class MyClass;  // OK
partial ref class MyClass{};  //OK
partial ref class MyClass{}; // OK
partial ref class MyClass{}; // OK
ref class MyClass{}; // OK
partial ref class MyClass{}; // C3971, partial definition cannot appear after full definition.

Fullständig definition

Vid tidpunkten för den fullständiga definitionen av klassen X är beteendet detsamma som om definitionen av X hade deklarerat alla basklasser, medlemmar och så vidare, i den ordning de påträffades och definierades i de partiella klasserna. Det innebär att innehållet i de partiella klasserna behandlas som om de skrevs vid den punkt där klassens fullständiga definition angavs, och namnuppslag och andra språkregler tillämpas vid tidpunkten för den fullständiga definitionen av klassen som om innehållet i de partiella klasserna skrevs på plats

Följande två kodexempel har identisk betydelse och effekt. I det första exemplet används en partiell klass och det andra exemplet gör det inte.

ref class Base1 { public: property int m_num; int GetNumBase();};
interface class Base2 { int GetNum(); };
interface class Base3{ int GetNum2();};

partial ref class N : public Base1 
{
public:
    /*...*/

};

partial ref class N : public Base2
{
public:
    virtual int GetNum();
    // OK, as long as OtherClass is
    //declared before the full definition of N
    void Method2( OtherClass^ oc );       
};

ref class OtherClass;

ref class N : public Base3
{    
public:
    virtual int GetNum2();
};

 

ref class OtherClass;
ref class N : public Base1, public Base2, public Base3 
{
public:    
    virtual int GetNum();
    virtual int GetNum2();
private:    
    void Method2(OtherClass^ oc);

};

Templates

En partiell klass kan inte vara en mall.

Begränsningar

En partiell klass kan inte sträcka sig över en översättningsenhet.

Nyckelordet partial stöds endast i kombination med nyckelordet ref class eller nyckelordet value class .

Exempel

I följande exempel definieras klassen i Address två kodfiler. Designern ändrar Address.details.h och du ändrar Address.h. Endast klassdefinitionen i den första filen använder nyckelordet partial .

// Address.Details.h
partial ref class Address
{
private:
  Platform::String^ street_;
  Platform::String^ city_;
  Platform::String^ state_;
  Platform::String^ zip_;
  Platform::String^ country_;
  void ValidateAddress(bool normalize = true);
};

 

// Address.h
#include "Address.details.h"
ref class Address
{
public:
  Address(Platform::String^ street, Platform::String^ city, Platform::String^ state,
    Platform::String^ zip, Platform::String^ country);
  property Platform::String^ Street { Platform::String^ get(); }
  property Platform::String^ City { Platform::String^ get(); }
  property Platform::String^ State { Platform::String^ get(); }
  property Platform::String^ Zip { Platform::String^ get(); }
  property Platform::String^ Country { Platform::String^ get(); }
};

Se även

typsystem
C++/CX-språkreferens
referens för namnområden

  • Last updated on