C ++ kvalifiseringskamp og lagringsklassespesifikasjoner

CV står for konstant-flyktig. Erklæringen om et objekt som ikke er gitt av Const og/eller flyktig, er en CV-ikke-kvalifisert type. På den annen side er erklæringen om et objekt som er gitt av const og/eller ustabil er en CV-kvalifisert type. Hvis et objekt er erklært Const, kan ikke verdien på plasseringen endres. En flyktig variabel er en variabel hvis verdi er under påvirkning av programmereren, og kan derfor ikke endres av kompilatoren.Lagringsklassespesifikasjoner refererer til livet, stedet og måten en type eksisterer. Lagringsklassespesifikasjoner er statiske, mutable, tråd_lokal og ekstern.

Denne artikkelen forklarer C ++ kvalifiseringskamp og lagringsklassespesifikasjoner. Dermed kommer noe foreløpig kunnskap i C ++ godt for å virkelig sette pris på artikkelen.

Artikkelinnhold:

• Kvalifiseringer
• Lagringsklassespesifikasjoner
• Konklusjon

Kvalifiseringskamp:

const

Et objekt erklært konstant er et objekt lagringen (plasseringen) av hvis verdi ikke kan endres. For eksempel i uttalelsen:

int const theint = 5;

Verdien på 5 i lagringen for TheInt kan ikke endres.

flyktige

Tenk på følgende uttalelse:

Int Portval = 26904873;

Kompilatorer forstyrrer noen ganger verdien av en variabel med håp om å optimalisere programmet. Kompilatoren kan opprettholde verdien av en variabel som konstant når den ikke skal være konstant. Objektverdier som har å gjøre med minnekraktede IO-porter, eller avbryte tjenestrutiner for perifere enheter, kan forstyrres av kompilatoren. For å forhindre slik interferens, gjør den variable flyktige, som:

int flyktig portval;
Portval = 26904873;
eller liker:
int flyktig portval = 26904873;

Kombinasjon av const og flyktig:

const og ustabil kan forekomme i en uttalelse som følger:

int const flyktig portval = 26904873;

CV-kvalifiserere

En variabel foran med const og/eller flyktig er en CV-kvalifisert type. En variabel som ikke er foran med verken const eller flyktig eller begge deler, er en CV-ikke-kvalifisert type.

Bestilling:

En type kan være mer CV-kvalifisert enn en annen:

• Ingen CV-kvalifiserer er mindre enn en Const-kvalifisering
• Ingen CV-kvalifiserer er også mindre enn en flyktig kvalifiseringskamp
• Ingen CV-Qualifier er mindre enn en Const-flyktig kvalifiseringskamp
• Const Qualifier er mindre enn en Const-flyktig kvalifiseringskamp
• Flybar kvalifisering er mindre enn en Const-flyktig kvalifiseringskamp

Det er ennå ikke konkludert om Const og flyktig er av samme rangering.

Array og Instantiated Object:

Når en matrise er erklært konstant, som i følgende uttalelse, betyr det at verdien av hvert element i matrisen ikke kan endres:

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

Enten det er en 'A', 'B', 'C' eller 'D', det kan fremdeles ikke endres til en annen verdi (karakter).

En lignende situasjon gjelder et instantiert objekt i en klasse. Tenk på følgende program:

#inkludere
ved hjelp av navneområdet STD;
Klasse CLA

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

const cla obj;
retur 0;

På grunn av uttalelsen "const cla obj;" Med Const in the Main () -funksjonen kan verken 'A' eller 'B' eller 'C' eller 'D' endres til en annen verdi.

Lagringsklassespesifikasjoner:

Lagringsklassespesifikasjoner er statiske, mutable, tråd_lokal og ekstern.

De Statisk lagringsklassespesifikasjon

Den statiske lagringsklassespesifikatoren lar variabelen leve etter at omfanget har gått gjennom, men den kan ikke nås direkte.

Følgende program illustrerer dette, med en rekursiv funksjon:

#inkludere
ved hjelp av navneområdet STD;
int funct ()

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

cout << '\n';
retur 0;

funct ();

int main ()

funct ();
retur 0;

Utgangen er:

10 20 30 40 50

Hvis en statisk variabel ikke initialiseres ved sin første erklæring, forutsetter den standardverdien for sin type.

Den statiske spesifikasjonen kan også brukes sammen med medlemmer av en klasse; Bruken her er annerledes. Her tillater det at medlemmet kan nås uten instantiering for objektet.

Følgende program illustrerer dette for et datamedlem:

#inkludere
ved hjelp av navneområdet STD;
Klasse CLA

offentlig:
statisk const int num = 8;
;
int main ()

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

Utgangen er:

8

Det statiske datamedlemmet må være konstant. Merk at bruken av omfangsoppløsningsoperatøren for å få tilgang til den statiske variabelen utenfor omfanget (i hovedfunksjonen).

Følgende program illustrerer bruken av "statisk" for en medlemsfunksjon:

#inkludere
ved hjelp av navneområdet STD;
Klasse CLA

offentlig:
statisk tomrommetode ()

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

;
int main ()

Cla :: Metode ();
retur 0;

Utgangen er:

Av statisk medlemsfunksjon!

Merk at bruken av omfangsoppløsningsoperatøren for å få tilgang til den statiske medlemsfunksjonen utenfor omfanget (i hovedfunksjonen).

Den mutable spesifikasjonen

Husk, ovenfra, at hvis et instantiert objekt begynner med Const, kan verdien av noen av dets normale datamedlemmer ikke endres. Og for at et slikt datamedlem skal endres, må det deklareres, mutable.

Følgende program illustrerer dette:

#inkludere
ved hjelp av navneområdet STD;
Klasse 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';
retur 0;

Utgangen er:

'A "B" Z "D'

Thread_local -spesifikasjonen

I normal kjøring av et program blir ett kodesegment utført, deretter neste kodesegment, etterfulgt av et annet kodesegment etter det, og så videre. Det er en tråd; hovedtråden. Hvis to kodesegmenter utfører samtidig (samme varighet), er det nødvendig med en andre tråd. Resultatet av den andre tråden kan til og med være klar før hovedtråden.

Hovedfunksjonen () er som hovedtråden. Et program kan ha mer enn to tråder for en så asynkron oppførsel.

Den andre tråden trenger et omfang (blokkomfang) for å operere. Dette er vanligvis levert av funksjonsomfanget, en funksjon. En variabel i et ytre omfang som kan sees i omfanget av den andre tråden.

Følgende korte program illustrerer bruken av Tråd_lokale spesifikasjonen:

#inkludere
#inkludere
ved hjelp av navneområdet STD;
thread_local int inter = 1;
void thread_function ()

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

int main ()

tråd thr (& thread_function); // Thr begynner å løpe
cout << inter << "st or main thread\n";
thr.bli med(); // Hovedtråden venter på at tråden er ferdig
retur 0;

Utgangen er:

1. eller hovedtråd
2. tråd

Variabelen, Inter, gitt av tråd_lokal, betyr at Inter har en egen forekomst i hver tråd. Og at det kan endres i forskjellige tråder for å ha forskjellige verdier. I dette programmet tildeles det verdien, 1 i hovedtråden, og modifisert til verdien, 2 i den andre tråden.

En tråd trenger et spesielt objekt for å betjene. For dette programmet har biblioteket inkludert av “#include” en klasse som heter en tråd, hvorav objektet Thr har blitt instantiert. Konstruktøren for dette objektet tar en referanse til trådfunksjonen som et argument. Navnet på trådfunksjonen i dette programmet er tråd_funksjon ().

Join () medlemsfunksjon for det spesielle objektet, på sin ansatt, får hovedtråden til å vente på at den andre tråden skal avsluttes før den fortsetter å utføre, ellers kan hovedfunksjonen () avslutte uten at (andre) tråden har ga resultatet.

Ekstern spesifikasjon

Enkelt sagt, for en erklæring, blir ikke minnet tildelt for variabelen eller funksjonen, mens for en definisjon blir minnet tildelt. Det eksterne reserverte ordet gjør at en global variabel eller funksjon kan deklareres i en fil, men definert i en annen. Slike filer kalles oversettelsesenheter for hele C ++ -applikasjonen.

Skriv inn følgende program og lagre det med filnavnet, MainFile:

#inkludere
ved hjelp av navneområdet STD;
int myint;
const char ch;
void myfn ();
int main ()

myfn ();
retur 0;

Variabelen, Myint, den konstante variabelen, CH, og funksjonen, Myfn (), er blitt erklært uten å bli definert.

Skriv inn følgende program med definisjonene, og lagre det med filnavnet, OtherFile, i samme katalog:

#inkludere
ved hjelp av navneområdet STD;
int myint = 10;
const char ch = 'c';
ugyldig myfn ()

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

Forsøk å kompilere applikasjonen på terminalen (DOS -kommandoprommet) med følgende kommando, og legg merke til at den kanskje ikke sammenstiller:

G ++ Mainfile.CPP OtherFile.CPP -o Komplett.EXE

Nå kan du gå foran de tre erklæringene i hovedfilen med ordet "eksternt", som følger:

ekstern int myint;
ekstern const char ch;
eksternt tomrom myfn ();

Savle hovedfilen på nytt. Kompilere applikasjonen med:

G ++ Mainfile.CPP OtherFile.CPP -o Komplett.EXE

(Slik er separate filer for den samme applikasjonen samlet i C ++)

Og det skal kompilere. Nå, kjør søknaden, fullfør.exe, og utgangen skal være:

myfn () sier 10 og c

Merk at med bruk av "ekstern", kan en konstant variabel deklareres i en fil, men definert i en annen. Når du arbeider med funksjonserklæring og definisjon i forskjellige filer, er bruken av ekstern valgfritt.

Når skal du bruke ekstern? Bruk den når du ikke har toppfiler med globale erklæringer.

“Ekstern” brukes også med maldeklarasjoner - se senere.

Konklusjon:

En variabel foran med const og/eller flyktig er en CV-kvalifisert type. En variabel, ikke foregått med verken Const eller Volatile eller begge deler, er en CV-Ukvalifisert type.

Lagringsklassespesifikasjoner er statiske, mutable, tråd_lokal og ekstern. Disse påvirker levetiden (varigheten), sted og måte å sysselsette variabler i en applikasjon.