Classes partielles (C++/CX)

Article
10/12/2023

Une classe partielle est une construction qui prend en charge les scénarios dans lesquels vous modifiez une partie d'une définition de classe et un logiciel de génération de code automatique, par exemple le concepteur XAML, modifie également le code de la même classe. L'utilisation d'une classe partielle vous permet d'empêcher le concepteur de remplacer votre code. Dans un projet Visual Studio, le modificateur partial est appliqué automatiquement au fichier généré.

Syntaxe

Pour définir une classe partielle, utilisez le mot clé partial immédiatement avant la clé-classe de ce qui devrait être une définition de classe normale. Un mot clé comme partial ref class est un mot clé contextuel qui contient des espaces blancs. Les définitions partielles sont prises en charge dans les constructions ci-dessous.

class ou struct
ref class ou ref struct
value class ou value struct
enum ou enum class
ref interface, interface class, interface struct, ou __interface
union

L'exemple suivant illustre une ref classpartielle :

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

Contenu

Une définition de classe partielle peut contenir tout ce que la définition de classe complète peut contenir si le mot clé partial a été omis. Sauf une exception, cela inclut toutes les constructions valides, telles que les classes de base, les données membres, les fonctions de membre, les énumérations, les déclarations Friend et les attributs. Les définitions inline des données membres statiques sont autorisées.

L'unique exception est l'accessibilité de la classe. Par exemple, l'instruction public partial class MyInvalidClass {/* ... */}; est une erreur. Aucun spécificateur d'accès utilisé dans une définition de classe partielle pour MyInvalidClass n'affecte l'accessibilité par défaut dans une définition de classe partielle ou complète suivante pour MyInvalidClass.

Le fragment de code suivant illustre cette accessibilité. Dans la première classe partielle, Method1 est publique car son accessibilité est publique. Dans la deuxième classe partielle, Method2 est privée car l'accessibilité de la classe est par défaut privée.

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

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

Déclaration

Une définition partielle d’une classe telle que MyClass n’est qu’une déclaration de MyClass. Autrement dit, il introduit uniquement le nom MyClass. MyClass ne peut pas être utilisé d’une manière qui nécessite une définition de classe, par exemple, connaître la taille ou l’utilisation d’une MyClass base ou d’un membre de MyClass. MyClass est considéré comme étant défini uniquement lorsque le compilateur rencontre une définition non partielle de MyClass.

L'exemple ci-dessous illustre le comportement de déclaration d'une classe partielle. Après la déclaration n°1, MyClass peut être utilisé comme s’il a été écrit comme déclaration de transfert, ref class MyClass;. La déclaration n°2 équivaut à la déclaration #1. La déclaration n°3 est valide, car il s’agit d’une déclaration de transfert à une classe. Mais la déclaration n°4 n'est pas valide car

MyClass n’est pas entièrement défini.

La déclaration n°5 n’utilise pas le partial mot clé et la déclaration définit MyClassentièrement . Par conséquent, la déclaration #6 est valide.

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

Nombre et classement

Il peut y avoir zéro définition de classe partielle ou plus pour chaque définition de classe complète.

Chaque définition de classe partielle d'une classe doit précéder lexicalement la seule définition complète de cette classe, mais ne doit pas précéder les déclarations anticipées de cette classe. S'il n'existe aucune définition complète de la classe, les déclarations de classe partielles ne peuvent être que des déclarations anticipées.

Toutes les clés-classe comme class et struct doivent concorder. Par exemple, c’est une erreur de coder partial class X {}; struct X {};.

L'exemple suivant illustre le nombre et le classement. La dernière déclaration partielle échoue car la classe est déjà définie.

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.

Définition complète

Dans la phase de définition complète de la classe X, le comportement est identique comme si la définition de X a déclaré toutes les classes de base, les membres, etc., dans l'ordre dans lequel ils ont été rencontrés et définis dans les classes partielles. En d'autres termes, le contenu des classes partielles est traité comme s'il a été écrit dans la phase de définition complète de la classe, et la recherche de nom et d'autres règles de langage sont appliquées dans la phase de définition complète de la classe comme si le contenu des classes partielles a été écrit à ce moment

Les deux exemples de code ci-dessous ont une signification et un effet identiques. Le premier exemple utilise une classe partielle et le deuxième exemple ne le fait pas.

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

};

Modèles

Une classe partielle ne peut pas être un modèle.

Restrictions

Une classe partielle ne peut pas s'étendre au-delà d'une unité de traduction.

Le mot clé partial est pris en charge uniquement en association avec le mot clé ref class ou value class .

Exemples

L'exemple suivant définit la classe Address pour deux fichiers de code. Le concepteur modifie Address.details.h et vous modifiez Address.h. Seule la définition de classe contenue dans le premier fichier utilise le mot clé 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(); }
};

Voir aussi

Système de type
Informations de référence sur le langage C++/CX
Référence aux espaces de noms

Partage via