C ++ minősítők és tárolási osztályok specifikációi

A CV a Constant-Volatile rövidítése. Az objektum deklarálása, amelyet nem előz meg konst és / vagy volatilis, egy cv-minősítés nélküli típus. Másrészt az objektum deklarálása, amelyet konst és / vagy volatile előz meg, egy cv minősítésű típus. Ha egy objektumot deklaráltunk const-nak, akkor a helyén lévő érték nem módosítható. A volatilis változó olyan változó, amelynek értéke a programozó hatása alatt áll, ezért a fordító nem változtathatja meg.A tárolási osztály specifikátorai a típus létezésére, helyére és módjára utalnak. A tárolási osztály specifikátorai statikusak, változtathatóak, thread_local és externek.

Ez a cikk a C ++ minősítőket és a tárolási osztályok specifikációit ismerteti. Így a C ++ nyelvben elért előzetes ismeretek jól jönnek ahhoz, hogy valóban értékeljék a cikket.

A cikk tartalma:

• Minősítők
• Tárolási osztály specifikátorok
• Következtetés

Selejtezők:

konst

Az állandónak deklarált objektum olyan objektum, amelynek értékét (tárhelyét) nem lehet megváltoztatni. Például a nyilatkozatban:

int const azInt = 5;

Az INI tárolójában lévő 5 értéke nem módosítható.

illó

Vegye figyelembe a következő állítást:

int portVal = 26904873;

A fordítók néha beavatkoznak egy változó értékébe a program optimalizálásának reményében. A fordító változók értékét tarthatja állandónak, ha állítólag nem állandó. A fordító megzavarhatja azokat az objektumértékeket, amelyek a memória által leképezett IO portokhoz vagy a perifériás eszközök megszakító szolgáltatás rutinjaihoz kapcsolódnak. Az ilyen interferencia megelőzése érdekében tegye a változót illékonyvá, például:

int illékony portVal;
portVal = 26904873;
vagy mint:
int illékony portVal = 26904873;

A konstans és az illékony kombinálása:

konst és volatilis fordulhat elő egy állításban, az alábbiak szerint:

int const illékony portVal = 26904873;

cv-selejtezők

Az const és / vagy volatile előtt álló változó CV minősítésű típus. Az a változó, amely előtt nem szerepel sem const, sem volatile, sem mindkettő, CV minősítés nélküli típus.

Rendelés:

Egy típus lehet több CV minősítésű, mint egy másik:

• Egyetlen cv-minősítő sem kisebb, mint egy konst minősítő
• Egy cv-selejtező sem kevesebb, mint egy illékony selejtező
• Egyetlen cv-minősítő sem kisebb, mint egy konstans volatilis minősítő
• A const minősítő kisebb, mint a konstans volatilis minősítő
• az illékony minősítő kisebb, mint a konstans illékony minősítő

Még nem állapították meg, hogy a const és a volatile azonos rangú-e.

Tömb és azonnali objektum:

Ha egy tömböt állandónak nyilvánítanak, mint a következő utasításban, ez azt jelenti, hogy a tömb egyes elemeinek értéke nem változtatható meg:

const char arr [] = 'a', 'b', 'c', 'd';

Legyen az 'a', 'b', 'c' vagy 'd', mégsem lehet megváltoztatni valamilyen más értékre (karakterre).

Hasonló helyzet áll fenn egy osztály példányosított objektumára is. Fontolja meg a következő programot:

#include
névtér használata std;
osztály Cla

nyilvános:
char ch0 = 'a';
char ch1 = 'b';
char ch2 = 'c';
char ch3 = 'd';
;
int main ()

const Cla obj;
visszatér 0;

A „const Cla obj;” állítás miatt Ha a const a main () függvényben, sem az „a”, sem „b”, sem „c”, sem „d” nem változtatható más értékre.

Tárolási osztály specifikátorok:

A tárolási osztály specifikátorai statikusak, változtathatóak, thread_local és externek.

A statikus Storage Class Specifier

A statikus tárolóosztály-specifikátor lehetővé teszi a változó életét a hatókörének átélése után, de közvetlenül nem érhető el.

A következő program ezt szemlélteti rekurzív funkcióval:

#include
névtér használata std;
int funct ()

statikus int stac = 10;
cout << stac < 50)

cout << '\n';
visszatér 0;

funct ();

int main ()

funct ();
visszatér 0;

A kimenet:

10 20 30 40 50

Ha egy statikus változót nem inicializálnak az első deklarációnál, akkor az átveszi a típusának alapértelmezett értékét.

A statikus specifikátor egy osztály tagjaival is használható; itt más a felhasználás. Itt lehetővé teszi a tag elérését az objektum példányosítása nélkül.

A következő program ezt szemlélteti egy adattag esetében:

#include
névtér használata std;
osztály Cla

nyilvános:
statikus const int szám = 8;
;
int main ()

cout << Cla::num << '\n';
visszatér 0;

A kimenet:

8

A statikus adattagnak állandónak kell lennie. Ne feledje, hogy a hatókör-felbontás operátor használata a hatókörén kívüli statikus változó eléréséhez (a fő funkcióban).

A következő program a „statikus” tagfunkció használatát szemlélteti:

#include
névtér használata std;
osztály Cla

nyilvános:
static void módszer ()

cout << "Of static member function!" << '\n';

;
int main ()

Cla :: módszer ();
visszatér 0;

A kimenet:

Statikus tagfunkció!

Ne feledje, hogy a hatókör-felbontás operátor használata a statikus tag funkció eléréséhez a hatókörén kívül (a fő funkcióban).

A változtatható specifikátor

Felülről ne feledje, hogy ha egy példányos objektum const-tal kezdődik, akkor annak egyik normál adattagjának értéke sem változtatható meg. És ahhoz, hogy bármely ilyen adattagot megváltoztathassanak, deklarálhatónak kell lennie.

A következő program ezt szemlélteti:

#include
névtér használata std;
osztály Cla

nyilvános:
char ch0 = 'a';
char ch1 = 'b';
mutálható char ch2 = 'c';
char ch3 = 'd';
;
int main ()

const Cla obj;
obj.ch2 = 'z';
cout << obj.ch0 << " << obj.ch1 << " << obj.ch2 << " << obj.ch3 << " << '\n';
visszatér 0;

A kimenet:

'a "b" z "d"

A thread_local specifikátor

A program normál futása során egy kódszegmens kerül végrehajtásra, majd a következő kódszegmens, utána pedig egy másik kódszegmens, és így tovább. Ez egy szál; a fő szál. Ha két kódszegmens fut egyszerre (azonos időtartamban), akkor egy második szálra van szükség. A második menet eredménye még a fő menet előtt is kész lehet.

A main () függvény olyan, mint a fő szál. Egy programnak kétnél több szála lehet egy ilyen aszinkron viselkedéshez.

A második szálnak hatókörre (blokk hatókörre) van szüksége a működéshez. Ezt általában a függvény hatóköre, egy függvény biztosítja. Külső hatókörű változó, amely a második szál hatókörében látható.

Az alábbi rövid program bemutatja a thread_local specifikátor használatát:

#include
#include
névtér használata std;
thread_local int inter = 1;
void thread_function ()

inter = inter + 1;
cout << inter << "nd thread\n";

int main ()

menet thr (& menet_funkció); // thr futni kezd
cout << inter << "st or main thread\n";
thr.csatlakozik(); // fő szál várja a szálat, thr befejeződik
visszatér 0;

A kimenet:

1. vagy fő szál
2. szál

Az inter változó, amelyet a thread_local előz meg, azt jelenti, hogy az inter minden szálban külön példánnyal rendelkezik. És hogy különböző szálakban módosítható, hogy különböző értékek legyenek. Ebben a programban hozzá van rendelve az érték, 1 a fő szálban, és módosítva az értékhez, 2 a második szálban.

A szál működéséhez speciális objektumra van szükség. Ehhez a programhoz a „#include ”Egy szál nevű osztálya van, amelyből a thr objektum példányos lett. Ennek az objektumnak a kivitelezője a szálfüggvényre hivatkozást vesz fel argumentumként. A szálfüggvény neve ebben a programban a szál_funkció ().

A speciális objektumhoz tartozó join () tag függvény az általa alkalmazott helyzetben arra készteti a fő szálat, hogy a végrehajtás folytatása előtt megvárja a második szál végrehajtását, különben a main () függvény kiléphet anélkül, hogy a (második) szálnak lenne meghozta eredményét.

A külső specifikátor

Egyszerűbben fogalmazva: egy deklarációhoz a memória nincs kiosztva a változóhoz vagy a függvényhez, míg egy definícióhoz a memória van lefoglalva. A külső fenntartott szó lehetővé teszi egy globális változó vagy függvény deklarálását az egyik fájlban, de a másikban definiálását. Az ilyen fájlokat fordítási egységeknek nevezzük a teljes C ++ alkalmazás számára.

Gépelje be a következő programot, és mentse a fájlnév, mainFile nevű fájlba:

#include
névtér használata std;
int myInt;
const char ch;
void myFn ();
int main ()

myFn ();
visszatér 0;

A myInt változót, a ch állandó változót és a myFn () függvényt deklarálás nélkül deklaráltuk.

Írja be a következő programot a definíciókkal, és mentse a fájlnév, otherFile nevű fájlba, ugyanabba a könyvtárba:

#include
névtér használata std;
int myInt = 10;
const char ch = 'c';
void myFn ()

cout << "myFn() says " << myInt << " and " << ch <<'\n';

Próbálja meg lefordítani az alkalmazást a terminálon (DOS parancssor) a következő paranccsal, és vegye figyelembe, hogy előfordulhat, hogy nem fordítja le:

g ++ mainfile.cpp egyébFájl.cpp -o teljes.alkalmazás

Most a mainFile fájlban található három deklaráció előtt álljon az „extern” szóval, az alábbiak szerint:

extern int myInt;
extern const char ch;
extern void myFn ();

Mentse újra a mainFile fájlt. Állítsa össze az alkalmazást:

g ++ mainfile.cpp egyébFájl.cpp -o teljes.alkalmazás

(Így állítják össze ugyanazon alkalmazás külön fájljait a C ++ nyelven)

És össze kell állítania. Most futtassa az alkalmazást, fejezze be.exe, és a kimenetnek a következőknek kell lennie:

myFn () szerint 10 és c

Ne feledje, hogy az „extern” használatával állandó változó deklarálható az egyik fájlban, de meghatározható a másikban. Ha a függvénydeklarációval és a definícióval különböző fájlokban foglalkozik, akkor az extern használata opcionális.

Mikor kell használni az extern-t? Akkor használja, ha nincsenek fejlécfájlok globális deklarációkkal.

Az „extern” sablon deklarációknál is használatos - lásd később.

Következtetés:

Az const és / vagy volatile előtt álló változó CV minősítésű típus. Egy változó, amelyet nem előz meg sem const, sem volatile, sem mindkettő, CV minősítés nélküli típus.

A tárolási osztály specifikátorai statikusak, változtathatóak, thread_local és externek. Ezek befolyásolják a változók élettartamát (időtartamát), helyét és alkalmazási módját egy alkalmazásban.