Teilen über

Partielle Klassen (C++/CX)

Eine partielle Klasse ist ein Konstrukt, das Szenarien unterstützt, in denen Sie einen Teil einer Klassendefinition ändern. Software, die automatisch Code generiert – beispielsweise der XAML Designer – ändert ebenfalls Code in der gleichen Klasse. Durch die Verwendung einer partiellen Klasse können Sie verhindern, dass der Designer Ihren Code überschreibt. In einem Visual Studio-Projekt wird der Modifizierer partial automatisch auf die generierte Datei angewendet.

Syntax

Um eine partielle Klasse zu definieren, verwenden Sie das Schlüsselwort partial direkt vor dem Klassenschlüssel. Andernfalls wäre dies eine normale Klassendefinition. Ein Schlüsselwort wie partial ref class ist ein Kontextschlüsselwort, das Leerzeichen enthält. Partielle Definitionen werden in den folgenden Konstrukten unterstützt.

  • class oder struct

  • ref class oder ref struct

  • value class oder value struct

  • enum oder enum class

  • ref interface, interface class, interface struct oder __interface

  • union

Dieses Beispiel zeigt eine partielle ref class:

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

Contents

Eine partielle Klassendefinition kann alles enthalten, was die vollständige Klassendefinition enthalten kann, wenn das Schlüsselwort partial ausgelassen wird. Mit einer Ausnahme schließt dies jedes gültige Konstrukt ein, z. B. Basisklassen, Datenmember, Memberfunktionen, Enumerationen, Friend-Deklarationen und Attribute. Inlinedefinitionen statischer Datenmember sind zulässig.

Die eine Ausnahme ist die Klassen-Barrierefreiheit. Beispielsweise ist die Anweisung public partial class MyInvalidClass {/* ... */}; fehlerhaft. Zugriffsspezifizierer, die in einer partiellen Klassendefinition für MyInvalidClass verwendet werden, wirken sich nicht auf die Standard-Barrierefreiheit in einer nachfolgenden partiellen oder vollständigen Klassendefinition für MyInvalidClass aus.

Das folgende Codefragment zeigt die Barrierefreiheit. In der ersten partiellen Klasse ist Method1 öffentlich, weil die Barrierefreiheit öffentlich ist. In der zweiten partiellen Klasse ist Method2 privat, weil die standardmäßige Klassenbarrierefreiheit privat ist.

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

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

Deklaration

Eine partielle Definition einer Klasse, z MyClass . B. eine Deklaration von MyClass. Das heißt, es führt nur den Namen MyClassein. MyClass kann nicht auf eine Weise verwendet werden, die eine Klassendefinition erfordert, z. B. die Größe oder MyClass Verwendung einer Basis oder eines Elements von MyClass. MyClass wird nur dann definiert, wenn der Compiler auf eine nicht partielle Definition von MyClass.

Im folgenden Beispiel wird das Deklarationsverhalten einer partiellen Klasse demonstriert. Nach der Deklaration Nr. 1 kann verwendet werden, MyClass als ob sie als Forward-Deklaration geschrieben wurde. ref class MyClass; Deklaration Nr. 2 entspricht der Deklaration #1. Deklaration #3 ist gültig, da es sich um eine Weiterleitungsdeklaration an eine Klasse handelt. Deklaration Nr. 4 ist jedoch ungültig, da

MyClass ist nicht vollständig definiert.

Deklaration #5 verwendet nicht das partial Schlüsselwort, und die Deklaration definiert MyClassvollständig. Daher ist Deklaration Nr. 6 gültig.

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

Anzahl und Reihenfolge

Es kann null oder mehr partielle Klassendefinitionen für jede vollständige Definition einer Klasse geben.

Jede partielle Klassendefinition einer Klasse muss lexikalisch der einen vollständigen Definition dieser Klasse vorausgehen, braucht jedoch Vorwärtsdeklarationen der Klasse nicht vorauszugehen. Wenn es keine vollständige Definition der Klasse gibt, können die partiellen Klassendeklarationen nur Vorwärtsdeklarationen sein.

Alle Klassenschlüssel, z. B. class und struct , müssen übereinstimmen. Beispielsweise ist der Code partial class X {}; struct X {};ein.

Das folgende Beispiel zeigt Anzahl und Reihenfolge. Bei der letzten partiellen Deklaration tritt ein Fehler auf, da die Klasse bereits definiert ist.

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.

Vollständige Definition

Zum Zeitpunkt der vollständigen Definition der Klasse ist X ist das Verhalten das Gleiche, als ob die Definition von X alle Basisklassen, Member usw. in der Reihenfolge deklariert hätte, in der sie in der partiellen Klasse gefunden und definiert wurden. Das bedeutet, dass der Inhalt der partiellen Klassen so behandelt wird, als ob er zum Zeitpunkt der vollständigen Definition der Klasse geschrieben wäre. Namenssuche und andere Sprachregeln werden zum Zeitpunkt der vollständigen Definition der Klasse angewendet, als ob der Inhalt der partiellen Klassen an dieser Stelle geschrieben wäre.

Die folgenden zwei Codebeispiele haben identische Bedeutung und Auswirkungen. Im ersten Beispiel wird eine partielle Klasse verwendet, im zweiten jedoch nicht.

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

};

Vorlagen

Eine partielle Klasse kann keine Vorlage sein.

Beschränkungen

Eine partielle Klasse kann nicht über eine Übersetzungseinheit hinausgehen.

Das Schlüsselwort partial wird nur in Verbindung mit dem Schlüsselwort ref class oder dem Schlüsselwort value class unterstützt.

Beispiele

Im folgenden Beispiel wird die Klasse Address für zwei Codedateien definiert. Der Designer ändert Address.details.h , und Sie ändern Address.h. Nur die Klassendefinition in der ersten Datei verwendet das Schlüsselwort 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(); }
};

Siehe auch

Typsystem
C++-/CX-Programmiersprachenreferenz
Referenz zu Namespaces

  • Last updated on