Omfattning i C ++

En enhet i C ++ har ett namn som kan deklareras och / eller definieras. En deklaration är en definition, men en definition är inte nödvändigtvis en deklaration. En definition tilldelar minne för den namngivna enheten, men en deklaration kan eller inte tilldela minne för den namngivna enheten. En deklarativ region är den största delen av ett program där namnet på en enhet (variabel) är giltig. Den regionen kallas ett omfång eller ett potentiellt omfång. Denna artikel förklarar omfattning i C++. Dessutom behövs grundläggande kunskaper i C ++ för att förstå den här artikeln.

Artikelinnehåll

Deklarativ region och räckvidd
Globalt omfång
Blockera omfattning
Funktionens omfattning
Uppräkningsomfattning
Klassomfång
Template Parameter Scope
Namn gömmer sig
Möjlighet att upprepa deklarationen i samma omfattning
Namnområdets omfattning
Räckvidd i olika delar
Slutsats

Deklarativ region och räckvidd

En deklarativ region är den största delen av en programtext där namnet på en enhet är giltig. Det är regionen där det okvalificerade namnet kan användas (sett) för att hänvisa till samma enhet. Tänk på följande korta program:

#omfatta
använder namnrymd std;
ogiltigt fn ()

int var = 3;
om (1 == 1)

cout<

int main ()

fn ();
returnera 0;

Funktionen fn () har två block: ett inre block för if-tillståndet och ett yttre block för funktionskroppen. Identifieraren, var, introduceras och ses i det yttre blocket. Det ses också i det inre blocket, med cout uttalande. De yttre och inre blocken är båda utrymmet för namnet, var.

Namnet, var, kan dock fortfarande användas för att deklarera en annan enhet, till exempel en flottör i det inre blocket. Följande kod illustrerar detta:

#omfatta
använder namnrymd std;
ogiltigt fn ()

int var = 3;
om (1 == 1)

flottör var = 7.5;
cout<

int main ()

fn ();
returnera 0;

Utgången är 7.5. I det här fallet kan namnet, var, inte längre användas i det inre blocket för att hänvisa till heltalet med värde 3, som infördes (deklareras) i det yttre blocket. Sådana inre block kallas potentiellt utrymme för enheter som deklareras i det yttre blocket.

Anmärkning: En enhet av samma typ, som det yttre blocket, kan fortfarande deklareras i det inre blocket. Men i det här fallet är det som är giltigt i det inre blocket den nya deklarationen och dess betydelse, medan den gamla deklarationen och dess betydelse utanför det inre blocket förblir giltig i det yttre blocket.

En förklaring med samma namn i ett inre block åsidosätter normalt deklarationen av samma namn utanför det inre blocket. Inre block kan hysa andra inre block.

Globalt omfång

När en programmerare bara börjar skriva en fil är det det globala omfånget. Följande kortprogram illustrerar detta:

#omfatta
använder namnrymd std;
flottör var = 9.4;
int main ()

cout <cout <<::var<<'\n';
returnera 0;

Utgången är:
9.4
9.4

I det här fallet börjar den deklarativa regionen eller räckvidden för var från deklarationspunkten för var, fortsätter nedåt till slutet av filen (översättningsenhet).

Blocket för huvudfunktionen () har ett annat omfång; det är ett kapslat omfång för det globala omfånget. För att komma åt en enhet av det globala omfånget, från ett annat omfång, används identifieraren direkt eller föregås av operatören för omfångsupplösning: .

Obs! Enheten, main (), deklareras också i det globala omfånget.

Blockera omfattning

Uttrycket if, while, do, for eller switch kan definiera var och en ett block. Ett sådant uttalande är ett sammansatt uttalande. Namnet på en variabel som deklarerats i ett block har blockets omfång. Dess omfattning börjar vid deklarationspunkten och slutar i slutet av blocket. Följande kortprogram illustrerar detta för variabeln, ident:

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

om (1 == 1)

/ * några uttalanden * /
int ident = 5;
cout</ * några uttalanden * /

returnera 0;

En variabel, såsom ident, som deklareras i blockomfång är en lokal variabel.

En variabel som deklareras utanför blockomfånget och ovanför den kan ses i rubriken på blocket (t.ex.g., villkor för if-block) och även inom blocket. Följande kortprogram illustrerar detta för variabeln, identif:

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

int identif = 8;
if (identif == 8)

cout<
returnera 0;

Utgången är 8. Det finns två blockomfång här: blocket för huvudfunktionen () och det kapslade if-compound-uttalandet. Det kapslade blocket är det potentiella omfånget för huvudfunktionsblocket ().

En deklaration som införs i blockomfång kan inte ses utanför blocket. Följande korta program, som inte kompilerar, illustrerar detta med variabeln, variab:

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

om (1 == 1)

int variab = 15;

cout<returnera 0;

Kompilatorn ger ett felmeddelande för variab.

En enhet som introducerats, deklarerad i rubriken för en sammansatt funktion, kan inte ses utanför (nedan) sammansatt uttalande. Följande for-loop-kod kompileras inte, vilket resulterar i ett felmeddelande:

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

för (int i = 0; i<4; ++i)

cout<
cout<returnera 0;

Iterationsvariabeln, i, ses inuti for-loop-blocket men inte utanför for-loop-blocket.

Funktionens omfattning

En funktionsparameter visas i funktionsblocket. En enhet som deklareras i ett funktionsblock ses från deklarationspunkten till slutet av funktionsblocket. Följande kortprogram illustrerar detta:

#omfatta
#omfatta
använder namnrymd std;
sträng fn (sträng str)

char stri [] = "bananer";
/ * andra uttalanden * /
sträng totalStr = str + stri;
returnera totalStr;

int main ()

sträng totStr = fn ("äta");
cout<returnera 0;

Utgången är:
äta bananer

Obs! En enhet som deklareras utanför funktionen (ovanför den) kan ses i listan över funktionsparametrar och även i funktionsblocket.

Märka

Omfattningen av en etikett är den funktion den visas i. Följande kod illustrerar detta:

#omfatta
använder namnrymd std;
ogiltigt fn ()

goto labl;
/ * andra uttalanden * /
labl: int inte = 2;
cout<
int main ()

fn ();
returnera 0;

Utgången är 2.

Uppräkningsomfattning

Okopierad uppräkning
Tänk på följande if-block:

om (1 == 1)

enum a, b, c = b + 2;
cout<

Utgången är 0 1 3.

Den första raden i blocket är en uppräkning, a, b och c är dess uppräkare. Omfattningen av en uppräkare börjar från deklarationspunkten till slutet av det omslutande blocket för uppräkningen.

Följande uttalande kommer inte att kompileras eftersom deklarationspunkten för c är efter den för a:

enum a = c + 2, b, c;

Följande kodsegment kommer inte att kompileras eftersom räknaren nås efter det slutande blocket för uppräkningen:

om (1 == 1)

enum a, b, c = b + 2;

cout<Ovanstående uppräkning beskrivs som en oupptäckt uppräkning, och dess uppräkare beskrivs som oupptäckta uppräkare. Detta beror på att det bara börjar med det reserverade ordet, enum. Uppräkningar som börjar med enum-klass eller enum-struktur beskrivs som omfattande uppräkningar. Deras räknare beskrivs som omfattande räknare.

Omfattande uppräkning
Följande uttalande är OK:

enum klass nam a, b, c = b + 2;

Detta är ett exempel på en omfattande uppräkning. Namnet på klassen är nam. Här börjar räknarens räckvidd från deklarationspunkten till slutet av uppräkningsdefinitionen, och inte slutet på det omslutande blocket för uppräkningen. Följande kod kompileras inte:

om (1 == 1)

enum klass nam a, b, c = b + 2;
cout<

Klassomfång

Med normal omfattning börjar den deklarativa regionen från en punkt, fortsätter sedan och stannar vid en annan punkt. Omfattningen finns i en kontinuerlig region. Med klassen kan omfattningen av en enhet vara i olika regioner som inte är sammanfogade. Reglerna för kapslade block gäller fortfarande. Följande program illustrerar detta:

#omfatta
använder namnrymd std;
// Basklass
klass Cla

privat:
int memP = 5;
skyddad:
int memPro = 9;
offentlig:
ogiltigt fn ()

cout<
;
// härledd klass
klass DerCla: allmän Cla

offentlig:
int derMem = memPro;
;
int main ()

Cla obj;
obj.fn ();
DerCla derObj;
cout<returnera 0;

Utgången är:
5
9

I klassen Cla, variabeln memP, ses vid deklarationspunkten. Efter det hoppas över den korta delen av "skyddad" och ses sedan igen i klassmedlemmens funktionsblock. Den härledda klassen hoppas över och ses sedan igen vid huvudområdet () funktionsomfång (block).

I klassen Cla, variabeln memPro, ses vid deklarationspunkten. Den del av den offentliga funktionen fn () hoppas över och ses sedan i det härledda klassbeskrivningsblocket. Det ses igen nere i huvudfunktionen ().

Scope Resolution Operator
Omfattningsupplösningsoperatören i C ++ är :: . Den används för att komma åt en statisk medlem i klassen. Följande program illustrerar detta:

#omfatta
använder namnrymd std;
klass Cla

offentlig:
statisk int const mem = 5;
offentlig:
statiskt tomrum fn ()

cout<
;
int main ()

cout<Cla :: fn ();
returnera 0;

Utgången är:
5
5

De statiska medlemmarna ses i huvudfunktionsblocket (), nås med operatören för omfångsupplösning.

Template Parameter Scope

Det normala omfånget för ett mallparameternamn börjar från deklarationspunkten till slutet av blocket, som i följande kod:

mall struct Åldrar

T John = 11;
U Peter = 12.3;
T Mary = 13;
U Joy = 14.6;
;

U och T ses inom blocket.

För en mallfunktionsprototyp börjar omfattningen från deklarationspunkten till slutet av funktionsparameterlistan, som i följande uttalande:

mall void func (T no, U cha, const char * str);

Men när det gäller klassbeskrivningen (definition) kan omfattningen också ha olika delar som i följande kod:

#omfatta
använder namnrymd std;
mall klass TheCla

offentlig:
T num;
statisk U ch;
void func (U cha, const char * str)

cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';

statisk tomrumskul (U ch)

om (ch == 'a')
cout << "Official static member function" << '\n';

;
int main ()

TheCla obj;
obj.num = 12;
obj.funk ('$', "500");
returnera 0;

Namn gömmer sig

Ett exempel på namngömning inträffar när namnet på samma objekttyp deklareras i ett kapslat block. Följande program illustrerar detta:

#omfatta
använder namnrymd std;
ogiltigt fn ()

int var = 3;
om (1 == 1)

int var = 4;
cout<
cout<
int main ()

fn ();
returnera 0;

Utgången är:
4
3

Det beror på att var i det kapslade blocket gömde var i det yttre blocket.

Möjlighet att upprepa deklarationen i samma omfattning

Poängen med deklarationen är där namnet införs (för första gången) i dess omfattning.

Funktionsprototyp
Olika enheter, även av olika typer, kan normalt inte deklareras i samma omfattning. En funktionsprototyp kan dock deklareras mer än en gång i samma omfattning. Följande program med två funktionsprototyper och motsvarande funktionsdefinition illustrerar detta:

#omfatta
använder namnrymd std;
ogiltigt fn (int num);
ogiltigt fn (int num);
ogiltigt fn (int num)

cout<
int main ()

fn (5);
returnera 0;

Programmet fungerar.

Överbelastade funktioner
Överbelastade funktioner är funktioner med samma namn men olika funktionssignaturer. Som ett annat undantag kan överbelastade funktioner med samma namn definieras i samma omfång. Följande program illustrerar detta:

#omfatta
använder namnrymd std;
ogiltigt fn (int num)

cout<
void fn (float no)

cout<
int main ()

fn (5);
float flt = 8.7;
fn (flt);
returnera 0;

Utgången är:
5
8.7

De överbelastade funktionerna har definierats i det globala omfånget.

Namnområdets omfattning

Namespace Scope förtjänar sin egen artikel. Nämnda artikel har skrivits för denna webbplats, linuxhint.com. Skriv bara sökorden "Namespace Scope" i sökrutan på den här webbplatsen (sidan) och klicka på OK så får du artikeln.

Omfattning i olika delar

Klassen är inte det enda schemat där omfattningen kan vara i olika delar. Vänsspecifikator, vissa användningsområden för den utarbetade typspecifikatorn och användningsdirektiv är andra scheman där omfattningen finns på olika platser - för detaljer, se senare.

Slutsats

Ett omfång är en deklarativ region. En deklarativ region är den största delen av en programtext där namnet på en enhet är giltig. Den kan delas in i mer än en del i enlighet med vissa programmeringsscheman, såsom kapslade block. De delar som inte har deklarationspunkten utgör det potentiella omfånget. Det potentiella omfånget kan eller kanske inte ha deklarationen.