Klasy częściowe (C++/CX)

Artykuł
10/12/2023

Klasa częściowa to konstrukcja, która obsługuje scenariusze, w których modyfikujesz jedną część definicji klasy, a automatyczne oprogramowanie do generowania kodu — na przykład projektant XAML — również modyfikuje kod w tej samej klasie. Korzystając z klasy częściowej, można uniemożliwić projektantowi zastąpienie kodu. W projekcie partial programu Visual Studio modyfikator jest stosowany automatycznie do wygenerowanego pliku.

Składnia

Aby zdefiniować klasę częściową, użyj partial słowa kluczowego bezpośrednio przed kluczem klasy, co w przeciwnym razie byłoby normalną definicją klasy. Słowo kluczowe, takie jak partial ref class jest kontekstowym słowem kluczowym, które zawiera znaki odstępów. Definicje częściowe są obsługiwane w poniższych konstrukcjach.

class lub struct
ref class lub ref struct
value class lub value struct
enum lub enum class
ref interface, interface class, lub interface struct__interface
union

W tym przykładzie pokazano częściowe ref class:

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

Zawartość

Definicja klasy częściowej może zawierać wszystkie elementy, które może zawierać pełna definicja klasy, jeśli partial słowo kluczowe zostało pominięte. Z jednym wyjątkiem obejmuje to dowolną prawidłową konstrukcję, taką jak klasy bazowe, składowe danych, funkcje składowe, wyliczenia, deklaracje przyjacielskie i atrybuty. A wbudowane definicje statycznych elementów członkowskich danych są dozwolone.

Jednym wyjątkiem jest dostępność klasy. Na przykład instrukcja public partial class MyInvalidClass {/* ... */}; jest błędem. Wszelkie specyfikatory dostępu używane w definicji klasy częściowej dla klasy MyInvalidClass nie mają wpływu na domyślną dostępność w kolejnej definicji częściowej lub pełnej klasy dla klasy MyInvalidClass.

Poniższy fragment kodu pokazuje ułatwienia dostępu. W pierwszej klasie częściowej jest publiczne, Method1 ponieważ jej dostępność jest publiczna. W drugiej klasie częściowej jest prywatna, Method2 ponieważ domyślna dostępność klasy jest prywatna.

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

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

Deklaracji

Częściowa definicja klasy, taka jak MyClass , jest tylko deklaracją MyClass. Oznacza to, że wprowadza tylko nazwę MyClass. MyClass Nie można używać w sposób, który wymaga definicji klasy, na przykład znajomości rozmiaru MyClass lub użycia podstawy MyClasslub elementu członkowskiego . MyClass jest uważana za zdefiniowaną tylko wtedy, gdy kompilator napotka nie częściową definicję MyClass.

W poniższym przykładzie pokazano zachowanie deklaracji klasy częściowej. Po deklaracji #1 można użyć tak, MyClass jakby zostały zapisane jako deklaracja przesyłania dalej, ref class MyClass;. Deklaracja #2 jest równoważna deklaracji #1. Deklaracja nr 3 jest prawidłowa, ponieważ jest deklaracją przesyłania dalej do klasy. Ale deklaracja #4 jest nieprawidłowa, ponieważ

MyClass nie jest w pełni zdefiniowany.

Deklaracja nr 5 nie używa słowa kluczowego partial , a deklaracja w pełni definiuje MyClasselement . W związku z tym deklaracja #6 jest prawidłowa.

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

Numerowanie i kolejność

Dla każdej pełnej definicji klasy może istnieć zero lub więcej częściowych definicji klasy.

Każda częściowa definicja klasy musi poprzedzać jedną pełną definicję tej klasy, ale nie musi poprzedzać deklaracji do przodu klasy. Jeśli nie ma pełnej definicji klasy, deklaracje klasy częściowej mogą być tylko deklaracjami do przodu.

Wszystkie klucze klasy, takie jak class i struct muszą być zgodne. Na przykład jest to błąd kodu partial class X {}; struct X {};.

W poniższym przykładzie pokazano liczbę i kolejność. Ostatnia deklaracja częściowa kończy się niepowodzeniem, ponieważ klasa jest już zdefiniowana.

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.

Pełna definicja

W punkcie pełnej definicji klasy X zachowanie jest takie samo, jak w przypadku, gdy definicja X zadeklarowała wszystkie klasy bazowe, składowe i tak dalej, w kolejności, w jakiej zostały napotkane i zdefiniowane w klasach częściowych. Oznacza to, że zawartość klas częściowych jest traktowana tak, jakby została zapisana w punkcie pełnej definicji klasy, a wyszukiwanie nazw i inne reguły języka są stosowane w punkcie pełnej definicji klasy tak, jakby zawartość częściowych klas została zapisana w miejscu

Poniższe dwa przykłady kodu mają identyczne znaczenie i efekt. W pierwszym przykładzie użyto klasy częściowej, a drugi przykład nie.

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

};

Szablony

Klasa częściowa nie może być szablonem.

Ograniczenia

Klasa częściowa nie może przekraczać jednej jednostki tłumaczenia.

Słowo partial kluczowe jest obsługiwane tylko w połączeniu ref classvalue class ze słowem kluczowym lub słowem kluczowym.

Przykłady

W poniższym przykładzie zdefiniowano klasę Address w dwóch plikach kodu. Projektant modyfikuje Address.details.h element i modyfikuje Address.helement . Tylko definicja klasy w pierwszym pliku używa słowa kluczowego 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(); }
};

Zobacz też

System typów
Dokumentacja języka C++/CX
Dokumentacja przestrzeni nazw