Artikelindhold
- Deklarativt område og omfang
- Globalt omfang
- Bloker omfang
- Funktionsomfang
- Optællingsomfang
- Klassens omfang
- Skabelon Parameter Omfang
- Navn gemmer sig
- Mulighed for at gentage erklæring i samme omfang
- Navneområde Omfang
- Omfang i forskellige portioner
- Konklusion
Deklarativt område og omfang
En deklarativ region er den største del af en programtekst, hvor navnet på en enhed er gyldigt. Det er den region, hvor det ukvalificerede navn kan bruges (set) til at referere til den samme enhed. Overvej følgende korte program:
#omfatte
ved brug af navnerumtimer;
ugyldigfn()
{
inthvor= 3;
hvis (1==1)
{
koste<<hvor<<' n';
}
}
intvigtigste()
{
fn();
Vend tilbage 0;
}
Funktionen fn () har to blokke: en indre blok til if-tilstanden og en ydre blok til funktionslegemet. 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, f.eks. En float i den indre blok. Følgende kode illustrerer dette:
#omfatte
ved brug af navnerumtimer;
ugyldigfn()
{
inthvor= 3;
hvis (1==1)
{
flydehvor= 7.5;
koste<<hvor<<' n';
}
}
intvigtigste()
{
fn();
Vend tilbage 0;
}
Outputtet er 7,5. I dette tilfælde kan navnet, var, ikke længere bruges i den indre blok til at referere til heltalet af værdi 3, som blev introduceret (deklareret) i den ydre blok. Sådanne indre blokke betegnes som potentielt omfang for enheder, der er deklareret i den ydre blok.
Bemærk: En enhed af samme type, som den i den ydre blok, kan stadig erklæres i den indre blok. I dette tilfælde er det, der er gyldigt i den indre blok, imidlertid 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 samme navn uden for den indre blok. Indre blokke kan rede andre indre blokke.
Globalt omfang
Når en programmør bare begynder at skrive en fil, er det det globale omfang. Følgende korte program illustrerer dette:
#omfatteved brug af navnerumtimer;
flydehvor= 9.4;
intvigtigste()
{
koste <<hvor<<' n';
koste <<::hvor<<' n';
Vend tilbage 0;
}
Outputtet er:
9.4
9.4
I dette tilfælde begynder den deklarative region eller omfanget for var fra deklarationspunktet for var, fortsætter nedad til slutningen af filen (oversættelsesenhed).
Blokken for hovedfunktionen () er et andet omfang; det er et indlejret anvendelsesområde for det globale anvendelsesområde. For at få adgang til en enhed af det globale omfang, fra et andet omfang, bruges identifikatoren direkte eller forud for omfangsopløsningsoperatøren ::.
Bemærk: Enheden, main (), er også erklæret i det globale omfang.
Bloker omfang
Sætningen 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 bloks omfang. Dets anvendelsesområde begynder på dens erklæringspunkt og slutter ved enden af dens blok. Følgende korte program illustrerer dette for variablen, ident:
#omfatteved brug af navnerumtimer;
intvigtigste()
{
hvis (1==1)
{
/*nogle udsagn*/
intident= 5;
koste<<ident<<' n';
/*nogle udsagn*/
}
Vend tilbage 0;
}
En variabel, f.eks. Ident, erklæret ved blokomfang er en lokal variabel.
En variabel, der er erklæret uden for blokomfanget og over den, kan ses i blokens header (f.eks. Betingelse for if-block) og også inden for blokken. Følgende korte program illustrerer dette for variablen, identificer:
#omfatteved brug af navnerumtimer;
intvigtigste()
{
intidentificere= 8;
hvis (identificere== 8)
{
koste<<identificere<<' n';
}
Vend tilbage 0;
}
Outputtet er 8. Der er to blokomfang her: blokken til funktionen main () og den indlejrede if-compound-sætning. Den indlejrede blok er det potentielle omfang af funktionsblokken main ().
En erklæring indført i et blokomfang kan ikke ses uden for blokken. Følgende korte program, som ikke kompilerer, illustrerer dette med variablen, variab:
#omfatteved brug af navnerumtimer;
intvigtigste()
{
hvis (1 == 1)
{
intvariab= femten;
}
koste<<variab<<' n'; // fejl: adgang uden for dens anvendelsesområde.
Vend tilbage 0;
}
Kompilatoren producerer en fejlmeddelelse for variab.
En indført enhed, der er erklæret i overskriften på en sammensat funktion, kan ikke ses uden for (under) den sammensatte sætning. Følgende for-loop-kode kompileres ikke, hvilket resulterer i en fejlmeddelelse:
#omfatteved brug af navnerumtimer;
intvigtigste()
{
til (intjeg=0;jeg<4; ++jeg)
{
koste<<jeg<<'';
}
koste<<jeg<<'';
Vend tilbage 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 deklarationspunktet til slutningen af funktionsblokken. Følgende korte program illustrerer dette:
#omfatte#omfatte
ved brug af navnerumtimer;
streng fn(streng str)
{
forkælelsestri[] = 'bananer';
/*andre udsagn*/
streng totalStr=s+stri;
Vend tilbagetotalStr;
}
intvigtigste()
{
streng totStr=fn('spise');
koste<<totStr<<' n';
Vend tilbage 0;
}
Outputtet er:
spise bananer
Bemærk: En enhed 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:
#omfatteved brug af navnerumtimer;
ugyldigfn()
{
gå tillabl;
/*andre udsagn*/
labl: intikke= 2;
koste<<ikke<<' n';
}
intvigtigste()
{
fn();
Vend tilbage 0;
}
Outputtet er 2.
Optællingsomfang
Uopmålt optælling
Overvej følgende if-block:
{
enum {a, b, c=b+2};
koste<<til<<''<<b<<''<<c<<' n';
}
Outputtet er 0 1 3.
Den første linje i blokken er en optælling, a, b og c er dens optællere. En tællers omfang begynder fra erklæringspunktet til slutningen af optællingens omsluttende blok.
Følgende erklæring vil ikke kompilere, fordi erklæringspunktet for c er efter punktet for a:
enum {til=c+2, b, c};Følgende kodesegment kompileres ikke, fordi der er adgang til tællerne efter optællingens omsluttende blok:
hvis (1==1){
enum {a, b, c=b+2};
}
koste<<til<<''<<b<<''<<c<<' n'; // fejl: uden for anvendelsesområdet
Ovenstående optælling beskrives som en ikke -optaget optælling, og dens optællere beskrives som uskopulerede optællere. Dette skyldes, at det kun begynder med det reserverede ord, enum. Optællinger, der begynder med enum -klasse eller enum struct, beskrives som omfangsopregninger. Deres optællere beskrives som omfangsregistrerede tællere.
Omfattet optælling
Følgende erklæring er OK:
Dette er et eksempel på en omfangsopregning. Klassens navn er nam. Her begynder omfanget af optælleren fra erklæringspunktet til slutningen af optællingsdefinitionen, og ikke slutningen på den omsluttende blok til optællingen. Følgende kode vil ikke kompilere:
hvis (1==1){
enum klassehan-{a, b, c=b+2};
koste<<til<<''<<b<<''<<c<<' n'; // fejl: uden for anvendelsesområdet for enum klasse eller enum struct
}
Klassens omfang
Ved normalt omfang begynder den deklarative region fra et punkt, fortsætter derefter og stopper på et andet tidspunkt. Omfanget findes i en sammenhængende region. Med klassen kan omfanget af en enhed være i forskellige regioner, der ikke er forbundet sammen. Reglerne for indlejrede blokke gælder stadig. Følgende program illustrerer dette:
#omfatteved brug af navnerumtimer;
// Grundklasse
klasseCla
{
privat:
intmemP= 5;
beskyttet:
intmemPro= 9;
offentlig:
ugyldigfn()
{
koste<<memP<<' n';
}
};
// Afledt klasse
klasseDerCla: offentligCla
{
offentlig:
intderMem=memPro;
};
intvigtigste()
{
Cla obj;
obj.fn();
DerCla derObj;
koste<<derObj.derMem<<' n';
Vend tilbage 0;
}
Outputtet er:
5
9
I klassen Cla ses variablen memP på deklarationsstedet. Derefter springes den korte del af beskyttede over og derefter ses igen i klassemedlemens funktionsblok. Den afledte klasse springes over og ses derefter igen ved funktionsomfanget () (blok).
I klassen Cla ses variablen memPro på deklarationsstedet. Delen af den offentlige funktion fn () springes over og ses derefter i den afledte klassebeskrivelsesblok. Det ses igen nede i hovedfunktionen ().
Operatør for omfangsopløsning
Omfangsopløsningsoperatoren i C ++ er ::. Det bruges til at få adgang til et statisk medlem af klassen. Følgende program illustrerer dette:
ved brug af navnerumtimer;
klasseCla
{
offentlig:
statisk int konstmeme= 5;
offentlig:
statisk ugyldigfn()
{
koste<<meme<<' n';
}
};
intvigtigste()
{
koste<<Cla::meme<<' n';
Cla::fn();
Vend tilbage 0;
}
Outputtet er:
5
5
De statiske medlemmer ses i funktionsblokken (), der er tilgængelig ved hjælp af operatøren for opløsning af omfang.
Skabelon Parameter Omfang
Det normale omfang af et skabelonparameternavn begynder fra erklæringspunktet til slutningen af dets blok, som i følgende kode:
skabelon<type navnT,type navnU> strukturAlder{
T John= elleve;
Dig Peter= 12.3;
T Mary= 13;
U Joy= 14.6;
};
U og T ses inden for blokken.
For en skabelonfunktionsprototype begynder omfanget fra erklæringspunktet til slutningen af funktionsparameterlisten, som i følgende sætning:
skabelon<type navnT,type navnU> ugyldigfungere(Du nej, u cha,konst forkælelse *s);Når det kommer til klassebeskrivelsen (definition), kan omfanget imidlertid også have forskellige dele som i følgende kode:
#omfatteved brug af navnerumtimer;
skabelon<klasseT,klasseU> klasseTheCla
{
offentlig:
t num;
statiskU ch;
ugyldigfungere(U far,konst forkælelse *s)
{
koste << 'Der er ' <<på en<< 'bøger værd' <<ingen<<s<< ' i butikken.' << ' n';
}
statisk ugyldigsjovt(U ch)
{
hvis (kap== 'til')
koste << 'Officiel statisk medlemsfunktion' << ' n';
}
};
intvigtigste()
{
TheCla<int,forkælelse>obj;
obj.på en = 12;
obj.fungere('$','500');
Vend tilbage 0;
}
Navn gemmer sig
Et eksempel på navnet skjuler forekommer, når navnet på den samme objekttype deklareres igen i en indlejret blok. Følgende program illustrerer dette:
#omfatteved brug af navnerumtimer;
ugyldigfn()
{
inthvor= 3;
hvis (1==1)
{
inthvor= 4;
koste<<hvor<<' n';
}
koste<<hvor<<' n';
}
intvigtigste()
{
fn();
Vend tilbage 0;
}
Outputtet er:
4
3
Det er fordi var i den indlejrede blok skjulte var i den ydre blok.
Mulighed for at gentage erklæring i samme omfang
Pointen i erklæringen er, hvor navnet introduceres (for første gang) i dets omfang.
Funktion Prototype
Forskellige enheder, selv af forskellige typer, kan normalt ikke erklæres i samme omfang. Imidlertid kan en funktionsprototype deklareres mere end én gang i samme omfang. Følgende program med to funktionsprototyper og tilhørende funktionsdefinition illustrerer dette:
ved brug af navnerumtimer;
ugyldigfn(intpå en);
ugyldigfn(intpå en);
ugyldigfn(intpå en)
{
koste<<på en<<' n';
}
intvigtigste()
{
fn(5);
Vend tilbage 0;
}
Programmet virker.
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:
ved brug af navnerumtimer;
ugyldigfn(intpå en)
{
koste<<på en<<' n';
}
ugyldigfn(flydeingen)
{
koste<<ingen<<' n';
}
intvigtigste()
{
fn(5);
flydeflt= 8.7;
fn(flt);
Vend tilbage 0;
}
Outputtet er:
5
8.7
De overbelastede funktioner er defineret i det globale omfang.
Navneområde Omfang
Namespace Scope fortjener sin egen artikel. Den nævnte artikel er skrevet til dette websted, linuxhint.com. Indtast bare søgeordene Namespace Scope i søgefeltet på dette websted (side) og klik på OK, så får du artiklen.
Omfang i forskellige portioner
Klassen er ikke den eneste ordning, hvor omfanget kan være i forskellige portioner. Friend specificer, visse anvendelser af den specificerede type specificer og use-directives er andre ordninger, hvor omfanget er forskellige steder-for detaljer, se senere.
Konklusion
Et anvendelsesområde er en deklarativ region. En deklarativ region er den største del af en programtekst, hvor navnet på en enhed er gyldigt. Det kan opdeles i mere end en portion i overensstemmelse med visse programmeringsordninger, såsom indlejrede blokke. De dele, der ikke har deklarationspunktet, danner det potentielle omfang. Det potentielle omfang kan have en erklæring eller ej.