Artikkelinnhold
- Deklarativ region og virkeområde
- Globalt omfang
- Blokkere omfang
- Funksjon Omfang
- Opptelling Omfang
- Klasseomfang
- Mal Parameter Omfang
- Navn gjemmer seg
- Mulighet for å gjenta erklæringen i samme omfang
- Navneområde Omfang
- Omfang i forskjellige deler
- Konklusjon
Deklarativ region og virkeområde
En deklarativ 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. Vurder følgende korte program:
#inkludere
ved hjelp av navneområdetimer;
tomromfn()
{
inthvor= 3;
hvis (1==1)
{
koste<<hvor<<' n';
}
}
inthoved-()
{
fn();
komme tilbake 0;
}
Funksjonen fn () har to blokker: en indre blokk for if-tilstanden og en ytre blokk for funksjonskroppen. Identifikatoren, var, blir introdusert og sett i den ytre blokken. Det er også sett 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 å deklarere en annen enhet, for eksempel en flottør i den indre blokken. Følgende kode illustrerer dette:
#inkludere
ved hjelp av navneområdetimer;
tomromfn()
{
inthvor= 3;
hvis (1==1)
{
flytehvor= 7.5;
koste<<hvor<<' n';
}
}
inthoved-()
{
fn();
komme tilbake 0;
}
Utgangen er 7,5. I dette tilfellet kan navnet, var, ikke lenger brukes i den indre blokken for å referere til heltallet av verdi 3, som ble introdusert (deklarert) i den ytre blokken. Slike indre blokker omtales som potensielt omfang for enheter deklarert i den ytre blokken.
Merk: En enhet av samme type, som for den ytre blokken, kan fremdeles deklareres i den indre blokken. I dette tilfellet er det imidlertid 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 av 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:
#inkludereved hjelp av navneområdetimer;
flytehvor= 9.4;
inthoved-()
{
koste <<hvor<<' n';
koste <<::hvor<<' n';
komme tilbake 0;
}
Utgangen er:
9.4
9.4
I dette tilfellet begynner den deklarative regionen eller omfanget for var fra deklarasjonspunktet for var, fortsetter nedover til slutten av filen (oversettelsesenhet).
Blokken for 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 for omfangsoppløsning, ::.
Merk: Enheten, main (), er også deklarert i det globale omfanget.
Blokkere omfang
Hvis, mens, gjør, for eller bytter setning kan hver definere en blokk. En slik uttalelse er en sammensatt uttalelse. Navnet på en variabel som er deklarert i en blokk, har en blokkomfang. Omfanget begynner på erklæringspunktet og slutter ved slutten av blokken. Følgende korte program illustrerer dette for variabelen, ident:
#inkludereved hjelp av navneområdetimer;
inthoved-()
{
hvis (1==1)
{
/*noen utsagn*/
intident= 5;
koste<<ident<<' n';
/*noen utsagn*/
}
komme tilbake 0;
}
En variabel, for eksempel ident, erklært ved blokkomfang er en lokal variabel.
En variabel som er deklarert utenfor blokkens omfang og over den, kan sees i overskriften på blokken (f.eks. Betingelse for if-blokk) og også i blokken. Følgende korte program illustrerer dette for variabelen, identif:
#inkludereved hjelp av navneområdetimer;
inthoved-()
{
intidentif= 8;
hvis (identif== 8)
{
koste<<identif<<' n';
}
komme tilbake 0;
}
Utgangen er 8. Det er to blokkområder her: blokken for hovedfunksjonen () og den nestede if-compound-setningen. Den nestede blokken er det potensielle omfanget av hovedfunksjonen ().
En erklæring innført i et blokkomfang kan ikke sees utenfor blokken. Følgende korte program, som ikke kompilerer, illustrerer dette med variabelen, variab:
#inkludereved hjelp av navneområdetimer;
inthoved-()
{
hvis (1 == 1)
{
intvariab= femten;
}
koste<<variab<<' n'; // feil: åpnes utenfor omfanget.
komme tilbake 0;
}
Kompilatoren produserer en feilmelding for variab.
En enhet som er introdusert, erklært i overskriften til en sammensatt funksjon, kan ikke sees utenfor (under) den sammensatte setningen. Følgende for-loop-kode vil ikke kompilere, noe som resulterer i en feilmelding:
#inkludereved hjelp av navneområdetimer;
inthoved-()
{
til (intJeg=0;Jeg<4; ++Jeg)
{
koste<<Jeg<<'';
}
koste<<Jeg<<'';
komme tilbake 0;
}
Iterasjonsvariabelen, i, sees inne i for-loop-blokken, men ikke utenfor for-loop-blokken.
Funksjon Omfang
En funksjonsparameter vises i funksjonsblokken. En enhet som er deklarert i en funksjonsblokk, ses fra deklarasjonspunktet til slutten av funksjonsblokken. Følgende korte program illustrerer dette:
#inkludere#inkludere
ved hjelp av navneområdetimer;
streng fn(streng str)
{
røyestri[] = 'bananer';
/*andre utsagn*/
streng totalStr=s. s+stri;
komme tilbaketotalStr;
}
inthoved-()
{
streng totStr=fn('spiser ');
koste<<totStr<<' n';
komme tilbake 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:
#inkludereved hjelp av navneområdetimer;
tomromfn()
{
gå tillabl;
/*andre utsagn*/
labl: intikke= 2;
koste<<ikke<<' n';
}
inthoved-()
{
fn();
komme tilbake 0;
}
Utgangen er 2.
Opptelling Omfang
Ubegrenset oppregning
Vurder følgende if-block:
{
enum {a, b, c=b+2};
koste<<til<<''<<b<<''<<c<<' n';
}
Utgangen er 0 1 3.
Den første linjen i blokken er en oppregning, a, b og c er dens tellere. Omfanget av en teller begynner fra deklarasjonspunktet til slutten av den omsluttende blokken av oppregningen.
Følgende uttalelse vil ikke kompilere fordi erklæringspunktet for c er etter det for a:
enum {til=c+2, b, c};Følgende kodesegment vil ikke kompilere fordi det er tilgang til tellerne etter den omsluttende blokken i oppregningen:
hvis (1==1){
enum {a, b, c=b+2};
}
koste<<til<<''<<b<<''<<c<<' n'; // feil: utenfor omfanget
Ovennevnte oppregning beskrives som en ubegrenset oppregning, og dens oppregnere beskrives som uberegnede tellere. Dette er fordi det bare begynner med det reserverte ordet enum. Tall som begynner med enum klasse eller enum struct beskrives som omfangsregister. Tallene deres beskrives som omfangsregister.
Omfattet oppregning
Følgende uttalelse er OK:
Dette er et eksempel på en omfangsregistrering. Navnet på klassen er nam. Her begynner omfanget av telleren fra erklæringspunktet til slutten av oppregningsdefinisjonen, og ikke slutten på den vedlagte blokken for oppregningen. Følgende kode vil ikke kompilere:
hvis (1==1){
enum klassemann{a, b, c=b+2};
koste<<til<<''<<b<<''<<c<<' n'; // feil: utenfor omfanget av enum klasse eller enum struct
}
Klasseomfang
Ved normal omfang begynner den deklarative regionen fra et punkt, fortsetter deretter og stopper på 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:
#inkludereved hjelp av navneområdetimer;
// Grunnklasse
klasseCla
{
privat:
intmemP= 5;
beskyttet:
intmemPro= 9;
offentlig:
tomromfn()
{
koste<<memP<<' n';
}
};
// Avledet klasse
klasseDerCla: offentligCla
{
offentlig:
intderMem=memPro;
};
inthoved-()
{
Cla obj;
obj.fn();
DerCla derObj;
koste<<derObj.derMem<<' n';
komme tilbake 0;
}
Utgangen er:
5
9
I klassen Cla er variabelen memP sett på deklarasjonsstedet. Etter det blir den korte delen av beskyttet hoppet over, og deretter sett igjen i funksjonsblokken for klassemedlemmer. Den avledede klassen hoppes over, og sees deretter igjen ved hovedfunksjonens () funksjonsomfang (blokk).
I klassen Cla er variabelen memPro sett på deklarasjonsstedet. Delen av den offentlige funksjonen fn () hoppes over, og sees deretter i den avledede klassebeskrivelsesblokken. Det sees igjen nede i hovedfunksjonen ().
Operatør for omfangsoppløsning
Omfangsoppløsningsoperatøren i C ++ er ::. Den brukes til å få tilgang til et statisk medlem av klassen. Følgende program illustrerer dette:
ved hjelp av navneområdetimer;
klasseCla
{
offentlig:
statisk int konstmeme= 5;
offentlig:
statisk tomromfn()
{
koste<<meme<<' n';
}
};
inthoved-()
{
koste<<Cla::meme<<' n';
Cla::fn();
komme tilbake 0;
}
Utgangen er:
5
5
De statiske medlemmene ses i hovedblokken (), som er tilgjengelig med operatøren for oppløsning av omfang.
Mal Parameter Omfang
Det normale omfanget av et malparameternavn begynner fra deklarasjonspunktet til slutten av blokken, som i følgende kode:
mal<type navnT,type navnU> strukturAlder{
T John= elleve;
Du Peter= 12.3;
T Mary= 1. 3;
U Joy= 14.6;
};
U og T sees innenfor blokken.
For en malfunksjonsprototype begynner omfanget fra erklæringspunktet til slutten av funksjonsparameterlisten, som i følgende setning:
mal<type navnT,type navnU> tomromfunksjon(Du nei, du cha,konst røye *s. s);Når det gjelder klassebeskrivelsen (definisjonen), kan omfanget imidlertid også ha forskjellige deler som i følgende kode:
#inkludereved hjelp av navneområdetimer;
mal<klasseT,klasseU> klasseTheCla
{
offentlig:
t num;
statiskU ch;
tomromfunksjon(U far,konst røye *s. s)
{
koste << 'Det er ' <<på en<< 'bøker verdt' <<Nei<<s. s<< ' i butikken.' << ' n';
}
statisk tomrommoro(U ch)
{
hvis (kap== 'til')
koste << 'Offisiell statisk medlemsfunksjon' << ' n';
}
};
inthoved-()
{
TheCla<int,røye>obj;
obj.på en = 12;
obj.funksjon('$','500');
komme tilbake 0;
}
Navn gjemmer seg
Et eksempel på navneskjuling oppstår når navnet på samme objekttype deklareres på nytt i en nestet blokk. Følgende program illustrerer dette:
#inkludereved hjelp av navneområdetimer;
tomromfn()
{
inthvor= 3;
hvis (1==1)
{
inthvor= 4;
koste<<hvor<<' n';
}
koste<<hvor<<' n';
}
inthoved-()
{
fn();
komme tilbake 0;
}
Utgangen er:
4
3
Det er fordi var i den nestede blokken gjemte var i den ytre blokken.
Mulighet for å gjenta erklæringen i samme omfang
Poenget med erklæringen er hvor navnet blir introdusert (for første gang) i dets omfang.
Funksjon Prototype
Ulike enheter, selv av forskjellige typer, kan normalt ikke deklareres i samme omfang. Imidlertid kan en funksjonsprototype deklareres mer enn én gang i samme omfang. Følgende program med to funksjonsprototyper og tilhørende funksjonsdefinisjon illustrerer dette:
ved hjelp av navneområdetimer;
tomromfn(intpå en);
tomromfn(intpå en);
tomromfn(intpå en)
{
koste<<på en<<' n';
}
inthoved-()
{
fn(5);
komme tilbake 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:
ved hjelp av navneområdetimer;
tomromfn(intpå en)
{
koste<<på en<<' n';
}
tomromfn(flyteNei)
{
koste<<Nei<<' n';
}
inthoved-()
{
fn(5);
flyteflt= 8.7;
fn(flt);
komme tilbake 0;
}
Utgangen er:
5
8.7
De overbelastede funksjonene er definert i det globale omfanget.
Navneområde Omfang
Namespace Scope fortjener sin egen artikkel. Artikkelen er skrevet for dette nettstedet, linuxhint.com. Bare skriv søkeordene Namespace Scope i søkeboksen på dette nettstedet (side) og klikk OK, så får du artikkelen.
Omfang i forskjellige deler
Klassen er ikke den eneste ordningen der omfanget kan være i forskjellige deler. Vennespesifikator, visse bruksområder for den utarbeidede-type-spesifisatoren og bruk-direktiver er andre ordninger der omfanget er forskjellige steder-for detaljer, se senere.
Konklusjon
Et virkeområde er en deklarativ region. En deklarativ region er den største delen av en programtekst der navnet på en enhet er gyldig. Den kan deles inn i mer enn én porsjon i henhold til visse programmeringsordninger, for eksempel nestede blokker. Delene som ikke har deklarasjonspunktet danner det potensielle omfanget. Det potensielle omfanget kan ha erklæringen eller ikke.