Omfang i C ++

En enhet i C ++ har et navn som kan deklareres og / eller defineres. En erklæring er en definisjon, men en definisjon er ikke nødvendigvis en erklæring. En definisjon tildeler minne for den navngitte enheten, men en erklæring kan eller ikke tildele minne for den navngitte enheten. En erklærende region er den største delen av et program der navnet på en enhet (variabel) er gyldig. Den regionen kalles et omfang eller et potensielt omfang. Denne artikkelen forklarer scoping i C++. Videre er grunnleggende kunnskap i C ++ nødvendig for å forstå denne artikkelen.

Artikkelinnhold

Deklarativ region og omfang
Globalt omfang
Blokkere omfang
Funksjonens omfang
Oppregningsomfang
Klassens omfang
Mal Parameter Omfang
Navn gjemmer seg
Mulighet for å gjenta erklæring i samme omfang
Navneplassens omfang
Omfang i forskjellige porsjoner
Konklusjon

Deklarativ region og omfang

En erklærende region er den største delen av en programtekst der navnet på en enhet er gyldig. Det er regionen der det ukvalifiserte navnet kan brukes (sett) for å referere til den samme enheten. Tenk på følgende korte program:

#inkludere
bruker navneområde std;
ugyldig fn ()

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

cout<

int main ()

fn ();
retur 0;

Funksjonen fn () har to blokker: en indre blokk for if-tilstanden og en ytre blokk for funksjonslegemet. Identifikatoren, var, blir introdusert og sett i den ytre blokken. Det sees også i den indre blokken, med cout-uttalelsen. De ytre og indre blokkene er begge omfanget for navnet, var.

Imidlertid kan navnet, var, fortsatt brukes til å erklære en annen enhet, for eksempel en flottør i den indre blokken. Følgende kode illustrerer dette:

#inkludere
bruker navneområde std;
ugyldig fn ()

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

flyte var = 7.5;
cout<

int main ()

fn ();
retur 0;

Utgangen er 7.5. I dette tilfellet kan ikke navnet, var, lenger brukes i den indre blokken for å referere til heltallet av verdi 3, som ble introdusert (erklært) i den ytre blokken. Slike indre blokker blir referert til som potensielt omfang for enheter som er erklært i den ytre blokken.

Merk: En enhet av samme type, som den for den ytre blokken, kan fortsatt deklareres i den indre blokken. I dette tilfellet er det som er gyldig i den indre blokken den nye erklæringen og dens betydning, mens den gamle erklæringen og dens betydning utenfor den indre blokken forblir gyldig i den ytre blokken.

En erklæring med samme navn i en indre blokk overstyrer normalt erklæringen med samme navn utenfor den indre blokken. Indre blokker kan hekke andre indre blokker.

Globalt omfang

Når en programmerer bare begynner å skrive en fil, er det det globale omfanget. Følgende korte program illustrerer dette:

#inkludere
bruker navneområde std;
flyte var = 9.4;
int main ()

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

Utgangen er:
9.4
9.4

I dette tilfellet begynner den deklarative regionen eller omfanget for var fra erklæringspunktet for var, fortsetter nedover til slutten av filen (oversettelsesenhet).

Blokken til hovedfunksjonen () er et annet omfang; det er et nestet omfang for det globale omfanget. For å få tilgang til en enhet av det globale omfanget, fra et annet omfang, brukes identifikatoren direkte eller foran operatøren av omfangsoppløsningen: .

Merk: Enheten, main (), er også erklært i det globale omfanget.

Blokkere omfang

Uttalelsen if, while, do, for eller switch kan definere hver blokk. En slik uttalelse er en sammensatt uttalelse. Navnet på en variabel deklarert i en blokk har blokkens omfang. Dets omfang begynner ved erklæringspunktet og slutter på slutten av blokkeringen. Følgende korte program illustrerer dette for variabelen, ident:

#inkludere
bruker navneområde std;
int main ()

hvis (1 == 1)

/ * noen uttalelser * /
int ident = 5;
cout</ * noen uttalelser * /

retur 0;

En variabel, for eksempel ident, deklarert ved blokkomfang er en lokal variabel.

En variabel som er erklært utenfor blokkområdet og over den, kan sees i overskriften på blokken (f.eks.g., betingelse for if-block) og også innenfor blokken. Følgende korte program illustrerer dette for variabelen, identif:

#inkludere
bruker navneområde std;
int main ()

int identif = 8;
hvis (identif == 8)

cout<
retur 0;

Utgangen er 8. Det er to blokkomfang her: blokken for hovedfunksjonen () og den nestede if-compound-setningen. Den nestede blokken er det potensielle omfanget til hovedfunksjonen ().

En erklæring innført i blokkområde kan ikke sees utenfor blokken. Følgende korte program, som ikke kompilerer, illustrerer dette med variabelen, variab:

#inkludere
bruker navneområde std;
int main ()

hvis (1 == 1)

int variab = 15;

cout<retur 0;

Kompilatoren produserer en feilmelding for variab.

En enhet introdusert, erklært i overskriften til en sammensatt funksjon, kan ikke sees utenfor (under) sammensetningen. Følgende for-loop-kode kompileres ikke, noe som resulterer i en feilmelding:

#inkludere
bruker navneområde std;
int main ()

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

cout<
cout<retur 0;

Iterasjonsvariabelen, i, sees inne i for-loop-blokken, men ikke utenfor for-loop-blokken.

Funksjonsomfang

En funksjonsparameter ses i funksjonsblokken. En enhet erklært i en funksjonsblokk ses fra erklæringspunktet til slutten av funksjonsblokken. Følgende korte program illustrerer dette:

#inkludere
#inkludere
bruker navneområde std;
streng fn (streng str)

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

int main ()

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

Utgangen er:
spise bananer

Merk: En enhet som er erklært utenfor funksjonen (over den) kan sees i funksjonsparameterlisten og også i funksjonsblokken.

Merkelapp

Omfanget av en etikett er funksjonen den vises i. Følgende kode illustrerer dette:

#inkludere
bruker navneområde std;
ugyldig fn ()

gå til labl;
/ * andre uttalelser * /
labl: int inte = 2;
cout<
int main ()

fn ();
retur 0;

Utgangen er 2.

Oppregningsomfang

Uskopert oppregning
Vurder følgende if-block:

hvis (1 == 1)

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

Utgangen er 0 1 3.

Den første linjen i blokken er en oppregning, a, b og c er dens teller. Omfanget av en oppteller begynner fra erklæringspunktet til slutten av den omsluttende oppslagsblokken.

Følgende uttalelse vil ikke kompileres fordi erklæringspunktet for c er etter a:

enum a = c + 2, b, c;

Følgende kodesegment kompileres ikke fordi det er tilgang til tellerne etter den omsluttende blokken for opptellingen:

hvis (1 == 1)

enum a, b, c = b + 2;

cout<Ovennevnte oppregning er beskrevet som en uprøvd oppregning, og dens opptellere er beskrevet som uprøvde oppteller. Dette fordi det bare begynner med det reserverte ordet enum. Oppregninger som begynner med enum-klasse eller enum-struktur, blir beskrevet som omfangsrike oppregninger. Deres teller er beskrevet som omfangsrike teller.

Omfattende oppregning
Følgende uttalelse er OK:

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

Dette er et eksempel på en omfattende oversikt. Navnet på klassen er nam. Her begynner omfanget av telleren fra erklæringspunktet til slutten av enumerasjonsdefinisjonen, og ikke slutten av den vedlagte blokken for opptellingen. Følgende kode samles ikke:

hvis (1 == 1)

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

Klassens omfang

Ved normal avgrensning begynner den deklarative regionen fra et punkt, fortsetter og stopper ved et annet punkt. Omfanget eksisterer i en sammenhengende region. Med klassen kan omfanget av en enhet være i forskjellige regioner som ikke er koblet sammen. Reglene for nestede blokker gjelder fortsatt. Følgende program illustrerer dette:

#inkludere
bruker navneområde std;
// Baseklasse
klasse Cla

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

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

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

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

Utgangen er:
5
9

I klassen Cla, variabelen memP, ses på erklæringspunktet. Deretter hoppes den korte delen av "beskyttet" og sees igjen i klasseblokkens funksjonsblokk. Den avledede klassen blir hoppet over, og så igjen på hovedområdet () funksjonsomfang (blokk).

I klassen Cla, variabelen memPro, ses på erklæringspunktet. Delen av den offentlige funksjonen fn () hoppes over, og sees deretter i den avledede klassebeskrivelsesblokken. Det sees igjen nede i hovedfunksjonen ().

Omfangsoppløsningsoperatør
Omfangsoppløsningsoperatøren i C ++ er :: . Den brukes til å få tilgang til et statisk medlem av klassen. Følgende program illustrerer dette:

#inkludere
bruker navneområde std;
klasse Cla

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

cout<
;
int main ()

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

Utgangen er:
5
5

De statiske medlemmene sees i hovedfunksjonen (), blokken er tilgjengelig ved bruk av operatøren for omfangsoppløsning.

Mal Parameter Omfang

Det normale omfanget av et malparameternavn begynner fra erklæringspunktet til slutten av blokken, som i følgende kode:

mal struct Ages

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

U og T sees innenfor blokken.

For en prototyp for malfunksjonen begynner omfanget fra erklæringspunktet til slutten av funksjonsparameterlisten, som i følgende uttalelse:

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

Imidlertid, når det gjelder klassebeskrivelsen (definisjon), kan omfanget også være av forskjellige deler som i følgende kode:

#inkludere
bruker navneområde std;
mal klasse 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 tomrom moro (U ch)

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

;
int main ()

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

Navn gjemmer seg

Et eksempel på skjuling av navn oppstår når navnet på den samme objekttypen blir erklært på nytt i en nestet blokk. Følgende program illustrerer dette:

#inkludere
bruker navneområde std;
ugyldig fn ()

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

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

fn ();
retur 0;

Utgangen er:
4
3

Det er fordi var i den nestede blokken skjulte var i den ytre blokken.

Mulighet for å gjenta erklæring i samme omfang

Poenget med erklæringen er hvor navnet introduseres (for første gang) i dets omfang.

Funksjon Prototype
Ulike enheter, selv av forskjellige typer, kan normalt ikke erklæres i samme omfang. Imidlertid kan en funksjonsprototype erklæres mer enn én gang i samme omfang. Følgende program med to funksjonsprototyper og tilhørende funksjonsdefinisjon illustrerer dette:

#inkludere
bruker navneområde std;
ugyldig fn (int num);
ugyldig fn (int num);
ugyldig fn (int num)

cout<
int main ()

fn (5);
retur 0;

Programmet fungerer.

Overbelastede funksjoner
Overbelastede funksjoner er funksjoner med samme navn, men forskjellige funksjonssignaturer. Som et annet unntak kan overbelastede funksjoner med samme navn defineres i samme omfang. Følgende program illustrerer dette:

#inkludere
bruker navneområde std;
ugyldig fn (int num)

cout<
void fn (float no)

cout<
int main ()

fn (5);
flyte flt = 8.7;
fn (flt);
retur 0;

Utgangen er:
5
8.7

De overbelastede funksjonene er definert i det globale omfanget.

Navneplassens omfang

Namespace Scope fortjener sin egen artikkel. Nevnte artikkel er skrevet for dette nettstedet, linuxhint.com. Bare skriv inn søkeordene "Namespace Scope" i søkefeltet på dette nettstedet (side) og klikk OK, så får du artikkelen.

Omfang i forskjellige porsjoner

Klassen er ikke den eneste ordningen der omfanget kan være i forskjellige porsjoner. Vennespesifikator, visse bruksområder for den utarbeidede type-spesifisereren og bruksdirektivene er andre ordninger der omfanget er forskjellige steder - for detaljer, se senere.

Konklusjon

Et omfang er en deklarativ region. En erklærende region er den største delen av en programtekst der navnet på en enhet er gyldig. Den kan deles inn i mer enn en del i samsvar med visse programmeringsskjemaer, for eksempel nestede blokker. Delene som ikke har deklarasjonspunktet, danner det potensielle omfanget. Det potensielle omfanget kan eller ikke ha erklæringen.