Omfang i C ++

En enhed i C ++ har et navn, der kan erklæres og / eller defineres. En erklæring er en definition, men en definition er ikke nødvendigvis en erklæring. En definition tildeler hukommelse til den navngivne enhed, men en erklæring tildeler måske eller måske ikke hukommelse til den navngivne enhed. En erklærende region er den største del af et program, hvor navnet på en enhed (variabel) er gyldig. Denne region kaldes et omfang eller et potentielt omfang. Denne artikel forklarer scoping i C++. Desuden er grundlæggende viden i C ++ nødvendig for at forstå denne artikel.

Artikelindhold

Deklarativ region og anvendelsesområde
Globalt anvendelsesområde
Bloker anvendelsesområde
Funktionsomfang
Tællingsomfang
Klassens omfang
Template Parameter Scope
Navn gemmer sig
Mulighed for gentagelse af erklæring i samme omfang
Navneområde Anvendelsesområde
Anvendelsesområde i forskellige portioner
Konklusion

Deklarativ region og anvendelsesområde

En erklærende region er den største del af en programtekst, hvor navnet på en enhed er gyldig. Det er regionen, hvor det ukvalificerede navn kan bruges (set) til at henvise til den samme enhed. Overvej følgende korte program:

#omfatte
ved hjælp af namespace std;
ugyldigt fn ()

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

cout<

int main ()

fn ();
returnere 0;

Funktionen fn () har to blokke: en indre blok til if-tilstanden og en ydre blok til funktionskroppen. Identifikatoren, var, introduceres og ses i den ydre blok. Det ses også i den indre blok med cout-erklæringen. De ydre og indre blokke er begge omfanget for navnet, var.

Navnet, var, kan dog stadig bruges til at erklære en anden enhed, såsom en svømmer i den indre blok. Følgende kode illustrerer dette:

#omfatte
ved hjælp af namespace std;
ugyldigt fn ()

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

flyde var = 7.5;
cout<

int main ()

fn ();
returnere 0;

Outputtet er 7.5. I dette tilfælde kan navnet, var, ikke længere bruges i den indre blok til at henvise til heltal af værdi 3, som blev introduceret (erklæret) i den ydre blok. Sådanne indre blokke omtales som potentielt omfang for enheder, der er erklæret i den ydre blok.

Bemærk: En enhed af samme type som den ydre blok kan stadig erklæres i den indre blok. Men i dette tilfælde er det gyldige i den indre blok den nye erklæring og dens betydning, mens den gamle erklæring og dens betydning uden for den indre blok forbliver gyldig i den ydre blok.

En erklæring med samme navn i en indre blok tilsidesætter normalt erklæringen af det samme navn uden for den indre blok. Indvendige blokke kan reden andre indre blokke.

Globalt anvendelsesområde

Når en programmør bare begynder at skrive en fil, er det det globale omfang. Følgende korte program illustrerer dette:

#omfatte
ved hjælp af namespace std;
flyde var = 9.4;
int main ()

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

Outputtet er:
9.4
9.4

I dette tilfælde begynder den deklarative region eller omfanget for var fra erklæringspunktet for var, fortsætter nedad til slutningen af filen (oversættelsesenhed).

Blokken for hovedfunktionen () har et andet omfang; det er et indlejret omfang for det globale omfang. For at få adgang til en enhed af det globale omfang, fra et andet omfang, bruges identifikatoren direkte eller forud for omfangsopløsningsoperatoren, :: .

Bemærk: Enheden, main (), erklæres også i det globale omfang.

Bloker anvendelsesområde

Erklæringen if, while, do, for eller switch kan hver definere en blok. En sådan erklæring er en sammensat erklæring. Navnet på en variabel, der er deklareret i en blok, har en blocks rækkevidde. Dets anvendelsesområde begynder ved sit erklæringssted og slutter ved slutningen af dens blokering. Følgende korte program illustrerer dette for variablen, ident:

#omfatte
ved hjælp af namespace std;
int main ()

hvis (1 == 1)

/ * nogle udsagn * /
int ident = 5;
cout</ * nogle udsagn * /

returnere 0;

En variabel, såsom ident, deklareret ved blokomfang er en lokal variabel.

En variabel, der er erklæret uden for blokområdet, og derover, kan ses i blokens overskrift (e.g., betingelse for if-blok) og også inden for blokken. Følgende korte program illustrerer dette for variablen, ident:

#omfatte
ved hjælp af namespace std;
int main ()

int ident = 8;
hvis (ident == 8)

cout<
returnere 0;

Outputtet er 8. Der er to blokomfang her: blokken til hovedfunktionen () og den indlejrede if-compound-sætning. Den indlejrede blok er det potentielle omfang af hovedfunktionsblokken ().

En erklæring, der er indført i blokområdet, kan ikke ses uden for blokken. Følgende korte program, som ikke kompileres, illustrerer dette med variablen variab:

#omfatte
ved hjælp af namespace std;
int main ()

hvis (1 == 1)

int variab = 15;

cout<returnere 0;

Compileren producerer en fejlmeddelelse for variab.

En enhed, der er introduceret, deklareret i overskriften på en sammensat funktion, kan ikke ses udenfor (nedenfor) sammensætningen. Følgende for-loop-kode kompileres ikke, hvilket resulterer i en fejlmeddelelse:

#omfatte
ved hjælp af namespace std;
int main ()

for (int i = 0; i<4; ++i)

cout<
cout<returnere 0;

Iterationsvariablen, i, ses inde i for-loop-blokken, men ikke uden for for-loop-blokken.

Funktionsomfang

En funktionsparameter ses i funktionsblokken. En enhed, der er erklæret i en funktionsblok, ses fra erklæringspunktet til slutningen af funktionsblokken. Følgende korte program illustrerer dette:

#omfatte
#omfatte
ved hjælp af namespace std;
streng fn (streng str)

char stri [] = "bananer";
/ * andre udsagn * /
streng totalStr = str + stri;
returnere totalStr;

int main ()

streng totStr = fn ("spise");
cout<returnere 0;

Outputtet er:
spise bananer

Bemærk: En enhed, der er erklæret uden for funktionen (over den), kan ses i funktionsparameterlisten og også i funktionsblokken.

Etiket

Omfanget af en etiket er den funktion, den vises i. Følgende kode illustrerer dette:

#omfatte
ved hjælp af namespace std;
ugyldigt fn ()

goto labl;
/ * andre udsagn * /
labl: int inte = 2;
cout<
int main ()

fn ();
returnere 0;

Outputtet er 2.

Tællingsomfang

Uskopet optælling
Overvej følgende if-block:

hvis (1 == 1)

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

Outputtet er 0 1 3.

Den første linje i blokken er en optælling, a, b og c er dens tællere. Omfanget af en tæller begynder fra erklæringspunktet til slutningen af den vedlagte blok for tællingen.

Følgende udsagn kompileres ikke, fordi erklæringspunktet for c er efter a:

enum a = c + 2, b, c;

Følgende kodesegment kompileres ikke, fordi der er adgang til tællerne efter den opsluttende blok for tællingen:

hvis (1 == 1)

enum a, b, c = b + 2;

cout<Ovenstående opregning er beskrevet som en upåvirket optælling, og dens opregner er beskrevet som upåvirkede optællere. Dette skyldes, at det kun begynder med det reserverede ord, enum. Tællinger, der begynder med enum-klasse eller enum-struktur, beskrives som omfangsrige tællinger. Deres tællere beskrives som en række tællere.

Omfattende optælling
Følgende udsagn er OK:

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

Dette er et eksempel på en kort rækkevidde. Navnet på klassen er nam. Her begynder optællingsomfanget fra erklæringspunktet til slutningen af optællingsdefinitionen og ikke slutningen af den vedlagte blok til optællingen. Følgende kode kompileres ikke:

hvis (1 == 1)

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

Klassens omfang

Ved normal afgrænsning begynder den deklarative region fra et punkt og fortsætter derefter og stopper ved et andet punkt. Omfanget findes i en kontinuerlig region. Med klassen kan omfanget af en enhed være i forskellige regioner, der ikke er sammenføjet. Reglerne for indlejrede blokke gælder stadig. Følgende program illustrerer dette:

#omfatte
ved hjælp af namespace std;
// Basisklasse
klasse Cla

privat:
int memP = 5;
beskyttet:
int memPro = 9;
offentlig:
ugyldigt fn ()

cout<
;
// Afledt klasse
klasse DerCla: offentlig Cla

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

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

Outputtet er:
5
9

I klassen Cla, variablen memP, ses på erklæringsstedet. Derefter springes den korte del af "beskyttet" over og ses derefter igen i klassemedlems funktionsblok. Den afledte klasse springes over og ses derefter igen i hovedområdet () funktionsomfang (blok).

I klassen Cla, variablen memPro, ses på erklæringsstedet. Den del af den offentlige funktion fn () springes over og ses derefter i den afledte klassebeskrivelsesblok. Det ses igen nede i hovedfunktionen ().

Scope Resolution Operator
Omfangsopløsningsoperatoren i C ++ er :: . Det bruges til at få adgang til et statisk medlem af klassen. Følgende program illustrerer dette:

#omfatte
ved hjælp af namespace std;
klasse Cla

offentlig:
statisk int konstmem = 5;
offentlig:
statisk tomrum fn ()

cout<
;
int main ()

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

Outputtet er:
5
5

De statiske medlemmer ses i hovedfunktionsblokken (), der åbnes ved hjælp af operatøren for omfangsopløsning.

Template Parameter Scope

Det normale omfang for et skabelonparameters navn begynder fra erklæringspunktet til slutningen af dets blok, som i følgende kode:

skabelon struct Ages

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

U og T ses inden for blokken.

For en prototype til en skabelonfunktion begynder omfanget fra erklæringspunktet til slutningen af funktionsparameterlisten som i følgende udsagn:

skabelon ugyldig funk (T no, U cha, const char * str);

Men når det kommer til klassebeskrivelsen (definition), kan omfanget også have forskellige dele som i følgende kode:

#omfatte
ved hjælp af namespace std;
skabelon klasse TheCla

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

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

statisk tomrums sjov (U ch)

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

;
int main ()

TheCla obj;
obj.num = 12;
obj.func ('$', "500");
returnere 0;

Navn gemmer sig

Et eksempel på skjulte navne opstår, når navnet på den samme objekttype bliver deklareret i en indlejret blok. Følgende program illustrerer dette:

#omfatte
ved hjælp af namespace std;
ugyldigt fn ()

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

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

fn ();
returnere 0;

Outputtet er:
4
3

Det er fordi var i den indlejrede blok skjulte var i den ydre blok.

Mulighed for gentagelse af erklæring i samme omfang

Pointen med erklæringen er, hvor navnet introduceres (for første gang) inden for dets anvendelsesområde.

Funktionsprototype
Forskellige enheder, selv af forskellige typer, kan normalt ikke erklæres i samme omfang. En funktionsprototype kan dog erklæres mere end én gang i samme omfang. Følgende program med to funktionsprototyper og tilsvarende funktionsdefinition illustrerer dette:

#omfatte
ved hjælp af namespace std;
ugyldigt fn (int num);
ugyldigt fn (int num);
ugyldigt fn (int num)

cout<
int main ()

fn (5);
returnere 0;

Programmet fungerer.

Overbelastede funktioner
Overbelastede funktioner er funktioner med samme navn, men forskellige funktionssignaturer. Som en anden undtagelse kan overbelastede funktioner med samme navn defineres i samme omfang. Følgende program illustrerer dette:

#omfatte
ved hjælp af namespace std;
ugyldigt fn (int num)

cout<
ugyldigt fn (float no)

cout<
int main ()

fn (5);
flyde flt = 8.7;
fn (flt);
returnere 0;

Outputtet er:
5
8.7

De overbelastede funktioner er defineret i det globale omfang.

Navneområde Anvendelsesområde

Namespace Scope fortjener sin egen artikel. Den nævnte artikel er skrevet til dette websted, linuxhint.com. Indtast bare søgeordene "Navneområdet" i søgefeltet på dette websted (side) og klik på OK, så får du artiklen.

Anvendelsesområde i forskellige portioner

Klassen er ikke den eneste ordning, hvor omfanget kan være i forskellige dele. Vennespecifikator, visse anvendelser af den udførlige type-specifikator og brugsdirektiver er andre ordninger, hvor omfanget er forskellige steder - for detaljer, se senere.

Konklusion

Et omfang er en erklærende region. En erklærende region er den største del af en programtekst, hvor navnet på en enhed er gyldig. Det kan opdeles i mere end en del i overensstemmelse med visse programmeringsplaner, såsom indlejrede blokke. De dele, der ikke har erklæringspunktet, danner det potentielle omfang. Det potentielle anvendelsesområde kan eller ikke have erklæringen.