KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

static — blijvende toestand, interne koppeling en klassenleden

De betekenis van static hangt af van de plaats van de declaratie: een lokale variabele behoudt zijn toestand tussen aanroepen, een naam op naamruimteniveau krijgt interne koppeling en een klassenlid vereist geen aparte kopie in elk object. Opslagduur, bereik en koppeling zijn verschillende begrippen.

Versie: C++23; repository compiler flag, production runtime not attested

Syntax

static T name = initializer;
static R function(parameters);
struct C {
    inline static T member = initializer;
    static R method(parameters);
};

Binnen een blok declareert static T name = initializer; een variabele met statische opslagduur: de opslag blijft bestaan gedurende de hele uitvoering van het programma, maar de naam blijft lokaal. De toestand verdwijnt niet wanneer de functie terugkeert. Met thread_local is de opslagduur in plaats daarvan aan de thread gekoppeld.

Dynamische initialisatie van een lokale static-variabele vindt plaats wanneer de uitvoering voor het eerst langs de declaratie komt; constante initialisatie kan eerder plaatsvinden. Gelijktijdige toegang wacht tot de initialisatie is voltooid. Na een uitzondering probeert de volgende toegang de initialisatie opnieuw; recursieve toegang tijdens de initialisatie leidt tot ongedefinieerd gedrag. Deze bescherming synchroniseert latere waardewijzigingen niet.

Op naamruimteniveau geeft static een variabele- of functienaam interne koppeling: de naam verwijst naar een entiteit binnen die vertaaleenheid. Een definitie in een header die door meerdere vertaaleenheden wordt opgenomen, maakt afzonderlijke entiteiten aan. Verwar dit niet met opslagduur: ook een gewone variabele op naamruimteniveau heeft statische opslagduur zonder static, tenzij deze thread_local is.

In een klasse is een static-gegevenslid geen subobject van elke instantie; zonder thread_local delen objecten één lid. inline static maakt het mogelijk dit binnen de klasse te definiëren. Een niet-inline-lid dat op een manier wordt gebruikt waarvoor een definitie nodig is (odr-use), vereist ook een definitie buiten de klasse. Een static-lidfunctie heeft geen this, kan worden aangeroepen als C::method() en heeft een object nodig om toegang te krijgen tot niet-statische gegevensleden. De functie kan niet virtual zijn en kan niet met const of volatile worden gekwalificeerd.

Het voorbeeld combineert drie toepassingen: next_id heeft interne koppeling, value behoudt de teller en Counter::calls en Counter::next horen bij de klasse. Deze uitleg richt zich op C++23; de aangeleverde bron is een evoluerend werkdocument, geen vastgelegde C++23-editie.

Voorbeelden

#include <iostream>

static int next_id() {
    static int value = 0;
    return ++value;
}

struct Counter {
    inline static int calls = 0;

    static int next() {
        ++calls;
        return next_id();
    }
};

int main() {
    std::cout << Counter::next() << '\n';
    std::cout << Counter::next() << '\n';
    std::cout << Counter::calls << '\n';
}

Resultaat

1
2
2

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen