Részleges osztályok (C++/CX)

A részleges osztály olyan szerkezet, amely támogatja azokat a forgatókönyveket, amelyekben egy osztálydefiníció egy részét módosítja, és az automatikus kódgeneráló szoftverek – például az XAML-tervező – szintén ugyanabban az osztályban módosítják a kódot. Részleges osztály használatával megakadályozhatja, hogy a tervező felülírja a kódot. Egy Visual Studio-projektben a rendszer automatikusan alkalmazza a partial módosítót a létrehozott fájlra.

Szemantika

Részleges osztály definiálásához használja a partial kulcsszót közvetlenül a normál osztálydefiníció osztálykulcsa előtt. Egy kulcsszó, például partial ref class egy környezetfüggő kulcsszó, amely szóköz karaktereket tartalmaz. A részleges definíciókat az alábbi szerkezetek támogatják.

• class vagy struct

• ref class vagy ref struct

• value class vagy value struct

• enum vagy enum class

• ref interface, interface class, interface structvagy __interface

• union

Ez a példa egy részleges ref class:

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

Tartalom

A részleges osztálydefiníciók bármit tartalmazhatnak, amelyet a teljes osztálydefiníció tartalmazhat, ha a partial kulcsszót kihagyták. Egyetlen kivétellel ez minden érvényes szerkezetet magában foglal, például alaposztályokat, adattagokat, tagfüggvényeket, számokat, barátdeklarációkat és attribútumokat. A statikus adattagok beágyazott definíciói pedig engedélyezettek.

Az egyetlen kivétel az osztály akadálymentessége. Az utasítás public partial class MyInvalidClass {/* ... */}; például hiba. A MyInvalidClass részleges osztálydefiníciójában használt hozzáférés-meghatározók nem befolyásolják a MyInvalidClass egy későbbi részleges vagy teljes osztálydefiníciójának alapértelmezett akadálymentességét.

Az alábbi kódrészlet a kisegítő lehetőségeket mutatja be. Az első részleges osztályban nyilvános, Method1 mert az akadálymentessége nyilvános. A második részleges osztály privát, Method2 mert az alapértelmezett osztály akadálymentessége privát.

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

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

Nyilatkozat

Egy osztály részleges definíciója, például MyClass csak a MyClass deklarációja. Ez azt jelzi, hogy csak a nevet MyClass. MyClass nem használható olyan módon, amely osztálydefiníciót igényel, például annak méretét MyClass vagy egy alap vagy tag MyClassméretét ismerve. MyClasscsak akkor tekinthető definiáltnak, ha a fordító nem részleges definícióval találkozik.MyClass

Az alábbi példa egy részleges osztály deklarációs viselkedését mutatja be. Az 1. deklaráció után úgy használható, MyClass mintha a továbbítási deklarációként lett volna megírva. ref class MyClass; A 2. deklaráció egyenértékű az 1. deklarációval. A 3. deklaráció azért érvényes, mert egy osztálynak továbbított deklaráció. A 4. deklaráció azonban érvénytelen, mert

MyClass nincs teljesen definiálva.

Az 5. deklaráció nem használja a kulcsszót partial , és a deklaráció teljes mértékben meghatározza MyClass. Következésképpen a 6. deklaráció érvényes.

// 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.

Szám és rendelés

Az osztály minden teljes definíciója nulla vagy több részleges osztálydefiníciót tartalmazhat.

Az osztály minden részleges osztálydefiníciójának lexikálisan meg kell előznie az osztály egyetlen teljes definícióját, de nem kell megelőznie az osztály előre deklarációit. Ha nincs teljes definíciója az osztálynak, akkor a részleges osztálydeklarációk csak továbbítási deklarációk lehetnek.

Minden osztálykulcsnak meg kell egyeznie, például class és struct meg kell egyeznie. Ez például hiba a kódban partial class X {}; struct X {};.

Az alábbi példa a számokat és a rendezést mutatja be. Az utolsó részleges deklaráció meghiúsul, mert az osztály már definiálva van.

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.

Teljes definíció

Az X osztály teljes definíciójának időpontjában a viselkedés ugyanaz, mintha az X definíciója az összes alaposztályt, tagot stb. deklarálta volna abban a sorrendben, amelyben a részleges osztályokban találkoztak és definiálták őket. Vagyis a részleges osztályok tartalmát úgy kezeli a rendszer, mintha az osztály teljes definíciójának helyén írták volna őket, és a névkeresést és más nyelvi szabályokat az osztály teljes definíciójának helyén alkalmazzák, mintha a részleges osztályok tartalma a helyén lett volna megírva.

Az alábbi két kódpéldának azonos jelentése és hatása van. Az első példa egy részleges osztályt használ, a második példa pedig nem.

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);

};

Sablonok

A részleges osztály nem lehet sablon.

Korlátozások

Egy részleges osztály nem terjedhet ki egy fordítási egységen túlra.

A partial kulcsszó csak a kulcsszóval vagy a ref classvalue class kulcsszóval együtt támogatott.

Példák

Az alábbi példa két kódfájl osztályát Address határozza meg. A tervező módosítja Address.details.h , és ön módosítja Address.h. A kulcsszót csak az első fájl osztálydefiníciója használja 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(); }
};

Lásd még

Típus rendszer
C++/CX nyelvi referencia
Névterek – referencia