C ++ - kvalificerings- och lagringsklassspecifikatorer

CV står för Constant-Volatile. Deklarationen av ett objekt som inte föregås av const och / eller flyktigt är en cv-okvalificerad typ. Å andra sidan är deklarationen av ett objekt som föregås av const och / eller flyktig en cv-kvalificerad typ. Om ett objekt förklaras const kan värdet på dess plats inte ändras. En flyktig variabel är en variabel vars värde påverkas av programmeraren och därför inte kan ändras av kompilatorn.Lagringsklassspecifikatorer hänvisar till livslängd, plats och sätt på vilket en typ finns. Lagringsklassspecifikationer är statiska, mutabla, trådlokala och externa.

Den här artikeln förklarar C ++ - kvalificerings- och lagringsklassspecifikatorer. Således kommer vissa förkunskaper i C ++ till nytta för att verkligen uppskatta artikeln.

Artikelinnehåll:

Kval
Lagringsklassspecifikatorer
Slutsats

Kval:

konst

Ett objekt som deklareras som konstant är ett objekt vars lagring (plats) inte kan ändras. Till exempel i uttalandet:

int const theInt = 5;

Värdet 5 i lagringen för theInt kan inte ändras.

flyktig

Tänk på följande uttalande:

int portVal = 26904873;

Kompilatorer stör ibland värdet på en variabel i hopp om att optimera programmet. Kompilatorn kan behålla värdet på en variabel som konstant när den inte ska vara konstant. Objektvärden som har att göra med minneskartade IO-portar eller Interrupt Service Routines för kringutrustning kan störas av kompilatorn. För att förhindra sådan störning, gör variabeln flyktig, som:

int flyktig portVal;
portVal = 26904873;
eller liknande:
int flyktig portVal = 26904873;

Kombinera konst och flyktig:

const och flyktiga kan förekomma i ett uttalande enligt följande:

int const flyktiga portVal = 26904873;

cv-kval

En variabel som föregås av const och / eller flyktig är en cv-kvalificerad typ. En variabel som inte föregås av varken const eller flyktig eller båda är en cv-okvalificerad typ.

Beställning:

En typ kan vara mer cv-kvalificerad än en annan:

Ingen cv-kvalificering är mindre än en const-kvalificering
Ingen cv-kval är också mindre än en flyktig kval
Ingen cv-kvalificering är mindre än en konst-flyktig kval
const-kval är mindre än en const-flyktig kval
flyktig kval är mindre än en konstant flyktig kval

Det har ännu inte slutits om konst och flyktiga är av samma rang.

Array och Instantiated Object:

När en matris förklaras konstant, som i följande uttalande, betyder det att värdet på varje element i matrisen inte kan ändras:

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

Oavsett om det är ett 'a', 'b', 'c' eller 'd', kan det ändå inte ändras till något annat värde (tecken).

En liknande situation gäller för ett instanserat objekt i en klass. Tänk på följande program:

#omfatta
använder namnrymd std;
klass Cla

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

const Cla obj;
returnera 0;

På grund av uttalandet "const Cla obj;" med const i huvudfunktionen () kan varken 'a' eller 'b' eller 'c' eller 'd' ändras till något annat värde.

Lagringsklassspecifikatorer:

Lagringsklassspecifikationer är statiska, mutabla, trådlokala och externa.

De statisk specifikation för lagringsklass

Den statiska lagringsklassspecifikatorn tillåter variabeln att leva efter att dess omfattning har gått igenom, men den kan inte nås direkt.

Följande program illustrerar detta med en rekursiv funktion:

#omfatta
använder namnrymd std;
int funkt ()

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

cout << '\n';
returnera 0;

funct ();

int main ()

funct ();
returnera 0;

Utgången är:

10 20 30 40 50

Om en statisk variabel inte initialiseras vid den första deklarationen antar den standardvärdet för sin typ.

Den statiska specifikationen kan också användas med medlemmar i en klass; användningen här är annorlunda. Här tillåter det att medlemmen kan nås utan ögonblick för objektet.

Följande program illustrerar detta för en datamedlem:

#omfatta
använder namnrymd std;
klass Cla

offentlig:
statisk konst int antal = 8;
;
int main ()

cout << Cla::num << '\n';
returnera 0;

Utgången är:

Den statiska datamedlemmen måste vara konstant. Observera att användningen av operatören för omfångsupplösning för att komma åt den statiska variabeln utanför dess omfång (i huvudfunktionen).

Följande program illustrerar användningen av "statisk" för en medlemsfunktion:

#omfatta
använder namnrymd std;
klass Cla

offentlig:
statisk tomrummet metod ()

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

;
int main ()

Cla :: metod ();
returnera 0;

Utgången är:

Med statisk medlemsfunktion!

Observera att användningen av operatören för omfångsupplösning för att komma åt den statiska medlemsfunktionen utanför dess omfång (i huvudfunktionen).

Den muterbara specifikatorn

Kom ihåg, från ovan, att om ett instanserat objekt börjar med const, kan värdet på någon av dess normala datamedlemmar inte ändras. Och för att någon sådan datamedlem ska kunna ändras måste den förklaras, förändras.

Följande program illustrerar detta:

#omfatta
använder namnrymd std;
klass Cla

offentlig:
char ch0 = 'a';
char ch1 = 'b';
mutable char ch2 = 'c';
char ch3 = 'd';
;
int main ()

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

Utgången är:

'a "b" z "d'

Thread_local Specifier

Vid normal körning av ett program körs ett kodsegment, sedan nästa kodsegment, följt av ett annat kodsegment efter det, och så vidare. Det är en tråd; huvudtråden. Om två kodsegment körs samtidigt (samma varaktighet) behövs en andra tråd. Resultatet av den andra tråden kan till och med vara klar före huvudtråden.

Huvudfunktionen () är som huvudtråden. Ett program kan ha mer än två trådar för ett sådant asynkront beteende.

Den andra tråden behöver ett scope (block scope) för att fungera. Detta tillhandahålls vanligtvis av funktionsomfånget, en funktion. En variabel i ett yttre omfång som kan ses i ramen för den andra tråden.

Följande kortprogram illustrerar användningen av specificera thread_local:

#omfatta
#omfatta
använder namnrymd std;
thread_local int inter = 1;
ogiltig tråd_funktion ()

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

int main ()

trådtråd (& trådfunktion); // thr börjar springa
cout << inter << "st or main thread\n";
thr.Ansluta sig(); // huvudtråd väntar på att tråden ska avslutas
returnera 0;

Utgången är:

1: a eller huvudtråd
2: a tråden

Variabeln, inter, föregången av thread_local, betyder att inter har en separat instans i varje tråd. Och att den kan modifieras i olika trådar för att ha olika värden. I detta program tilldelas det värdet, 1 i huvudtråden, och modifieras till värdet, 2 i den andra tråden.

En tråd behöver ett speciellt objekt för att fungera. För detta program ingår biblioteket av “#include ”Har en klass som kallas en tråd, från vilken objektet thr har instantierats. Konstruktören för detta objekt tar en hänvisning till trådfunktionen som ett argument. Namnet på trådfunktionen i detta program är thread_function ().

Sammanfoga () medlemsfunktionen för det speciella objektet, vid dess position, gör att huvudtråden väntar på att den andra tråden ska slutföras innan den fortsätter att köra, annars kan huvudfunktionen () gå ut utan att (andra) tråden har gav sitt resultat.

Den externa specifikatorn

Enkelt uttryckt, för en deklaration tilldelas inte minne för variabeln eller funktionen, medan för en definition tilldelas minne. Det externa reserverade ordet tillåter att en global variabel eller funktion deklareras i en fil men definieras i en annan. Sådana filer kallas översättningsenheter för hela C ++ - applikationen.

Skriv in följande program och spara det med filnamnet, mainFile:

#omfatta
använder namnrymd std;
int myInt;
const char ch;
ogiltig myFn ();
int main ()

myFn ();
returnera 0;

Variabeln, myInt, den konstanta variabeln, ch och funktionen, myFn (), har deklarerats utan att de har definierats.

Skriv följande program med definitionerna och spara det med filnamnet, otherFile, i samma katalog:

#omfatta
använder namnrymd std;
int mynt = 10;
const char ch = 'c';
ogiltig myFn ()

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

Försök att kompilera applikationen vid terminalen (DOS-kommandotolken) med följande kommando och lägg märke till att den kanske inte kompilerar:

g ++ huvudfil.cpp otherFile.cpp -o komplett.exe

Före de tre deklarationerna i mainFile med ordet "extern", enligt följande:

extern int mynt;
extern const char ch;
extern tomrum myFn ();

Spara mainFile igen. Kompilera applikationen med:

g ++ huvudfil.cpp otherFile.cpp -o komplett.exe

(Så här sammanställs separata filer för samma applikation i C ++)

Och det borde sammanställas. Kör nu applikationen, slutför.exe, och utdata ska vara:

myFn () säger 10 och c

Observera att med hjälp av "extern" kan en konstant variabel deklareras i en fil men definieras i en annan. När man hanterar funktionsdeklaration och definition i olika filer är användning av extern valfri.

När ska extern användas? Använd den när du inte har rubrikfiler med globala deklarationer.

”Extern” används också med malldeklarationer - se senare.

Slutsats:

En variabel som föregås av const och / eller flyktig är en cv-kvalificerad typ. En variabel, som inte föregås av vare sig const eller flyktig eller båda, är en cv-okvalificerad typ.

Lagringsklassspecifikatorer är statiska, muterbara, trådlokala och externa. Dessa påverkar livslängden (varaktighet), plats och sätt att anställa variabler i en applikation.