Artikli sisu
- Deklaratiivne piirkond ja reguleerimisala
- Globaalne ulatus
- Blokeerimisala
- Funktsiooni ulatus
- Loendusala
- Klassi ulatus
- Malli parameetrite ulatus
- Nimi peidus
- Deklaratsiooni kordamise võimalus samas ulatuses
- Nimeruumi ulatus
- Ulatus erinevates osades
- Järeldus
Deklaratiivne piirkond ja reguleerimisala
Deklaratiivne piirkond on programmi teksti suurim osa, milles üksuse nimi kehtib. See on piirkond, kus tingimusteta nime saab kasutada (näha) samale üksusele viitamiseks. Mõelge järgmisele lühikesele programmile:
#kaasake
kasutades nimeruumtundi;
tühinefn()
{
intkus= 3;
kui (1==1)
{
maksma<<kus<<' n';
}
}
intpeamine()
{
fn();
tagasi 0;
}
Funktsioonil fn () on kaks plokki: sisemine plokk if-tingimuse jaoks ja väline plokk funktsiooni keha jaoks. Identifikaator var on sisse viidud ja nähtav välisblokis. Seda on näha ka sisemises plokis koos cout -lausega. Välimine ja sisemine plokk on mõlemad nime ulatus, var.
Nime var abil saab siiski kasutada mõne muu olemi, näiteks siseploki ujuki deklareerimiseks. Seda illustreerib järgmine kood:
#kaasake
kasutades nimeruumtundi;
tühinefn()
{
intkus= 3;
kui (1==1)
{
hõljumakus= 7.5;
maksma<<kus<<' n';
}
}
intpeamine()
{
fn();
tagasi 0;
}
Väljund on 7,5. Sel juhul ei saa nimetust var enam sisemises plokis kasutada väärtuse 3 täisarvule viitamiseks, mis sisestati (deklareeriti) välisplokis. Selliseid sisemisi plokke nimetatakse välisplokis deklareeritud üksuste potentsiaalseks ulatuseks.
Märkus. Sama tüüpi olemit, nagu ka välimist plokki, saab endiselt sisemises plokis deklareerida. Kuid sel juhul kehtib sisemises plokis uus deklaratsioon ja selle tähendus, samas kui vana deklaratsioon ja selle tähendus väljaspool sisemist plokki jäävad kehtima välisplokis.
Sama nimega deklaratsioon sisemises plokis alistab tavaliselt sama nime deklaratsiooni väljaspool seda sisemist plokki. Sisemised plokid võivad pesitseda teisi sisemisi plokke.
Globaalne ulatus
Kui programmeerija alles hakkab faili tippima, on see globaalne ulatus. Seda illustreerib järgmine lühikava:
#kaasakekasutades nimeruumtundi;
hõljumakus= 9.4;
intpeamine()
{
maksma <<kus<<' n';
maksma <<::kus<<' n';
tagasi 0;
}
Väljund on:
9.4
9.4
Sel juhul algab deklareeriv piirkond või var -ulatus var -deklareerimispunktist, jätkub allapoole kuni faili (tõlkeüksus) lõpuni.
Funktsiooni peamine () plokk on erinev ulatus; see on globaalse ulatuse pesastatud ulatus. Globaalse ulatusega üksusele juurdepääsuks erinevast ulatusest kasutatakse identifikaatorit otse või selle ees on ulatuse lahendamise operaator ::.
Märkus. Üksus main () on deklareeritud ka üldises ulatuses.
Blokeerimisala
Lause if, while, do, for või switch võib igaüks blokeerida ploki. Selline väide on liitväide. Plokis deklareeritud muutuja nimel on ploki ulatus. Selle reguleerimisala algab deklareerimispunktist ja lõpeb ploki lõpus. Järgmine lühiprogramm illustreerib seda muutuja ident:
#kaasakekasutades nimeruumtundi;
intpeamine()
{
kui (1==1)
{
/*mõned väited*/
intident= 5;
maksma<<ident<<' n';
/*mõned väited*/
}
tagasi 0;
}
Ploki ulatuses deklareeritud muutuja, näiteks ident, on kohalik muutuja.
Muutujat, mis on deklareeritud väljaspool ploki ulatust ja sellest kõrgemal, saab näha ploki päises (nt if-ploki tingimus) ja ka ploki sees. Järgmine lühiprogramm illustreerib seda muutuja identifikaatori jaoks:
#kaasakekasutades nimeruumtundi;
intpeamine()
{
intidentifitseerida= 8;
kui (identifitseerida== 8)
{
maksma<<identifitseerida<<' n';
}
tagasi 0;
}
Väljund on 8. Siin on kaks ploki ulatust: põhifunktsiooni () plokk ja pesastatud if-ühend lause. Pesastatud plokk on põhifunktsiooni () potentsiaalne ulatus.
Ploki ulatuses sisestatud deklaratsiooni ei saa väljaspool plokki näha. Järgmine lühiprogramm, mida ei koostata, illustreerib seda muutujaga muutuja:
#kaasakekasutades nimeruumtundi;
intpeamine()
{
kui (1 == 1)
{
intmuutuja= viisteist;
}
maksma<<muutuja<<' n'; // viga: juurdepääs väljaspool selle reguleerimisala.
tagasi 0;
}
Kompilaator annab muutujale veateate.
Sisestatud üksust, mis on deklareeritud liitfunktsiooni päises, ei saa näha liitlausest väljaspool (allpool). Järgmist silmuse koodi ei kompileerita, mille tulemuseks on tõrketeade:
#kaasakekasutades nimeruumtundi;
intpeamine()
{
eest (inti=0;i<4; ++i)
{
maksma<<i<<'';
}
maksma<<i<<'';
tagasi 0;
}
Iteratsioonimuutuja i on nähtav for-loop ploki sees, kuid mitte väljaspool loop-plokki.
Funktsiooni ulatus
Funktsiooniplokis on näha funktsiooni parameeter. Funktsiooniplokis deklareeritud olemit vaadeldakse deklareerimispunktist kuni funktsiooniploki lõpuni. Seda illustreerib järgmine lühikava:
#kaasake#kaasake
kasutades nimeruumtundi;
string fn(string str)
{
süsistri[] = 'banaanid';
/*muud avaldused*/
string kokkuStr=lk+stri;
tagasitotalStr;
}
intpeamine()
{
string totStr=fn('söömine');
maksma<<totStr<<' n';
tagasi 0;
}
Väljund on:
banaanide söömine
Märkus. Väljaspool funktsiooni (selle kohal) deklareeritud olemit saab näha funktsiooni parameetrite loendis ja ka funktsiooniplokis.
Silt
Sildi ulatus on funktsioon, milles see ilmub. Seda illustreerib järgmine kood:
#kaasakekasutades nimeruumtundi;
tühinefn()
{
minemalabl;
/*muud avaldused*/
labl: intmitte= 2;
maksma<<mitte<<' n';
}
intpeamine()
{
fn();
tagasi 0;
}
Väljund on 2.
Loendusala
Skaneerimata loend
Mõelge järgmisele blokeerimisele:
{
enum {a, b, c=b+2};
maksma<<et<<''<<b<<''<<c<<' n';
}
Väljund on 0 1 3.
Ploki esimene rida on loend, a, b ja c on selle loendurid. Loendaja ulatus algab deklareerimispunktist loenduse lisabloki lõpuni.
Järgmist avaldust ei koostata, kuna c deklareerimise punkt on pärast a:
enum {et=c+2, b, c};Järgmist koodilõiku ei kompileerita, kuna loendajatele pääseb juurde pärast loenduse kaasplokki:
kui (1==1){
enum {a, b, c=b+2};
}
maksma<<et<<''<<b<<''<<c<<' n'; // viga: ulatusest väljas
Ülaltoodud loendit kirjeldatakse kui skaneerimata loendit ja selle loendajaid kirjeldatakse kui skaneerimata loendajat. Seda seetõttu, et see algab ainult reserveeritud sõnaga, enum. Loendusi, mis algavad enum -klassi või enum -struktuuriga, kirjeldatakse ulatusloendustena. Nende loendajaid kirjeldatakse kui ulatusloendajaid.
Ulatusloend
Järgmine avaldus on OK:
See on näide ulatusloendusest. Klassi nimi on nam. Siin algab loendaja ulatus deklareerimise punktist loendamise määratluse lõpuni, mitte loenduse lisabloki lõpp. Järgmist koodi ei kompileerita:
kui (1==1){
enum klassimees{a, b, c=b+2};
maksma<<et<<''<<b<<''<<c<<' n'; // viga: enum -klassi või enum -struktuuri ulatusest väljas
}
Klassi ulatus
Tavalise ulatuse korral algab deklaratiivne piirkond punktist, seejärel jätkub ja peatub teises kohas. Ulatus on ühes pidevas piirkonnas. Klassiga saab olemi ulatus olla erinevates piirkondades, mis pole omavahel ühendatud. Pesastatud plokkide reeglid kehtivad endiselt. Seda illustreerib järgmine programm:
#kaasakekasutades nimeruumtundi;
// Baasklass
klassiCla
{
privaatne:
intmemP= 5;
kaitstud:
intmemPro= 9;
avalik:
tühinefn()
{
maksma<<memP<<' n';
}
};
// Tuletatud klass
klassiDerCla: avalikCla
{
avalik:
intderMem=memPro;
};
intpeamine()
{
Cla obj;
obj.fn();
DerCla derObj;
maksma<<derObj.derMem<<' n';
tagasi 0;
}
Väljund on:
5
9
Klassis Cla nähakse deklareerimispunktis muutujat memP. Pärast seda jäetakse kaitstud lühike osa vahele, seejärel kuvatakse see uuesti klassiliikme funktsiooniplokis. Tuletatud klass jäetakse vahele, seejärel kuvatakse see uuesti põhifunktsiooni ulatuses ().
Klassis Cla nähakse deklareerimispunktis muutujat memPro. Avaliku funktsiooni fn () osa jäetakse vahele ja seda nähakse tuletatud klassikirjelduse plokis. Seda näeb uuesti põhifunktsioonis ().
Reguleerimisala lahendamise operaator
C ++ ulatuse eraldusvõime operaator on ::. Seda kasutatakse klassi staatilisele liikmele juurdepääsu saamiseks. Seda illustreerib järgmine programm:
kasutades nimeruumtundi;
klassiCla
{
avalik:
staatiline int constmeem= 5;
avalik:
staatiline tühinefn()
{
maksma<<meem<<' n';
}
};
intpeamine()
{
maksma<<Cla::meem<<' n';
Cla::fn();
tagasi 0;
}
Väljund on:
5
5
Staatilised elemendid on näha põhifunktsioonis (), millele pääseb juurde ulatuse eraldusvõime operaatori abil.
Malli parameetrite ulatus
Malli parameetri nime tavaline ulatus algab deklareerimispunktist selle ploki lõpuni, nagu järgmises koodis:
malli<tüübinimiT,tüübinimiU> struktuuriVanused{
T John= üksteist;
Sina Peeter= 12.3;
T Maarja= 13;
U Rõõm= 14.6;
};
Plokis on näha U ja T.
Mallifunktsiooni prototüübi puhul algab ulatus deklareerimispunktist kuni funktsiooni parameetrite loendi lõpuni, nagu järgmises lauses:
malli<tüübinimiT,tüübinimiU> tühinefunktsiooni(Sa ei, u cha,const süsi *lk);Kui aga tegemist on klassi kirjeldusega (määratlusega), võib ulatus olla ka erinevates osades nagu järgmises koodis:
#kaasakekasutades nimeruumtundi;
malli<klassiT,klassiU> klassiTheCla
{
avalik:
t num;
staatilineU ch;
tühinefunktsiooni(Sina isa,const süsi *lk)
{
maksma << 'Seal on ' <<ühe peale<< 'väärt raamatud' <<ei<<lk<< ' poes.' << ' n';
}
staatiline tühinelõbus(U ch)
{
kui (ch== '')
maksma << „Staatilise liikme ametlik funktsioon” << ' n';
}
};
intpeamine()
{
TheCla<int,süsi>obj;
obj.ühe peale = 12;
obj.funktsiooni('$','500');
tagasi 0;
}
Nimi peidus
Nime peitmise näide ilmneb siis, kui sama objektitüübi nimi deklareeritakse pesastatud plokis uuesti. Seda illustreerib järgmine programm:
#kaasakekasutades nimeruumtundi;
tühinefn()
{
intkus= 3;
kui (1==1)
{
intkus= 4;
maksma<<kus<<' n';
}
maksma<<kus<<' n';
}
intpeamine()
{
fn();
tagasi 0;
}
Väljund on:
4
3
Selle põhjuseks on asjaolu, et varjatud pesastatud plokis peitis var välimise ploki.
Deklaratsiooni kordamise võimalus samas ulatuses
Deklaratsiooni mõte on see, kus nimi esitatakse (esimest korda) selle ulatuses.
Funktsiooni prototüüp
Erinevaid üksusi, isegi erinevat tüüpi, ei saa tavaliselt samasse ulatusse kuulutada. Funktsiooni prototüübi saab samas ulatuses siiski deklareerida mitu korda. Seda illustreerib järgmine programm kahe funktsiooni prototüübiga ja vastava funktsiooni määratlusega:
kasutades nimeruumtundi;
tühinefn(intühe peale);
tühinefn(intühe peale);
tühinefn(intühe peale)
{
maksma<<ühe peale<<' n';
}
intpeamine()
{
fn(5);
tagasi 0;
}
Programm töötab.
Ülekoormatud funktsioonid
Ülekoormatud funktsioonid on sama nimega, kuid erineva allkirjaga funktsioonid. Teise erandina saab sama ulatusega määratleda sama nimega ülekoormatud funktsioone. Seda illustreerib järgmine programm:
kasutades nimeruumtundi;
tühinefn(intühe peale)
{
maksma<<ühe peale<<' n';
}
tühinefn(hõljumaei)
{
maksma<<ei<<' n';
}
intpeamine()
{
fn(5);
hõljumaflt= 8.7;
fn(flt);
tagasi 0;
}
Väljund on:
5
8.7
Ülekoormatud funktsioonid on määratletud globaalses ulatuses.
Nimeruumi ulatus
Namespace Scope väärib oma artiklit. See artikkel on kirjutatud selle veebisaidi linuxhint.com jaoks. Sisestage lihtsalt selle saidi (lehe) otsingukasti otsingusõnad Namespace Scope ja klõpsake nuppu OK ning saate artikli.
Ulatus erinevates osades
Klass pole ainus skeem, mille ulatus võib olla erinevates osades. Sõbra täpsustaja, välja töötatud tüübispetsiifori teatud kasutusviisid ja kasutusjuhised on muud skeemid, mille ulatus on erinevates kohtades-üksikasju vt hiljem.
Järeldus
Ulatusala on deklaratiivne piirkond. Deklaratiivne piirkond on programmi teksti suurim osa, milles üksuse nimi kehtib. Seda saab vastavalt teatud programmeerimisskeemidele, näiteks pesastatud plokkidele, jagada mitmeks osaks. Osad, millel pole deklareerimispunkti, moodustavad võimaliku ulatuse. Võimalikul ulatusel võib deklaratsiooni olla või mitte.