Bevezetés a C tároló osztályokba
Minden értéket vagy számot valahol el kell tárolni a későbbi felhasználáshoz, igaz? Ezt meg lehet tenni a C. változóival. A változók a programjainkban használt tároló területek. Minden változó egy meghatározott típusú, például egész szám, karakter, és típusuktól függően is lesz meghatározott méretük és elrendezésük. Minden egyes változót a memória meghatározott részében kell tárolni, és korlátozott vagy meghatározott hozzáférési engedélyekkel kell rendelkezni. A C tárolóosztályok határozzák meg, hogy a memória melyik részét tárolja az egyes változókat, és meghatározza a változó hatókörét (láthatóságát). Négy típusú tárolási osztály létezik: automatikus, külső, statikus és regisztrált. Egy változóval együtt említhető egy tároló-specifikátor.
Tárolási osztályok típusai C-ben
A C tárolóosztályok típusai a következők
1. Automatikus tárolási osztály
A függvényben vagy blokkban deklarált összes változót alapértelmezés szerint automatikus specifikátorban tárolják, még akkor is, ha nincs kifejezetten meghatározva. Ennek a tárolási osztálynak a meghatározója az 'auto'. Az automatikus tárolási osztályban a változók hatóköre vagy láthatósága a meghatározott blokkhoz vagy funkcióhoz lokális. A változót megsemmisítjük, ha kijutunk a funkcióból vagy a blokkból.
Ez jobban magyarázható egy példával. Vegyük figyelembe az alábbi példát:
Kód:
int main() (
int i = 2;
( int i = 4;
printf(“%d\n”, i);
)
printf(“%d\n”, i);
)
Kimenet:
4
2
Ebben az esetben az egész típusú I változót deklarálják először, és hozzárendelt 2-es értékkel rendelkezik. Ezután egy hurokban vagy blokkban ismét ugyanazon egész típusú I. változót deklaráljuk, a hozzárendelt 4-es értékkel. Ha a tároló-specifikátort nem említik, akkor alapértelmezés szerint automatikusan veszi fel. Az első printf utasításban, amelyet a blokkban megemlítenek, 4 lesz az I érték kinyomtatásakor, míg a második printf utasításban, amelyet a blokkon kívül említenek, az I értékét 2-ként nyomtatja, az a külső a háztömb. Jobb, ha valamilyen értéket inicializál az automatikus változókhoz, mert van esély arra, hogy bármilyen szemétértéket megkapjon, ha az inicializálás még nem történt meg. Ez a példa világos képet ad az automatikus változókról és a helyi hatókörről.
2. Regisztrálja a Tárolási osztályt
A nyilvántartás-tároló osztályban tárolt változóknak szintén helyi hatókörük lesz, azaz azok csak abban a blokkban érhetők el vagy láthatók, amelyben deklarálják. Ez a tárolás hasonló az automatikushoz, de a fő különbség az, hogy az automatikus változókat a memóriában tárolják, míg a regiszter változóit a CPU regiszterekben tárolják. Ez akkor történik, ha nagyon gyakran akarjuk elérni a változót. Ezek gyorsabban felhasználhatók. Csak néhány változót tárolnak a regiszter-meghatározókkal. Ha nincs hely a regisztrációban, akkor csak a memóriában tárolja. A regiszter változóinak nem adnak ki kezdeti értéket. Ezenkívül a & (cím) operátor nem használható a regiszter változóin. Például azokat a változókat, amelyeket a számlálókhoz vagy hasonló felhasználási típusokhoz használnak, regiszter-specifikátorral tároljuk.
3. Statikus tárolási osztály
A változót, legyen az globális vagy helyi, statikus specifikátorral tároljuk statikus tárolási osztályban, amikor a változót egyszer deklarálni kell, és az értéket meg kell őrizni. Ha egy változót statikusnak nyilvánítanak, akkor az érték mentésre kerül vagy megmarad a funkcióhívások között. Állandó tároló jön létre, és csak egyszer jelenik meg. Ha egy helyi változót statikusnak nyilvánítanak, akkor állandó tároló jön létre számára, és az értéket minden alkalommal megőrzik. A szokásos helyi változó hatóköre szerint a statikus helyi változók csak arra a funkcióra vagy blokkra láthatók, ahol azt definiálják. Ha egy globális változó statikusnak van nyilvánítva, hasonlóan a statikus lokálishoz, akkor állandó tároló jön létre, és csak egyszer jelenik meg. De bár globálisak, ezek a változók csak abban a fájlban láthatók, amelyben meg vannak határozva.
A statikus változók egyértelműen ábrázolhatók az alábbi példa segítségével:
Kód:
int samplefunc() (
static int a = 0;
a = a+2;
return a;
)
int main() (
int result1 = samplefunc();
int result2 = samplefunc();
printf("%d\n", result1);
printf("%d\n", result2);
)
Kimenet:
2
4
Itt, a fenti programban, amikor a mintafunc () meghívásra kerül, az a változót meghatározzuk és inicializáljuk, és állandó tárolót hozunk létre számára. A függvényben alkalmazott matematikai kifejezés alapján az a értéke 2-nek lesz. De amikor ugyanazt a mintafunc-ot () másodszor hívják, az a változót nem definiálják, vagy nem inicializálják, inkább az utolsó megtartott értéket veszi és folytatja a művelettel. a végső eredményt 4-ként állítjuk elő. Ez a statikus változók fő felhasználása és előnye.
4. Külső tárolási osztály
A külsőként deklarált változó azt jelzi, hogy a változót egy másik program máshol definiálták. Ezeket a külső változókat akkor használjuk, ha azt akarjuk, hogy az egyik programban definiált bármely változó vagy függvény egy másik fájlban is felhasználásra kerüljön. A külső meghatározóval rendelkező változókat a külső tárolási osztályban tároljuk. Amikor a változót programként deklarálják, mint külső, akkor meghatározza a külső összeköttetést, és ezért nem határozza meg, vagy nem inicializálja újra. A tároló csak egynek van kiosztva, és csak egyszer inicializálódik. Ha a külső változókat egy másik értékkel inicializáljuk a külső programban, akkor hibaüzenetet kapunk, amely a következőt tartalmazza: „A változó újradefiniálása”.
A külső változókat az alábbi példa magyarázza:
Kód:
Prg1.c
int count;
int main() (
count = 10;
)
Prg2.c
extern int count;
int main() (
printf(“%d”, count);
)
Kimenet:
10
Itt az egész változó számát az első C programban deklaráljuk (Prg1.c), és a fő funkción belül 10-re inicializáljuk. A második C programban ugyanazt a számváltozót deklaráljuk külső specifikátorral, amely meghatározza, hogy van külső kapcsolat, és az érték lekérésre kerül a tárolóból, és a 10-es érték adódik az értékszámhoz, amikor a második programban kinyomtatjuk. Ez a külső változók használata. Így, a különböző céltól függően, az egyes tárolási osztályokat a megfelelő változókhoz használják, és a megfelelő specifikátorokkal deklarálják.
Ajánlott cikkek
Ez egy útmutató a C tároló osztályokhoz. Itt tárgyaljuk a tárolási osztályok típusait, amelyek magukban foglalják az automatikus tárolási osztályt, a regisztrációs tárolási osztályt, a statikus tárolási osztályt és a külső tárolási osztályt. A következő cikkeket is megnézheti további információkért -
- Mi a JavaBeans?
- ES6 vs ES5
- C ++ vs Visual C ++
- C vs C ++ teljesítmény