final specifier (since C++11)

Spécifie qu'une fonction virtuelle ne peut pas être redéfinie dans une classe dérivée, ou qu'une classe ne peut pas être dérivée .

Syntaxe

Lorsqu'il est appliqué à une fonction membre, l'identificateur final apparaît immédiatement après le déclarateur dans la syntaxe d'une déclaration de fonction membre ou d'une définition de fonction membre à l'intérieur d'une définition de classe.

Lorsqu'il est appliqué à une classe (y compris struct et union), l'identifiant final apparaît au début de la définition de la classe, immédiatement après le nom de la classe, et ne peut pas apparaître dans une déclaration de classe.

Dans les cas (1,2) , virt-specifier-seq , si utilisé, est soit override soit final , soit final override ou override final . Dans le cas (3) , la seule valeur autorisée de class-virt-specifier , si utilisé, est final . Dans le cas (4) , la class-prop-specifier-seq , si utilisée, peut contenir n'importe quel nombre de spécificateurs de propriété de classe (depuis C++26) , mais chacun ne peut apparaître qu'au maximum une fois.

Explication

Lorsqu'il est utilisé dans une déclaration ou une définition de fonction virtuelle, final spécifie que la fonction est virtuelle et garantit qu'elle ne peut pas être redéfinie par les classes dérivées. Le programme est mal formé (une erreur de compilation est générée) dans le cas contraire.

Lorsqu'il est utilisé dans une définition de classe, 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 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.

final est un identifiant ayant une signification particulière lorsqu'il est utilisé dans une déclaration de fonction membre ou un en-tête de classe. Dans d'autres contextes, il n'est pas réservé et peut être utilisé pour nommer des objets et des fonctions.

Remarque

Dans une séquence des jetons suivants :

1. l'un des mots-clés class , struct et union
2. un identifiant éventuellement qualifié
3. final
4. l'un des symboles : et {

le troisième jeton final dans la séquence est toujours considéré comme un spécificateur plutôt qu'un identifiant.

struct A;
struct A final {}; // OK, définition de struct A,
                   // pas d'initialisation de valeur de variable final
struct X
{
    struct C { constexpr operator int() { return 5; } };
    struct B final : C{}; // OK, définition de classe imbriquée B,
                          // pas déclaration d'un membre champ de bits final
};
// Utilisation anormale de final.
struct final final // OK, définition d'une struct nommée `final` dont
{                  // on ne peut pas hériter
};
// struct final final {}; // Erreur: redéfinition de `struct final`, PAS une
                          // définition d'une variable `final` utilisant un
                          // spécificateur de type élaboré `struct final` suivi
                          // d'une initialisation d'agrégat
// struct override : final {}; // Erreur: ne peut pas dériver du type de base final;
                               // `override` dans ce contexte est un nom normal
void foo()
{
    [[maybe_unused]]
    final final; // OK, déclaration d'une variable nommée `final` de type
                 // `struct final` 
}
struct final final; // OK, déclaration d'une variable nommée `final` de type
                    // `struct final` utilisant un spécificateur de type élaboré
int main()
{
}

Mots-clés

final

Exemple

struct Base
{
    virtual void foo();
};
struct A : Base
{
    void foo() final; // Base::foo est surchargée et A::foo est la surcharge finale
    void bar() final; // Erreur : bar ne peut pas être final car elle n'est pas virtuelle
};
struct B final : A // struct B est final
{
    void foo() override; // Erreur : foo ne peut pas être surchargée car elle est final dans A
};
struct C : B {}; // Erreur : B est final

main.cpp:9:10: error: 'void A::bar()' marked 'final', but is not virtual
    9 |     void bar() final; // Erreur : bar ne peut pas être final car elle n'est pas virtuelle
      |          ^~~
main.cpp:14:10: error: virtual function 'virtual void B::foo()' overriding final function
   14 |     void foo() override; // Erreur : foo ne peut pas être surchargée car elle est final dans A
      |          ^~~
main.cpp:8:10: note: overridden function is 'virtual void A::foo()'
    8 |     void foo() final; // Base::foo est surchargée et A::foo est la surcharge finale
      |          ^~~
main.cpp:17:8: error: cannot derive from 'final' base 'B' in derived type 'C'
   17 | struct C : B // Erreur : B est final
      |

Références

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi