Beste antwoord
Verwar een type niet (zoals int) met andere aspecten van declaraties (bijv. een opslagklasse zoals static).
Dat wil zeggen, in:
int x;
static int y;
x en y hebben hetzelfde type, int (de term “ data type” wordt minder vaak gebruikt in C en C ++; het is echter niet verkeerd).
Het trefwoord static heeft drie verschillende betekenissen in C. In het bovenstaande voorbeeld geeft het aan die variabele y is “privé” voor die specifieke vertaaleenheid (aangezien de vertaaleenheid kan worden gezien als een bronbestand na alle #include instructies zijn verwerkt). Dus een variabele y die in een andere vertaaleenheid wordt gedeclareerd, verschilt van deze.
Hier is een voorbeeld van de tweede betekenis van static in C:
void f() {
static int n = 2;
...
}
Deze statische betekenis betekent dat variabele n wordt gedeeld door alle aanroepen van f() en blijft bestaan, zelfs nadat f() terugkeert (je zou kunnen, bijvoorbeeld een pointer ernaar terugsturen). De initialisatie van n naar 2 vindt alleen plaats voordat het programma wordt opgestart in C (op de eerste aanroep van f() in C ++). Dus de tweede (en latere) tijd f() wordt aangeroepen, n zal de waarde behouden die het eerder had (totdat het programma deze expliciet opnieuw wijzigt ).
De derde betekenis is minder gebruikelijk (en, denk ik, minder bekend):
void g(double x[static 5]) {
...
}
Dit geeft aan dat g() kan alleen worden aangeroepen met een pointer naar de eerste van ten minste 5 double waarden in arrayopstelling.
EDIT: Vaste uitleg van lokale statische initialisatie als (zie de opmerking van Jesse Pollard).
Antwoord
Statisch is het tegenovergestelde van dynamisch. Huh? Het betekent dat het geheugen dat voor die variabele is toegewezen, niet in het geheugen wordt verplaatst. Het betekent ook dat bij herhaalde aanroepen van functies die toegang hebben tot die variabele, geen nieuwe schaduwkopieën van de variabele worden gemaakt; de originele variabele wordt gebruikt, en elke andere functie die toegang heeft tot die variabele op dat adres kan deze wijzigen of lezen. Het is niet per se een globale variabele; het bereik blijft hetzelfde als waar en hoe het werd gedefinieerd. Het zou wel kunnen. Het zou echter een fout zijn om te proberen een andere statische variabele met dezelfde naam te definiëren in hetzelfde bestand of een variabele die is opgenomen in een toepassing.
overweeg een eenvoudige C add-functie:
int add(int a, int b)
{
static int count = 0;
static int last = 0;
count++;
last = a + b;
printf( "a:\t\%d \t\t b:\t\%d\n", a, b );
printf( "count:\t\%d \t\t last:\t\%d\n", count, last)
return last;
}
aantal en laatste zijn statisch gedefinieerd. Dat betekent dat de waarden die erin zijn ingevoerd, blijven bestaan tijdens meerdere aanroepen om toe te voegen. count en last worden op nul geïnitialiseerd, maar worden niet bij elke oproep opnieuw op nul gezet. Merk op dat het bereik van count en last alleen binnen de functie add vallen. Ze worden mogelijk niet gedeeld met andere functies of zijn toegankelijk buiten add, dus om ze te bereiken, moet u ze vanuit de functie afdrukken. Andere functies zouden ook een identiek aantal en laatste statische variabelen kunnen hebben en zouden nooit samenwerken.
Bekijk nu dit testprogramma:
#include
static int count = 5;
static int last = 0;
int add(int a, int b)
{
static int count = 0;
static int last = 0;
count++;
last = a + b;
printf( "a:\t\%d \t\t b:\t\%d\n", a, b );
printf( "count:\t\%d \t\t last:\t\%d\n", count, last)
return last;
}
int main(int argc, char**argv )
{
static int count = 10;
static int last = 0;
int i;
int a=1, b=1;
for(i = 0 ; i < count ; i++)
{
a = add(a, b);
b = add(a, last);
last = add(a, b);
}
printf( "a:\t\%d \t\t b:\t\%d\n", a, b );
printf( "count:\t\%d \t\t last:\t\%d\n", count, last);
return 0;
}
Drie zijn 3 sets statische variabelen tellen en laatste; ze zijn allemaal gescheiden. De eerste zijn de globals, ze worden hier nooit gebruikt. main heeft zijn eigen set die het gebruikt omdat zijn lokale variabelen de globals overschaduwen. add heeft zijn eigen set die schaduw geeft aan zowel de hoofd- als de globals met dezelfde naam.
Statische functiedefinities zijn iets anders. Het woord statisch geeft aan dat de functie alleen zichtbaar is in het bestand dat is gecompileerd vanuit de bron waar de functie is gedefinieerd. Dit is ofwel het bronbestand (".c") of een koptekst (".h) bestand dat erin is opgenomen. Dit kan nodig zijn als de objectbestanden die u gebruikt meer dan één versie van een functie met dezelfde naam hebben (zoals add, print, error, ...) zodat het combineren van objectbestanden (". O") samen als modules veroorzaken geen botsingen tussen namen.