Reguleerimisala C ++ keeles

C ++ üksusel on nimi, mille saab deklareerida ja / või määratleda. Deklaratsioon on määratlus, kuid määratlus ei pruugi olla deklaratsioon. Definitsioon eraldab mälu nimega üksusele, kuid deklaratsioon võib eraldada või mitte nimetatavale üksusele mälu. Deklaratiivne piirkond on programmi suurim osa, milles kehtib üksuse (muutuja) nimi. Seda piirkonda nimetatakse ulatuseks või potentsiaalseks ulatuseks. Selles artiklis selgitatakse ulatusega C-d++. Selle artikli mõistmiseks on vaja põhiteadmisi C ++ keeles.

Artikli sisu

Deklaratiivne piirkond ja ulatus
Ülemaailmne ulatus
Blokeeri ulatus
Funktsiooni ulatus
Loendamise ulatus
Klassi ulatus
Malliparameetri ulatus
Nimi peidus
Deklaratsiooni kordamise võimalus samas ulatuses
Nimeruumi ulatus
Reguleerimisala erinevates osades
Järeldus

Deklaratiivne piirkond ja ulatus

Deklaratiivne piirkond on suurim osa programmitekstist, milles üksuse nimi kehtib. See on piirkond, kus kvalifitseerimata nime saab kasutada (näha) samale üksusele viitamiseks. Mõelge järgmisele lühiprogrammile:

# kaasata
nimeruumi kasutamine std;
tühine fn ()

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

cout<

int main ()

fn ();
tagastama 0;

Funktsioonil fn () on kaks plokki: if-tingimuse sisemine plokk ja funktsiooni keha välimine plokk. Identifikaator var lisatakse ja nähakse välimises plokis. Seda on näha ka sisemises plokis koos avaldusega cout. Nii välimine kui ka sisemine plokk on nime ulatus, var.

Nime var, saab siiski kasutada sisemises plokis erineva üksuse, näiteks ujuki deklareerimiseks. Järgmine kood illustreerib seda:

# kaasata
nimeruumi kasutamine std;
tühine fn ()

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

ujuk var = 7.5;
cout<

int main ()

fn ();
tagastama 0;

Väljund on 7.5. Sellisel juhul ei saa sisemises plokis enam nime nimi var kasutada väärtuse 3 täisarvu tähistamiseks, mis lisati (deklareeriti) välimisse plokki. Selliseid siseplokke nimetatakse välises plokis deklareeritud üksuste potentsiaalseks ulatuseks.

Märkus. Sama tüüpi üksuse, nagu välimise ploki oma, saab ikkagi deklareerida sisemises plokis. 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 välises plokis kehtima.

Sisemises plokis sama nimega deklaratsioon alistab tavaliselt sama nime deklaratsiooni väljaspool seda sisemist plokki. Sisemised plokid võivad teisi sisemisi plokke pesastada.

Ülemaailmne ulatus

Kui programmeerija alles faili tippima hakkab, on see globaalne ulatus. Järgmine lühike programm illustreerib seda:

# kaasata
nimeruumi kasutamine std;
ujuk var = 9.4;
int main ()

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

Väljund on:
9.4
9.4

Sel juhul algab vari deklaratiivne piirkond või ulatus alates var-i deklareerimise punktist, jätkub allapoole kuni faili lõpuni (tõlkeüksus).

Funktsiooni main () plokk on erinev ulatus; see on globaalse ulatuse pesastatud ulatus. Ülemaailmse ulatusega üksusele juurdepääsemiseks erinevast ulatusest kasutab identifikaatorit otse või sellele eelneb ulatuseralduse operaator: .

Märkus. Olem, main (), deklareeritakse ka globaalses ulatuses.

Blokeeri ulatus

Lausel if, while, do, for või switch saab igaüks defineerida ploki. Selline väide on liitväide. Plokis deklareeritud muutuja nimel on ploki ulatus. Selle ulatus algab deklareerimise hetkest ja lõpeb ploki lõpus. Järgmine lühike programm illustreerib seda muutuja ident ident:

# kaasata
nimeruumi kasutamine std;
int main ()

kui (1 == 1)

/ * mõned avaldused * /
int ident = 5;
cout</ * mõned avaldused * /

tagastama 0;

Blokeerimisulatusena deklareeritud muutuja nagu ident on lokaalne muutuja.

Muutuja, mis on deklareeritud väljaspool ploki ulatust ja sellest kõrgemal, on näha ploki päises (nt.g., tingimus if-ploki jaoks) ja ka ploki sees. Järgmine lühike programm illustreerib seda muutuja identif:

# kaasata
nimeruumi kasutamine std;
int main ()

int identif = 8;
kui (identif == 8)

cout<
tagastama 0;

Väljund on 8. Siin on kaks plokkide ulatust: funktsiooni main () ja sisestatud if-compos lause lause. Pesastatud plokk on peamise () funktsiooniploki potentsiaalne ulatus.

Blokeerimisvaldkonnas sisse viidud deklaratsiooni ei saa väljaspool plokki näha. Järgmine lühike programm, mis ei kompileeri, illustreerib seda muutujaga muutuja:

# kaasata
nimeruumi kasutamine std;
int main ()

kui (1 == 1)

int muutuja = 15;

cout<tagastama 0;

Koostaja loob muutujale tõrketeate.

Liitfunktsiooni päises deklareeritud kasutusel olevat üksust ei saa näha liitlausest väljaspool (allpool). Järgmist for-loop koodi ei kompileerita, mille tulemuseks on tõrketeade:

# kaasata
nimeruumi kasutamine std;
int main ()

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

cout<
cout<tagastama 0;

Iteratsioonimuutujat i nähakse silmusploki sees, kuid mitte silmusplokist väljaspool.

Funktsiooni ulatus

Funktsiooniparameetrit nähakse funktsiooniplokis. Funktsiooniplokis deklareeritud üksust nähakse deklaratsioonipunktist funktsiooniploki lõpuni. Järgmine lühike programm illustreerib seda:

# kaasata
# kaasata
nimeruumi kasutamine std;
string fn (string str)

char stri [] = "banaanid";
/ * muud väited * /
string totalStr = str + riba;
return totalStr;

int main ()

string totStr = fn ("söömine");
cout<tagastama 0;

Väljund on:
banaanide söömine

Märkus: väljaspool funktsiooni (selle kohal) deklareeritud üksust saab näha funktsiooniparameetrite loendis ja ka funktsiooniplokis.

Silt

Sildi ulatus on funktsioon, milles see ilmub. Järgmine kood illustreerib seda:

# kaasata
nimeruumi kasutamine std;
tühine fn ()

goto labl;
/ * muud väited * /
labl: int inte = 2;
cout<
int main ()

fn ();
tagastama 0;

Väljund on 2.

Loendamise ulatus

Reguleerimata loend
Mõelge järgmisele if-blokile:

kui (1 == 1)

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

Väljund on 0 1 3.

Bloki esimene rida on loendamine, a, b ja c on selle loendajad. Loendaja ulatus algab deklareerimisest kuni loendit sisaldava ploki lõpuni.

Järgmist lauset ei kompileerita, sest c-i deklareerimise punkt on pärast a-d:

loend a = c + 2, b, c;

Järgmist koodilõiku ei kompileerita, kuna loendajatele pääseb juurde pärast loendi ümbritsevat plokki:

kui (1 == 1)

loend a, b, c = b + 2;

cout<Ülaltoodud loendit kirjeldatakse kui valimatu loendit ja selle loendajaid kirjeldatakse kui valimata loendajaid. Seda seetõttu, et see algab ainult reserveeritud sõnaga enum. Loendusi, mis algavad loendiklassist või loendistruktuurist, kirjeldatakse kui reguleerimisala loendeid. Nende loendajaid kirjeldatakse kui ulatusega loendajaid.

Reguleeritav ulatus
Järgmine väide on korras:

loendusklassi nam a, b, c = b + 2;

See on näide ulatuslikust loendist. Klassi nimi on nam. Siin algab loendaja ulatus deklareerimise punktist loenduse definitsiooni lõpuni, mitte loenduse lisabloki lõpust. Järgmist koodi ei kompileerita:

kui (1 == 1)

loendusklassi nam a, b, c = b + 2;
cout<

Klassi ulatus

Normaalse ulatuse korral algab deklaratiivne piirkond punktist, jätkub seejärel ja peatub teises punktis. Reguleerimisala eksisteerib ühes pidevas piirkonnas. Klassiga võib üksuse ulatus olla erinevates piirkondades, mis pole omavahel ühendatud. Pesastatud plokkide reeglid kehtivad endiselt. Järgmine programm illustreerib seda:

# kaasata
nimeruumi kasutamine std;
// Põhiklass
klass Cla

privaatne:
int memP = 5;
kaitstud:
int memPro = 9;
avalik:
tühine fn ()

cout<
;
// Tuletatud klass
klass DerCla: avalik Cla

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

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

Väljund on:
5
9

Klassis Cla nähakse muutuja memP deklareerimise kohas. Pärast seda jäetakse „kaitstud“ lühike osa vahele ja vaadatakse siis uuesti klassi liikme funktsiooniplokis. Tuletatud klass jäetakse vahele ja vaadatakse uuesti funktsiooni main () funktsioonipiirkonnas (plokk).

Klassis Cla on deklareerimise kohas näha muutujat memPro. Avaliku funktsiooni fn () osa jäetakse vahele ja vaadatakse tuletatud klassi kirjelduse plokis. Seda nähakse uuesti põhifunktsioonis ().

Reguleerimisala eraldamise operaator
Rakenduse C ++ ulatuseralduse operaator on :: . Seda kasutatakse klassi staatilise liikme juurde pääsemiseks. Järgmine programm illustreerib seda:

# kaasata
nimeruumi kasutamine std;
klass Cla

avalik:
staatiline int const mem = 5;
avalik:
staatiline void fn ()

cout<
;
int main ()

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

Väljund on:
5
5

Staatilisi liikmeid nähakse peamises () plokis, millele pääseb juurde spektri eraldusoperaatori abil.

Malliparameetri ulatus

Malliparameetri nime tavaline ulatus algab deklaratsioonipunktist kuni selle ploki lõpuni nagu järgmises koodis:

mall struktureeritud vanused

T Johannes = 11;
U Peetrus = 12.3;
T Maarja = 13;
U rõõm = 14.6;
;

U ja T on näha plokis.

Mallifunktsiooni prototüübi puhul algab ulatus deklaratsioonipunktist funktsiooni parameetrite loendi lõpuni, nagu järgmises avalduses:

mall void func (T nr, U cha, const char * str);

Klassikirjelduse (määratluse) osas võib rakendusala olla ka erinevates osades, nagu järgmises koodis:

# kaasata
nimeruumi kasutamine std;
mall klass TheCla

avalik:
T number;
staatiline U ch;
void func (U cha, const char * str)

cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';

staatiline tühine lõbu (U ch)

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

;
int main ()

TheCla obj;
obj.arv = 12;
obj.func ('$', "500");
tagastama 0;

Nimi peidus

Nime peitmise näide ilmneb siis, kui pesastatud plokis deklareeritakse sama objekti tüüpi nimi uuesti. Järgmine programm illustreerib seda:

# kaasata
nimeruumi kasutamine std;
tühine fn ()

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

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

fn ();
tagastama 0;

Väljund on:
4
3

Selle põhjuseks on asjaolu, et pesastatud ploki var varjas välises plokis var.

Deklaratsiooni kordamise võimalus samas ulatuses

Deklaratsiooni mõte on see, kus nimi on (esimest korda) kasutusele võetud.

Funktsiooni prototüüp
Erinevaid, isegi erinevat tüüpi üksusi ei saa tavaliselt deklareerida samas ulatuses. Funktsiooni prototüübi võib samas ulatuse kuulutada aga mitu korda. Järgmine kahe funktsiooni prototüübi ja vastava funktsiooni määratlusega programm illustreerib seda:

# kaasata
nimeruumi kasutamine std;
void fn (int number);
void fn (int number);
void fn (int number)

cout<
int main ()

fn (5);
tagastama 0;

Programm töötab.

Ülekoormatud funktsioonid
Ülekoormatud funktsioonid on sama nimega, kuid erinevate funktsioonide allkirjadega funktsioonid. Teise erandina võib sama nimega ülekoormatud funktsioone määratleda samas ulatuses. Järgmine programm illustreerib seda:

# kaasata
nimeruumi kasutamine std;
void fn (int number)

cout<
void fn (ujuk nr)

cout<
int main ()

fn (5);
ujuk flt = 8.7;
fn (flt);
tagastama 0;

Väljund on:
5
8.7

Ülekoormatud funktsioonid on määratletud globaalses ulatuses.

Nimeruumi ulatus

Nimeruumi ulatus väärib oma artiklit. Nimetatud artikkel on kirjutatud selle veebisaidi, linuxhint jaoks.com. Sisestage lihtsalt selle saidi (leht) otsingukasti otsingusõnad “Nimespace Scope” ja klõpsake nuppu OK ning saate artikli.

Reguleerimisala erinevates osades

Klass pole ainus skeem, kus ulatus võib olla erinevates osades. Sõbra täpsustaja, väljatöötatud tüübispetsifikaatori teatud kasutusalad ja kasutamisdirektiivid on muud skeemid, mille reguleerimisala on erinevates kohtades - üksikasju vt hiljem.

Järeldus

Reguleerimisala on deklaratiivne piirkond. Deklaratiivne piirkond on suurim osa programmitekstist, milles üksuse nimi kehtib. Seda saab jagada mitmeks osaks vastavalt teatud programmeerimisskeemidele, näiteks pesastatud plokkidele. Need osad, millel pole deklareerimispunkti, moodustavad potentsiaalse ulatuse. Võimalikul ulatusel võib deklaratsioon olla või mitte.