Tárolási osztályok C-ben: automatikus, külső, statikus, nyilvántartás (példák)

⚡ Okos összefoglaló

A C nyelvben a tárolási osztályok négy specifikátor – auto, register, static és extern – segítségével határozzák meg minden változó hatókörét, élettartamát, alapértelmezett értékét és memóriahelyét, hogy szabályozzák az adatok tárolásának helyét és a végrehajtás során eltöltött időtartamát.

  • 🗂️ Négy tárolási osztály: A C nyelv auto, register, static és extern specifikátorokat biztosít minden változó leírásához.
  • 🏠 Autó: Az alapértelmezett lokális osztály, amely a blokkjához van kötve, és egy szemét értéket tart fenn, amíg hozzá nem rendelik.
  • Regisztráció: CPU-regisztertárolást kér a gyakran használt változók, például a számlálók gyorsabb eléréséhez.
  • ♻️ Statikus: Megőrzi a változó értékét a függvényhívások között, és az első használatkor nullára állítja vissza az alapértelmezett értéket.
  • 🌐 Külső: Megoszt egy globális változót vagy függvényt több forrásfájl között anélkül, hogy újra kellene definiálni.
  • 📊 Hatály és élettartam: Minden osztály meghatározza, hogy egy változó hol látható és mennyi ideig él.

Tárolási osztályok C-ben

Mi az a tárolási osztály C-ben?

A tárolási osztály egy változó láthatóságát és helyét jelenti. Megmondja, hogy a kód mely részéből érhetünk el egy változót. A C-beli tárolási osztály a következő dolgok leírására szolgál:

  • A változó hatókör.
  • A változó tárolási helye.
  • Egy változó inicializált értéke.
  • Egy változó élettartama.
  • Ki férhet hozzá egy változóhoz?

Így egy tárolási osztályt használnak a változóval kapcsolatos információk megjelenítésére.

MEGJEGYZÉS: Egy változó nem csak egy változóhoz kapcsolódik. adattípus, értéke, hanem egy tárolási osztály is.

Milyen típusú tárolási osztályok vannak a C-ben?

Összesen négyféle szabványos tárolási osztály létezik. Az alábbi táblázat a tárolási osztályokat mutatja C-ben.

Tárolási osztály Cél
auto Ez egy alapértelmezett tárolási osztály.
külső Ez egy globális változó.
statikus Ez egy helyi változó, amely akkor is képes értéket visszaadni, ha a vezérlést a függvényhívásra adjuk át.
Regisztráció Ez egy változó, amelyet egy regiszterben tárolnak.

Automatikus tárolási osztály C-ben

Az automatikus tárolási osztály használatával definiált változókat helyi változóknak nevezzük. Az Auto az automatikus tárolási osztályt jelenti. Egy változó alapértelmezés szerint az automatikus tárolási osztályba tartozik, ha nincs kifejezetten megadva.

Az automatikus változó hatóköre csak az adott blokkra korlátozódik. Amint a vezérlő kilép a blokkból, a hozzáférés megsemmisül. Ez azt jelenti, hogy csak az a blokk férhet hozzá, amelyben az auto változó deklarálva van.

Az auto kulcsszó az automatikus tárolási osztály meghatározására szolgál. Alapértelmezés szerint az automatikus változó szemét értéket tartalmaz.

Example, auto int age;

Az alábbi program két lokális változóval rendelkező függvényt határoz meg

int add(void) {
   int a=13;
   auto int b=48;
return a+b;}

Vegyünk egy másik programot, amely megmutatja az egyes blokkkódokban lévő automatikus változók hatóköri szintű „láthatósági szintjét”, amelyek egymástól függetlenül vannak:

#include <stdio.h>
int main( )
{
  auto int j = 1;
  {
    auto int j= 2;
    {
      auto int j = 3;
      printf ( " %d ", j);
    }
    printf ( "\t %d ",j);
  }
  printf( "%d\n", j);}

output:

 3 2 1

Külső tárolási osztály C-ben

Extern a külső tárolási osztályt jelöli. A külső tárolási osztályt akkor használjuk, ha globális függvényeink vagy változóink vannak megosztva két vagy több fájl között.

Az extern kulcsszó egy globális változó vagy függvény deklarálására szolgál egy másik fájlban, hogy megadja az eredeti fájlban már definiált változó vagy függvény hivatkozását.

Az extern kulcsszóval definiált változókat globális változóknak nevezzük. Ezek a változók a program egészében elérhetők. Figyelje meg, hogy a külső változót nem lehet inicializálni, mert az eredeti fájlban már definiálva van.

Example, extern void display();

Első fájl: main.c

#include <stdio.h>
extern i;
main() {
   printf("value of the external integer is = %d\n", i);
   return 0;}

Második fájl: original.c

#include <stdio.h>
i=48;

Eredmény:

 value of the external integer is = 48

A fenti kód lefordításához és futtatásához kövesse az alábbi lépéseket

1. lépés) Hozz létre egy új projektet,

  • Válassza a Konzolalkalmazás lehetőséget
  • Kattintson a Go-ra

Új projekt létrehozása itt: Code Blocks

2. lépés) Válassza a C lehetőséget, majd kattintson a Tovább gombra

C nyelv kiválasztása

3. lépés) Kattintson a Tovább gombra

Kattintson a Tovább gombra

4. lépés) Adja meg az adatokat, majd kattintson a Tovább gombra

Adja meg a projekt részleteit

5. lépés) Kattintson a Befejezés gombra

Kattintson a Befejezés gombra

6. lépés) Helyezze el a main.c fájlban az előző programban látható fő kódot, és mentse el.

Kód hozzáadása a main.c fájlhoz

7. lépés) Hozz létre egy új C fájlt [Fájl -> új -> Üres fájl], mentsd el (eredeti.c fájlként), és add hozzá az aktuális projekthez az „OK” gombra kattintva a párbeszédpanelen.

eredeti.c fájl létrehozása

8. lépés) Írd be és mentsd el az előző példában látható eredeti .c fájl C kódját a main() függvény nélkül.

Kód hozzáadása az original.c-hez

9. lépés) Építsd fel és futtasd a projektedet. Az eredmény a következő ábrán látható.

Program kimenet

Statikus tárolási osztály C-ben

A statikus változókat a függvény/fájlon belül helyi statikus változóként használják. Használhatók továbbá a globális változó

  • A statikus helyi változó olyan helyi változó, amely megőrzi és tárolja értékét a függvényhívások vagy blokkok között, és csak az a funkció vagy blokk számára látható, amelyben definiálva van.
  • A statikus globális változók olyan globális változók, amelyek csak abban a fájlban láthatók, amelyben deklarálták őket.
Example: static int count = 10;

Ne feledje, hogy a statikus változó alapértelmezett kezdőértéke nulla, és élete során csak egyszer inicializálódik.

#include <stdio.h> /* function declaration */
void next(void);
static int counter = 7; /* global variable */
main() {
 while(counter<10) {
      next();
      counter++;   }
return 0;}
void next( void ) {    /* function definition */
   static int iteration = 13; /* local static variable */
   iteration ++;
   printf("iteration=%d and counter= %d\n", iteration, counter);}

Eredmény:

iteration=14 and counter= 7
iteration=15 and counter= 8
iteration=16 and counter= 9

A globális változók az egész fájlban elérhetők, míg a statikus változók csak a kód adott része számára érhetők el.

A statikus változó élettartama a teljes programkódban van. A statikus kulcsszóval deklarált vagy inicializált változó alapértelmezett értékeként mindig nullát tartalmaz.

Tárolási osztály regisztrálása C-ben

A regiszter tárolási osztályt akkor használhatja, ha a helyi változókat függvényeken vagy blokkokon belül kívánja tárolni a CPU regiszterekben. RAM hogy gyorsan hozzáférjenek ezekhez a változókhoz. Például a „számlálók” jó jelöltek a nyilvántartásban való tárolásra.

Example: register int age;

A „register” kulcsszóval deklarálunk egy regisztertároló osztályt. A kulcsszóval deklarált változók élettartama a program teljes időtartama alatt megvan.

Hasonló az automatikus tárolási osztályhoz. A változó az adott blokkra korlátozódik. Az egyetlen különbség az, hogy a regiszter tárolási osztályával deklarált változókat a memória helyett a CPU regiszterekben tárolják. A regiszter gyorsabb hozzáféréssel rendelkezik, mint a fő memóriáé.

A regiszter tárolási osztály használatával deklarált változóknak nincs alapértelmezett értéke. Ezeket a változókat gyakran a program elején deklarálják.

#include <stdio.h> /* function declaration */
main() {
{register int  weight;
int *ptr=&weight ;/*it produces an error when the compilation occurs ,we cannot get a memory location when dealing with CPU register*/}
}

output:

error: address of register variable 'weight' requested

A következő táblázat összefoglalja az egyes tárolási osztályok főbb jellemzőit, amelyeket általában használnak a C programozásban

Tárolási osztály Nyilatkozat Tárolás Alapértelmezett kezdeti érték Kör Élettartam
auto Egy függvény/blokk belsejében Memory design kiszámíthatatlan A funkción/blokkon belül A funkción/blokkon belül
Regisztráció Egy függvény/blokk belsejében CPU regiszterek Szemét A funkción/blokkon belül A funkción/blokkon belül
külső Minden funkción kívül Memory design Nulla Teljes fájl és egyéb olyan fájlok, amelyekben a változó külsőként van deklarálva program futási ideje
Statikus (helyi) Egy függvény/blokk belsejében Memory design Nulla A funkción/blokkon belül program futási ideje
Statikus (globális) Minden funkción kívül Memory design Nulla Globál program futási ideje

GYIK

A hatókör határozza meg, hogy egy változó hol látható a kódban, míg az élettartam (lifetime) határozza meg, hogy mennyi ideig marad a memóriában. Egy változónak lehet blokk hatóköre, de a program teljes élettartama.

Mindkettő blokk hatókörű lokális változókat hoz létre, de az auto alapértelmezett értékkel a memóriában tartja őket, míg a register gyorsabb CPU-regiszter tárolást kér, és tiltja a változó címének átvételét.

Nem. A regiszter csak egy kérés; a fordító figyelmen kívül hagyhatja, ha nincs szabad regiszter. A modern fordítóprogramok automatikusan optimalizálják a regiszterek használatát, így a kulcsszóra ma már ritkán van szükség.

A statikus és extern változók egy nulla inicializálású memóriaszegmensben találhatók a teljes programban, tehát nulláról kezdődnek. Az automatikus változók újrafelhasználják a veremmemóriát, keeping bármilyen értéket is hagytak maguk után.

Egy extern deklaráció csak egy máshol definiált változót jelent be, és nem inicializálható. A valódi definíció, egyetlen fájlban, lefoglalja a tárhelyet, és a linkelés minden hivatkozást ehhez kapcsol.

Többnyire, de nem egészen. C++ elavulttá tették a register kulcsszót, és az auto kulcsszót használták újra típuskövetkeztetésre. A static és az extern hasonlóan viselkednek, bár C++ hozzáadja a thread_local és az class-member tárolási szabályokat.

Igen. A mesterséges intelligencia asszisztensek leírják az auto, regiszter, statikus és extern változókat, javasolják az egyes változók megfelelő specifikátorát, és jelzik a helytelen használatot, például egy regiszterváltozó címének átvételét.

GitHub másodpilóta automatikusan kiegészíti a statikus számlálókat, a fájlok közötti extern deklarációkat és a regiszterekhez kapcsolódó tippeket, majd gépelés közben elmagyarázza a hatókört és az élettartamot.

Foglald össze ezt a bejegyzést a következőképpen: