Omfang i C ++

En enhet i C ++ har et navn, som kan erklæres 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. Et deklarativt område 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 om C ++ påkrevd for å forstå denne artikkelen.

Artikkelinnhold

• Erklærende region og omfang
• Globalt omfang
• Globale variabler og globalt omfang
• Blokkomfang
• Funksjonsomfang
• Klasseomfang
• Oppregningsomfang
• Global variabel
• Malparameteromfang
• Navn gjemmer
• Mulighet for å gjenta erklæring i samme omfang
• Navneområde omfang
• Omfang i forskjellige porsjoner
• Konklusjon

Erklærende region og omfang

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

#inkludere
ved hjelp av navneområdet STD;
ugyldig fn ()

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

cout<

int main ()

fn ();
retur 0;

Funksjonen fn () har to blokker: en indre blokk for IF-kondisjonen og en ytre blokk for funksjonskroppen. Identifikatoren, VAR, blir introdusert og sett i den ytre blokken. Det sees også i den indre blokken, med cout -uttalelsen. De ytre og indre blokker er omfanget av navnet, var.

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

#inkludere
ved hjelp av navneområdet STD;
ugyldig fn ()

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

Float var = 7.5;
cout<

int main ()

fn ();
retur 0;

Utgangen er

7.5

I dette tilfellet kan navnet, VaR, ikke lenger brukes i den indre blokken for å referere til verdien 3, som ble introdusert (erklært) i den ytre blokken. Slike indre blokker blir referert til som potensielt rom for enheter som er erklært i den ytre blokken.

Merk: En enhet av samme type, som den ytre blokken, kan fremdeles erklæres i den indre blokken. I dette tilfellet er den nye erklæringen og dens betydning imidlertid gyldig i den indre blokken, mens den gamle erklæringen og betydningen utenfor den indre blokken bare er 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 begynner å skrive en fil, er det det globale omfanget. Følgende korte program illustrerer dette:

#inkludere
ved hjelp av navneområdet STD;
Float var = 9.4;
int main ()

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

Utgangen er:

9.4
9.4

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

Blokken av 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 forut for omfangsoppløsningsoperatøren ::: .

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

Blokkomfang

IF, mens, gjør, for eller bryter uttalelser, kan hver definere en blokk. En slik uttalelse er en sammensatt uttalelse. Navnet på en variabel erklært i en blokk har en blokkens omfang. Omfanget begynner på dets erklæring og slutter på slutten av blokken. Følgende korte program illustrerer dette for variabelen, Ident:

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

if (1 == 1)

/*Noen utsagn*/
int identitet = 5;
cout</*Noen utsagn*/

retur 0;

En variabel, for eksempel identitet, erklært i blokkomfang er en lokal variabel.

En variabel erklært utenfor blokkomfanget og over den kan sees i blokkens overskrift (E.g., betingelse for if-block) og innenfor blokken. Følgende korte program illustrerer dette for variabelen, Identif:

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

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

cout<
retur 0;

Utgangen er,

8

Det er to blokkomfang: blokken for hoved () -funksjonen og den nestede IF-Compound-uttalelsen. Den nestede blokken er det potensielle omfanget av hovedfunksjonsblokken ().

En erklæring introdusert i et blokkomfang kan ikke sees utenfor blokken. Følgende korte program, som ikke kompilerer, illustrerer dette med variabelen, variab:

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

if (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 (nedenfor) den sammensatte uttalelsen. Følgende for-loop-kode vil ikke sammenstille, noe som resulterer i en feilmelding:

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

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

cout<
cout<return 0;

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

Funksjonsomfang

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

#inkludere
#inkludere
ved hjelp av navneområdet STD;
String fn (String str)

char stri [] = "bananer";
/*Andre uttalelser*/
streng totalstr = str + stri;
Returner totalstr;

int main ()

streng totstr = fn ("spising");
cout<retur 0;

Utgangen er:

Spiser bananer

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

Merkelapp

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

#inkludere
ved hjelp av navneområdet STD;
ugyldig fn ()

goto lable;
/*Andre uttalelser*/
Labl: int inte = 2;
cout<
int main ()

fn ();
retur 0;

Utgangen er

2

Klasseomfang

Med normal omfang begynner den deklarative regionen fra ett punkt i programmet, fortsetter og stopper på et annet punkt. Omfanget eksisterer i en kontinuerlig region. Med klassen kan omfanget av en enhet være i forskjellige regioner som ikke er sammen med sammen. Reglene for nestede blokker gjelder fortsatt. Følgende program illustrerer dette:

#inkludere
ved hjelp av navneområdet 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, den variable mempen, sees på erklæringspunktet. Etter det blir den korte delen av "beskyttet" hoppet over og sett igjen i klassemedlemsfunksjonsblokken. Den avledede klassen hoppes over og sett igjen på Main () funksjonsomfanget (blokkering).

I klassen CLA blir variabelen, Mempro, sett på erklæringspunktet. Den delen av den offentlige funksjonen fn () blir hoppet over, og deretter sett i den avledede klassebeskrivelsesblokken. Det sees igjen nede i hoved () -funksjonen.

Operatøroppløsningsoperatør

Operatøren for oppløsningsoppløsning i C ++ er :: . Det brukes til å få tilgang til et statisk medlem av klassen. Følgende program illustrerer dette:

#inkludere
ved hjelp av navneområdet 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 blir sett i hovedfunksjonsblokken (), åpnet ved hjelp av omfangsoppløsningsoperatøren.

Oppregningsomfang

Usikret oppregning

Tenk på følgende if-block:

if (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 tellerne. Omfanget av en oppregner begynner fra punktet med erklæringen, til slutten av den omsluttende blokken av oppregningen.

Følgende uttalelse vil ikke sammenstille fordi erklæringspunktet for C er etter A:

enum a = c+2, b, c;

Følgende kodesegment vil ikke sammenstille fordi tellerne er tilgjengelig etter den vedlagte blokken av oppregningen:

if (1 == 1)

enum a, b, c = b+2;

cout<

Den forrige oppregningen beskrives som en ustoppet oppregning, og dens oppregninger er definert som usikre oppregning. Dette er fordi det bare begynner med det reserverte ordet, enum. Oppregninger som begynner med enum -klasse eller enumstruktur, beskrives som scoped oppregninger. Deres oppregere er definert som scoped -tallerkener.

Scoped oppregling

Følgende uttalelse er OK:

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

Dette er et eksempel på en scoped oppregning. Navnet på klassen er Nam. Her begynner omfanget av oppregningen fra erklæringspunktet til slutten av oppregningsdefinisjonen og ikke slutten på den omsluttende blokken for oppregningen. Følgende kode vil ikke sammenstille:

if (1 == 1)

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

Enkel bruk av scoped oppregning

Følgende kode viser en enkel måte å bruke scoped oppregning på:

if (1 == 1)

enum nam a, b, c = b+2;
cout << c << endl; //simple usage

Utgangen er 3, siden B er 1 ('A' er 0).

Global variabel

En global variabel er en variabel erklært i det globale omfanget. Når en programmerer begynner å skrive en fil, er det det globale omfanget. Tenk på følgende program:

#inkludere
ved hjelp av navneområdet STD;
char va = 'a';
int main ()

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

Utgangen er:

EN
EN

I dette programmet starter delen eller omfanget for VA fra Deklarasjon av VA og fortsetter nedover til slutten av oversettelsesenheten (fil).

Hovedfunksjonens kropp er et annet omfang i seg selv; Det globale omfanget hekker hovedfunksjonen ().

Variabel VA er en global omfangsvariabel eller ganske enkelt global variabel fordi den kan sees overalt i filen, fra hvor den er erklært. Det kan sees i hovedfunksjonen ().

For å få tilgang til en global variabel (variabel av det globale omfanget) fra et annet omfang, brukes variabelnavnet direkte eller forut for omfangsoppløsningsoperatøren :: Som vist i programmet ovenfor.

IF, mens, gjør, for eller bryterklæring, kan hver definere en blokk. En slik uttalelse er en sammensatt uttalelse. Navnet på en variabel erklært i en blokk har en blokkens omfang. Omfanget begynner på dets erklæring og slutter på slutten av blokken. Følgende korte program illustrerer dette for variabelen, Ident:

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

if (1 == 1)

/*Noen utsagn*/
int identitet = 5;
cout</*Noen utsagn*/

retur 0;

En variabel, for eksempel identitet, erklært i blokkomfang er en lokal variabel.

En variabel erklært utenfor blokkomfanget og over den kan sees i blokkens overskrift (E.g., betingelse for if-block) og innenfor blokken. Følgende korte program illustrerer dette for variabelen, Identif:

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

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

cout<
retur 0;

Utgangen er,

8

Det er to blokkomfang her: blokken for hoved () -funksjonen og den nestede IF-Compound-uttalelsen. Den nestede blokken er det potensielle omfanget av hovedfunksjonsblokken ().

En erklæring introdusert i et blokkomfang kan ikke sees utenfor blokken. Følgende korte program, som ikke kompilerer, illustrerer dette med variabelen, variab:

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

if (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 (nedenfor) den sammensatte uttalelsen. Følgende for-loop-kode vil ikke sammenstille, noe som resulterer i en feilmelding:

#inkludere
ved hjelp av navneområdet 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.

En variabel erklært i det globale omfanget er en global variabel. Det kan sees i et blokkomfang. Følgende program illustrerer dette:

#inkludere
ved hjelp av navneområdet STD;
int GLB = 5;
int main ()

cout << glb << endl;
retur 0;

Utgangen er 5.

Omfordeling ikke tillatt i globalt omfang

I forrige program, uttalelsen:

int GLB = 5;

Det er en erklæring med initialisering (første tildeling av verdi) samtidig. I det følgende programmet er uttalelsen "int GLB;" har null tilordnet det som standard. Linjen etter (GLB = 5;) Prøver omfordeling av verdien, 5, i det globale omfanget. Dette skaper en feil, og programmet sammenstiller ikke. Programmet er:

#inkludere
ved hjelp av navneområdet STD;
int glb;
GLB = 5;
int main ()

cout << glb << endl;
retur 0;

Omfordeling vil imidlertid finne sted i et lokalt (blokk) omfang, som vist i følgende program:

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

if (1 == 1)
GLB = 5;
cout << glb << endl;

retur 0;

Utgangen er 5.

Global peker

Når en peker blir erklært i det globale omfanget, kan den sees i et nestet omfang. En peker erklært i et nestet omfang kan ikke sees utenfor det nestede omfanget. Det er to måter å erklære en peker. En peker kan deklareres med et praktisk oppdrag (av en adresse). En peker kan erklæres uten praktisk oppgave. Hvis pekeren blir erklært uten praktisk oppgave i det globale omfanget, kan den ikke tilordnes i det globale omfanget. I dette tilfellet kan det imidlertid tilordnes i et nestet omfang.

Global matrise

Når en matrise er erklært i det globale omfanget, kan den sees i et nestet omfang. En matrise erklært i et nestet omfang, kan ikke sees utenfor det nestede omfanget. Det er to måter å erklære en matrise. En matrise kan deklareres med en praktisk oppgave (av en adresse). En matrise kan erklæres uten praktisk oppgave. Hvis matrisen er deklarert uten praktisk oppgave i det globale omfanget, kan det ikke tilordnes i det globale omfanget. Imidlertid kan det tilordnes i et nestet omfang (element etter element).

Malparameteromfang

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

mal Struktur aldre

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

U og t sees i blokken.

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

mal void func (t nei, u cha, const char *str);

Når det gjelder klassebeskrivelsen (definisjonen), kan imidlertid omfanget også være av forskjellige deler, som i følgende eksempelprogram:

#inkludere
ved hjelp av navneområdet 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 (u ch)

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

;
int main ()

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

Navn gjemmer

Et eksempel på skjul på navn oppstår når navnet på samme objekttype er påklart i en nestet blokk. Følgende program illustrerer dette:

#inkludere
ved hjelp av navneområdet STD;
ugyldig fn ()

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

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

fn ();
retur 0;

Utgangen er:

4
3

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

Mulighet for å gjenta erklæring i samme omfang

Poenget med erklæringen er der navnet blir introdusert (for første gang) i omfanget.

Funksjonsprototype

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

#inkludere
ved hjelp av navneområdet STD;
void fn (int num);
void fn (int num);
void fn (int num)

cout<
int main ()

fn (5);
retur 0;

Programmet fungerer.

Overbelastede funksjoner

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

#inkludere
ved hjelp av navneområdet STD;
void fn (int num)

cout<
void fn (float nei)

cout<
int main ()

fn (5);
FLOAT FLT = 8.7;
fn (flt);
retur 0;

Utgangen er:

5
8.7

De overbelastede funksjonene er definert i det globale omfanget.

Navneområde omfang

Siden to forskjellige variabler kan ha samme navn og for å skille dem, må variablene erklæres i to forskjellige navnefelt. Et navneområde er en blokk med et navn, som har sine egne navngitte enheter. Navnet på et navneområde er navnet på blokken. To forskjellige navnefelt kan ha enheter med samme navn. Følgende program illustrerer dette:

#inkludere
ved hjelp av navneområdet STD;
Navneområde na

Char CH1;
char ch2 = 'q';

Navnområde NB

Char CH1;
char ch2 = 'y';

int main ()

Na :: ch1 = 'p';
cout << NA::ch1 << endl;
Nb :: ch1 = 'x';
cout << NB::ch1 << endl;
retur 0;

Utgangen er:

P
X

Det er to navneområder: NA og NB. Det forhåndsdefinerte rommet for NA er dens blokk. Det forhåndsdefinerte rommet for NB er også dens blokk. Merk at enhetene i de to forskjellige blokkene har de samme navnene. For å erklære et navneområde, begynn med det reserverte ordet, navneområde; Et rom følger, deretter blokken med enhetene sine.

For å få tilgang til en enhet utenfor navneområdet, begynn med navnet på navneområdet. Dette blir fulgt av omfangsoppløsningsoperatøren og deretter navnet på enheten.

Omfanget av variabelen, Na :: CH1, begynner fra erklæringspunktet til CH1 i NA -blokken. Den ender på slutten av NA -blokken og vises deretter i hvilken som helst linje utenfor (og under) blokken, der "Na ::" brukes. Omfanget av variabelen, NB :: CH1, begynner fra erklæringspunktet til CH1 i NB -blokken. Den ender på slutten av NB -blokken og vises i hvilken som helst linje utenfor (og under) blokken, der "NB ::" brukes.

Et navneområdeomfang refererer til en enhet som er erklært i navneblokken. Omfanget av navneområdet er navneområdet og en hvilken som helst linje utenfor blokken som bruker navneområdet navn.

Omfang i forskjellige porsjoner

Den forrige klassen og navneområdet har illustrert hvordan et omfang kan være i forskjellige deler av programteksten. Et annet godt eksempel er vennens spesifikasjon.

Vennspesifikasjon

Hvis klasse C blir erklært som en venn for klasse A, i klasse A -definisjon, kan alle de offentlige medlemsfunksjonene til klasse C tilgang til de private datamedlemmer (og private medlemsfunksjoner) i klasse A. Følgende program illustrerer dette:

#inkludere
ved hjelp av navneområdet STD;
klasse A
privat: int d = 5;
venn klasse C;
;
klasse B
/*
offentlig: int fb ()
A a;
returner a.d;

*/
;
klasse C
offentlig: int fc ()
A a;
returner a.d;

;
int main ()

A a;
B B;
C C;
// int ret1 = b.fb ();
int ret2 = c.fc ();
cout << ret2 << endl;
retur 0;

Utgangen er 5. I definisjonen av klasse A er klasse C erklært som en venn for klasse A. Så, FC () av ​​definisjon av klasse C, kan se D av definisjon av klasse A. Programmet kompilerer. Hvis kommentarsymbolene fjernes, vil ikke programmet sammenstille fordi klasse B ikke er erklært en venn til klasse A.

Omfanget av den private variabelen B begynner fra erklæringspunktet og slutter på slutten av klasse A -blokken. Det vises også i FC () -funksjonen i klasse C, som er en venn til klasse A. De to delene for omfanget er klasse A -blokken og FC () funksjonsblokken.

Konklusjon

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