Legjobb válasz
Ne keverje össze a típust (például int) a deklarációk egyéb vonatkozásaival (pl. egy tárolási osztály, például static).
Vagyis:
int x;
static int y;
x és y típusa azonos, int (a „ data típus” kifejezés a C és a C ++ nyelven ritkábban használják; ez azért nem baj).
A static kulcsszónak három különböző jelentése van C-ben. A fenti példában azt jelzi hogy a y változó „privát” az adott fordítási egységhez (mivel a fordítási egység minden #include irányelv után forrásfájlnak tekinthető feldolgozták). Tehát egy másik fordítási egységben deklarált y változó különbözik ettől.
Íme egy példa a static C-ben:
void f() {
static int n = 2;
...
}
Ez a statikus azt jelenti, hogy a megosztva van a f() összes meghívása között, és a f() visszatérése után is fennáll (lehet, pl. mutasson vissza rá mutatót). A n inicializálása 2 fájlra csak a program indítása előtt történik a C-ben (a első f() meghívásában a C ++ -ban). Tehát a f() második (és későbbi) idő meghívásra kerül, a n megtartja az előbbi értéket (amíg a program ezt kifejezetten módosítja) ).
A harmadik jelentés kevésbé gyakori (és azt hiszem, kevésbé ismert):
void g(double x[static 5]) {
...
}
Ez azt jelzi, hogy g() csak a tömbképzésben lévő legalább 5 double érték első mutatójával hívható meg.
SZERKESZTÉS: A helyi javításának magyarázata statikus inicializálás as (lásd Jesse Pollard megjegyzését).
Válasz
A statikus a dinamika ellentéte. Mi? Ez azt jelenti, hogy az adott változó számára lefoglalt memória nem mozog a memóriában. Ez azt is jelenti, hogy az adott változóhoz hozzáférő függvények ismételt hívásakor a változó új árnyékmásolatai nem jönnek létre; az eredeti változót használják, és bármely más, a változóhoz ezen a címen hozzáférő funkció módosíthatja vagy elolvashatja. Ez önmagában nem globális változó; hatálya ugyanaz marad, mint ahol és hogyan definiálták. Pedig lehet. Hiba lenne azonban megpróbálni meghatározni egy másik, azonos nevű statikus változót ugyanabban a fájlban, vagy pedig egy alkalmazásban.
Fontoljon meg egy egyszerű C add funkciót:
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;
}
a statikus értékek. Ez azt jelenti, hogy a beléjük helyezett értékek több felvételi hívás során is megmaradnak. A számlálást és az utolsó értéket nullára inicializáljuk, de ezután nem nullázzuk újra minden híváskor. Figyelje meg, hogy a számlálás és az last hatóköre csak a add függvényen belül található. Előfordulhat, hogy nem osztják meg más funkciókkal, és nem érhetők el az add hozzáadáson kívül, így ahhoz, hogy hozzájuk férjen, a funkció belsejéből kell kinyomtatnia őket. Más funkcióknak azonos lehet a számlálásuk és az utolsó statikus változataik, és soha nem lépnek kölcsönhatásba.
Most nézze meg ezt a tesztprogramot:
#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;
}
Három statikus változó három halmaza számít és utolsó; mindegyik külön. Először a globálisok vannak, itt soha nem használják őket. Az main saját halmaza van, amelyet azért használ, mert lokális varsai árnyékolják a globálisokat. A add saját halmaza van, amely a fő és a globális elemeket egyaránt azonos árnyékkal látja el.
Statikus függvénydefiníciók egy másfajta dolog. A statikus szó azt jelzi, hogy a függvény csak abban a fájlban látható, amely abból a forrásból van összeállítva, ahol a függvény meg van határozva. Ez vagy a forrás (“.c”) fájl, vagy a fejléc (“.h) fájlt tartalmaz. Erre akkor lehet szükség, ha az Ön által használt objektumfájloknak több, azonos nevű függvény-verziója van (például hozzáadás, nyomtatás, hiba stb.), Így az objektumfájlok kombinálása („. O”) mint modulok együttesen nem okoznak ütközést.