class property specifiers (since C++26)

Spécifie qu'une classe est remplaçable ( replaceable_if_eligible ), trivialement relogeable ( trivially_relocatable_if_eligible ), ou qu'une classe ne peut pas être dérivée ( final ).

Syntaxe

Spécificateurs de propriété de classe apparaissent au début de la définition de la classe, immédiatement après le nom de la classe, et ne peuvent pas apparaître dans une déclaration de classe.

Avant (C++26) , il y avait le class-virt-specifier  (optionnel) à la place de class-prop-specifier-seq  (optionnel) , qui ne permettait que le final pour final specifier (depuis C++11) .

Explication

final , replaceable_if_eligible et trivially_relocatable_if_eligible sont des identifiants ayant une signification particulière lorsqu'ils sont utilisés dans l'en-tête d'une classe. Dans d'autres contextes, ils ne sont pas réservés et peuvent être utilisés pour nommer des objets et des fonctions.

final spécificateur

final spécifie que cette classe ne peut pas apparaître dans la base-specifier-list d'une autre définition de classe (en d'autres termes, ne peut pas être dérivée). Le programme est mal formé dans le cas contraire (une erreur de compilation est générée). final peut également être utilisé avec une définition union , auquel cas il n'a aucun effet (autre que sur le résultat de std::is_final ) (depuis C++14) , car les unions ne peuvent pas être dérivées.

replaceable_if_eligible spécificateur

replaceable_if_eligible spécifie que cette classe est remplaçable  si elle est éligible au remplacement  .

trivially_relocatable_if_eligible spécificateur

trivially_relocatable_if_eligible spécifie que cette classe est trivialement relogeable  si elle est éligible pour la relocation triviale  .

Remplaçabilité

Une classe C est remplaçable  si elle est éligible au remplacement  et soit :

• a le replaceable_if_eligible class-prop-specifier
• est une union sans fonctions membres spéciales déclarées par l'utilisateur
• est default movable  .

Admissibilité au remplacement

Une classe C est éligible au remplacement sauf si l'une des conditions suivantes est remplie :

• il a une classe de base qui n'est pas une classe remplaçable 
• il a un membre de données non statique qui n'est pas d'un type remplaçable 
• la résolution de surcharge échoue ou sélectionne un constructeur supprimé lors de l' initialisation directe d'un objet de type C à partir d'une xvalue de type C
• la résolution de surcharge échoue ou sélectionne une fonction d'opérateur d'affectation supprimée lors de l'affectation à une lvalue de type C à partir d'une xvalue de type C
• il a un destructeur supprimé .

Relocalisation triviale

Une classe est trivialement relogeable  si elle est éligible à la relocation triviale  et soit :

• possède le trivially_relocatable_if_eligible class-prop-specifier
• est une union sans fonctions membres spéciales déclarées par l'utilisateur special member functions
• est default movable  .

Éligibilité pour la relocation triviale

Une classe est éligible pour la relocation triviale  sauf si elle possède l'une des caractéristiques suivantes :

• toute classe de base virtuelle
• une classe de base qui n'est pas une classe trivialement relogeable 
• un membre de données non statique d'un type objet qui n'est pas d'un type trivialement relogeable 
• un destructeur supprimé

sauf qu'il est défini par l'implémentation si une union autrement éligible ayant un ou plusieurs sous-objets de type classe polymorphe est éligible pour la relocation triviale  .

Mobilité par défaut

Une classe C est déplaçable par défaut si toutes les conditions suivantes sont remplies :

• la résolution de surcharge pour l'initialisation directe d'un objet de type C à partir d'une xvalue de type C sélectionne un constructeur qui est un membre direct de C et qui n'est ni fourni par l'utilisateur ni supprimé
• la résolution de surcharge pour l'affectation à une lvalue de type C à partir d'une xvalue de type C sélectionne une fonction d'opérateur d'affectation qui est un membre direct de C et qui n'est ni fournie par l'utilisateur ni supprimée
• C a un destructeur qui n'est ni fourni par l'utilisateur ni supprimé.

Mots-clés

final , replaceable_if_eligible , trivially_relocatable_if_eligible .

Remarque

• Toutes les classes TriviallyCopyable ne sont pas remplaçables  ou trivialement relogeables  .
• L' accessibilité des fonctions membres spéciales n'est pas prise en compte lors de l'établissement de la relogeabilité triviale  ou de la remplaçabilité  .
• Une classe avec des membres de données non statiques qualifiés const ou de type référence peut être trivialement relogeable  .
• Les union s sans fonctions membres spéciales déclarées par l'utilisateur et les classes déplaçables par défaut  sont à la fois remplaçables  et trivialement relogeables  , même lorsqu'elles sont définies sans spécificateurs de propriété de classe.

Exemple

struct final;      // OK; déclare une classe nommée 'final',
                   // n'utilise pas les spécificateurs de propriété de classe.
struct IF final;   // Mal formé : les spécificateurs de propriété de classe
                   // ne peuvent pas apparaître dans la déclaration de fonction.
struct F final {}; // OK; le spécificateur marque la classe F comme non dérivable.
struct D: F {};    // Mal formé : la classe F ne peut pas être dérivée.
// OK; le spécificateur marque la classe R comme 𝘳𝘦𝘮𝘱𝘭𝘢ç𝘢𝘣𝘭𝘦 si éligible.
struct R replaceable_if_eligible {};
// OK; le spécificateur marque la classe T comme 𝘵𝘳𝘪𝘷𝘪𝘢𝘭𝘦𝘮𝘦𝘯𝘵 𝘳𝘦𝘭𝘰𝘤𝘢𝘵𝘢𝘣𝘭𝘦 si éligible.
struct T trivially_relocatable_if_eligible {};
// OK; une classe peut être marquée avec plusieurs spécificateurs de propriété de classe.
struct FRT final replaceable_if_eligible trivially_relocatable_if_eligible {};
// Mal formé : chaque spécificateur de propriété de classe ne peut apparaître qu'une seule fois.
struct FRF final replaceable_if_eligible final {};
int main() {}

Références

Voir aussi