static members

• 1 Syntaxe
• 2 Explication
  • 2.1 Fonctions membres statiques
  • 2.2 Membres de données statiques
  • 2.3 Membres statiques constants
• 3 Mots‑clés
• 4 Rapports de défauts
• 5 Références
• 6 Voir aussi

Syntaxe

Une déclaration pour un membre statique est une déclaration de membre dont les spécificateurs de déclaration contiennent le mot‑clé static. Le mot‑clé static apparaît habituellement avant les autres spécificateurs (c’est pourquoi la syntaxe est souvent décrite de manière informelle comme static member-declaration), mais peut apparaître n’importe où dans la séquence de spécificateurs.

Le nom de tout membre de données statique et de toute fonction membre statique doit être différent du nom de la classe conteneur.

Explication

Les membres statiques d'une classe ne sont pas associés aux objets de la classe : ce sont des variables indépendantes avec une durée de stockage statique (depuis C++11) ou thread ou des fonctions régulières.

Le mot-clé static est uniquement utilisé avec la déclaration d'un membre statique, à l'intérieur de la définition de la classe, mais pas avec la définition de ce membre statique :

class X { static int n; }; // déclaration (utilise 'static')
int X::n = 1;              // définition (n'utilise pas 'static')

La déclaration à l'intérieur du corps de la classe n'est pas une définition et peut déclarer le membre comme étant de type incomplet (autre que void ), y compris le type dans lequel le membre est déclaré :

struct Foo;
struct S
{
    static int a[]; // déclaration, type incomplet
    static Foo x;   // déclaration, type incomplet
    static S s;     // déclaration, type incomplet (dans sa propre définition)
};
int S::a[10]; // définition, type complet
struct Foo {};
Foo S::x;     // définition, type complet
S S::s;       // définition, type complet

Pour faire référence à un membre statique m de la classe T , deux formes peuvent être utilisées : le nom qualifié T::m ou l'expression d'accès membre E.m ou E->m , où E est une expression qui s'évalue respectivement en T ou T* . Lorsqu'on se trouve dans la même portée de classe, la qualification n'est pas nécessaire :

struct X
{
    static void f(); // déclaration
    static int n;    // déclaration
};
X g() { return X(); } // une fonction retournant X
void f()
{
    X::f();  // X::f est un nom qualifié de fonction membre statique
    g().f(); // g().f est une expression d'accès membre se référant à une fonction membre statique
}
int X::n = 7; // définition
void X::f() // définition
{
    n = 1; // X::n est accessible simplement comme n dans cette portée
}

Les membres statiques respectent les règles d'accès aux membres de classe (private, protected, public) .

Fonctions membres statiques

Les fonctions membres statiques ne sont associées à aucun objet. Lorsqu'elles sont appelées, elles n'ont pas de this pointeur.

Les fonctions membres statiques ne peuvent pas être virtual , const , volatile , ou ref-qualified .

L'adresse d'une fonction membre statique peut être stockée dans un pointeur vers fonction ordinaire, mais pas dans un pointeur vers fonction membre .

Les membres de données statiques

ne sont associés à aucun objet. Ils existent même si aucun objet de la classe n'a été défini. Il n'y a qu'une seule instance du membre de données statique dans tout le programme avec une statique durée de stockage, à moins que le mot-clé thread_local ne soit utilisé, auquel cas il y a un tel objet par thread avec une durée de stockage de thread(depuis C++11).

Les membres de données statiques ne peuvent pas être mutable.

Les membres de données statiques d'une classe dans la portée d'un espace de noms ont une liaison externe si la classe elle-même a une liaison externe (n'est pas un membre de espace de noms anonyme). Les classes locales (classes définies à l'intérieur de fonctions) et les classes anonymes, y compris les classes membres de classes anonymes, ne peuvent pas avoir de membres de données statiques.

struct X
{
    inline static int fully_usable = 1; // No out-of-class definition required,
                                        // ODR-usable
    inline static const std::string class_name{"X"}; // Likewise

    static const int non_addressable = 1; // C.f. non-inline constants, usable
                                          // for its value, but not ODR-usable
    // static const std::string class_name{"X"}; // Non-integral declaration of this
                                                 // form is disallowed entirely
};

Membres statiques constants

Si un membre de données statique de type intégral ou énumération est déclaré const (et non volatile ), il peut être initialisé avec un initialiseur dans lequel chaque expression est une expression constante , directement à l'intérieur de la définition de la classe :

struct X
{
    const static int n = 1;
    const static int m{2}; // depuis C++11
    const static int k;
};
const int X::k = 3;

struct X
{
    constexpr static int arr[] = { 1, 2, 3 };        // OK
    constexpr static std::complex<double> n = {1,2}; // OK
    constexpr static int k; // Error: constexpr static requires an initializer
};

Si un membre de données statique const non inline (depuis C++17) ou un membre de données statique constexpr (depuis C++11) (jusqu'à C++17) est ODR-use , une définition au niveau de la portée de l'espace de noms est toujours requise, mais elle ne peut pas avoir d'initialiseur.

struct X
{
    static const int n = 1;
    static constexpr int m = 4;
};
const int *p = &X::n, *q = &X::m; // X::n et X::m sont ODR-utilisés
const int X::n;             // … donc une définition est nécessaire
constexpr int X::m;         // … (sauf pour X::m en C++17)

Mots-clés

static

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.

Références

Voir aussi

• static spécificateur de stockage