Laajuus C ++

C ++ - yksiköllä on nimi, joka voidaan ilmoittaa ja / tai määritellä. Ilmoitus on määritelmä, mutta määritelmä ei välttämättä ole ilmoitus. Määritelmä varaa muistia nimetylle yksikölle, mutta ilmoitus voi varata muistia nimetylle entiteetille. Deklaratiivinen alue on suurin osa ohjelmaa, jossa yksikön (muuttujan) nimi on voimassa. Tätä aluetta kutsutaan laajuudeksi tai mahdolliseksi laajuudeksi. Tässä artikkelissa selitetään laajuus C: ssä++. Lisäksi tämän artikkelin ymmärtämiseen tarvitaan perustiedot C ++: ssa.

Artikkelin sisältö

Ilmoitettava alue ja soveltamisala
Globaali soveltamisala
Estä soveltamisala
Toiminnon laajuus
Luettelon laajuus
Luokan laajuus
Malliparametrien laajuus
Nimi piilossa
Mahdollisuus toistaa julistus samalla laajuudella
Nimitilan laajuus
Laajuus eri osina
Johtopäätös

Ilmoitettava alue ja soveltamisala

Deklaratiivinen alue on suurin osa ohjelmatekstistä, jossa yksikön nimi on voimassa. Se on alue, jolla määrittelemätöntä nimeä voidaan käyttää (nähty) viittaamaan samaan entiteettiin. Harkitse seuraavaa lyhyttä ohjelmaa:

#sisältää
käyttämällä nimitilaa vakio;
void fn ()

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

cout<

int main ()

fn ();
paluu 0;

Funktiolla fn () on kaksi lohkoa: sisäinen lohko if-ehdolle ja ulompi lohko funktion rungolle. Tunniste, var, lisätään ja nähdään ulkolohkossa. Se näkyy myös sisemmässä lohkossa cout-lausunnon kanssa. Ulompi ja sisempi lohko ovat molemmat nimen laajuus, var.

Nimeä var voidaan kuitenkin silti käyttää ilmoittamaan eri kokonaisuus, kuten kellukkeen sisemmässä lohkossa. Seuraava koodi kuvaa tätä:

#sisältää
käyttämällä nimitilaa vakio;
void fn ()

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

kelluva var = 7.5;
cout<

int main ()

fn ();
paluu 0;

Lähtö on 7.5. Tässä tapauksessa nimeä var ei voida enää käyttää sisemmässä lohkossa viittaamaan arvon 3 kokonaislukuun, joka lisättiin (ilmoitettiin) ulkolohkossa. Tällaisia sisäisiä lohkoja kutsutaan ulommassa lohkossa ilmoitettujen entiteettien mahdolliseksi laajuudeksi.

Huomaa: Samantyyppinen entiteetti, kuten ulompi lohko, voidaan edelleen ilmoittaa sisemmässä lohkossa. Tässä tapauksessa sisäisessä lohkossa on kuitenkin voimassa uusi ilmoitus ja sen merkitys, kun taas vanha ilmoitus ja sen merkitys sisäisen lohkon ulkopuolella pysyvät voimassa ulkolohkossa.

Saman nimen ilmoitus sisäisessä lohkossa yleensä ohittaa saman nimen ilmoituksen sisäisen lohkon ulkopuolella. Sisemmät lohkot voivat sijoittaa muita sisäisiä lohkoja.

Globaali soveltamisala

Kun ohjelmoija alkaa vasta kirjoittaa tiedostoa, se on maailmanlaajuinen laajuus. Seuraava lyhyt ohjelma kuvaa tätä:

#sisältää
käyttämällä nimitilaa vakio;
kelluva var = 9.4;
int main ()

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

Tuotos on:
9.4
9.4

Tällöin var: n deklaratiivinen alue tai laajuus alkaa var: n ilmoituskohdasta, jatkuu alaspäin tiedoston loppuun (käännösyksikkö).

Pääfunktion () lohko on eri laajuus; se on sisäkkäinen laajuus globaalille laajuudelle. Jos haluat käyttää globaalin laajuuden entiteettiä eri laajuudesta, tunnusta käytetään suoraan tai sitä edeltää laajuuden resoluutiooperaattori: .

Huomaa: Entiteetti main () ilmoitetaan myös globaalissa laajuudessa.

Estä soveltamisala

Kukin if-, do-, for- tai switch-käsky voi määrittää lohkon. Tällainen lausuma on yhdistetty lause. Lohkossa ilmoitetun muuttujan nimellä on lohkon laajuus. Sen soveltamisala alkaa ilmoituksen kohdasta ja päättyy lohkon loppuun. Seuraava lyhyt ohjelma kuvaa tätä muuttujalle ident:

#sisältää
käyttämällä nimitilaa vakio;
int main ()

jos (1 == 1)

/ * joitain lausuntoja * /
int ident = 5;
cout</ * joitain lausuntoja * /

paluu 0;

Lohkon laajuudessa ilmoitettu muuttuja, kuten ident, on paikallinen muuttuja.

Lohkon laajuuden ulkopuolella ja sen yläpuolella ilmoitettu muuttuja näkyy lohkon otsikossa (esim.g., ehto if-lohkolle) ja myös lohkon sisällä. Seuraava lyhyt ohjelma kuvaa tätä muuttujalle identif:

#sisältää
käyttämällä nimitilaa vakio;
int main ()

int identif = 8;
jos (identif == 8)

cout<
paluu 0;

Tuotos on 8. Tässä on kaksi lohkoskooppia: pääfunktion () lohko ja sisäkkäinen if-yhdiste-lause. Sisäkkäinen lohko on pääfunktiolohkon mahdollinen laajuus.

Lohkon laajuuteen sisältyvää ilmoitusta ei voida nähdä lohkon ulkopuolella. Seuraava lyhyt ohjelma, joka ei koota, kuvaa tätä muuttujalla muuttuja:

#sisältää
käyttämällä nimitilaa vakio;
int main ()

jos (1 == 1)

int muuttuja = 15;

cout<paluu 0;

Kääntäjä tuottaa muuttujalle virheilmoituksen.

Yhdistetyn funktion otsikossa ilmoitettua yhteisöä ei voida nähdä yhdistetyn lauseen ulkopuolella (alla). Seuraavaa silmukan koodia ei koota, mikä johtaa virheilmoitukseen:

#sisältää
käyttämällä nimitilaa vakio;
int main ()

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

cout<
cout<paluu 0;

Iteraatiomuuttuja, i, näkyy silmukan estolohkon sisällä, mutta ei silmukan estolohkon ulkopuolella.

Toiminnon laajuus

Toimintoparametri näkyy toimintolohkossa. Funktiolohkossa ilmoitettu kokonaisuus nähdään ilmoituspisteestä funktiolohkon loppuun. Seuraava lyhyt ohjelma kuvaa tätä:

#sisältää
#sisältää
käyttämällä nimitilaa vakio;
merkkijono fn (merkkijono str)

char stri [] = "banaanit";
/ * muut lausunnot * /
merkkijono totalStr = str + nauha;
paluu totalStr;

int main ()

merkkijono totStr = fn ("syöminen");
cout<paluu 0;

Tuotos on:
syö banaaneja

Huomaa: Funktion ulkopuolella (sen yläpuolella) ilmoitettu entiteetti näkyy toimintoparametriluettelossa ja myös funktiolohkossa.

Tarra

Tarran laajuus on toiminto, jossa se esiintyy. Seuraava koodi kuvaa tätä:

#sisältää
käyttämällä nimitilaa vakio;
void fn ()

goto labl;
/ * muut lausunnot * /
labl: int inte = 2;
cout<
int main ()

fn ();
paluu 0;

Lähtö on 2.

Luettelon laajuus

Laajentamaton luettelo
Harkitse seuraavaa if-block:

jos (1 == 1)

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

Lähtö on 0 1 3.

Lohkon ensimmäinen rivi on luettelo, a, b ja c ovat sen laskijoita. Luettelijan laajuus alkaa ilmoituspisteestä luettelon liitteellisen lohkon loppuun.

Seuraavaa lausetta ei koota, koska c-lausekkeen piste on a-pisteen jälkeen:

enum a = c + 2, b, c;

Seuraavaa koodisegmenttiä ei koota, koska laskijoita käytetään luettelon liitteen jälkeen:

jos (1 == 1)

enum a, b, c = b + 2;

cout<Yllä olevaa luetteloa kuvataan kopioimattomaksi luetteloksi ja sen luetteloijia kuvataan kopioimattomiksi luetteloijiksi. Tämä johtuu siitä, että se alkaa vain varatulla sanalla enum. Luettelot, jotka alkavat enum-luokassa tai enum-rakenteella, kuvataan kattaviksi luetteloiksi. Heidän luetteloijansa kuvataan kattaviksi luetteloijiksi.

Laajennettu luettelo
Seuraava lausunto on OK:

enum-luokka nam a, b, c = b + 2;

Tämä on esimerkki rajatusta luettelosta. Luokan nimi on nam. Tässä laskurin laajuus alkaa ilmoituksen kohdasta laskentamääritelmän loppuun, eikä laskennan liitteen loppuun. Seuraavaa koodia ei koota:

jos (1 == 1)

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

Luokan laajuus

Normaalilla ulottuvuudella deklaratiivinen alue alkaa pisteestä, jatkuu sitten ja pysähtyy eri pisteessä. Laajuus on olemassa yhdellä jatkuvalla alueella. Luokan kanssa yksikön laajuus voi olla eri alueilla, joita ei ole yhdistetty toisiinsa. Sisäkkäisiä lohkoja koskevat säännöt ovat edelleen voimassa. Seuraava ohjelma kuvaa tätä:

#sisältää
käyttämällä nimitilaa vakio;
// Perusluokka
luokka Cla

yksityinen:
int memP = 5;
suojattu:
int memPro = 9;
julkinen:
void fn ()

cout<
;
// Johdettu luokka
luokka DerCla: julkinen Cla

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

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

Tuotos on:
5
9

Luokassa Cla muuttuja memP nähdään ilmoituskohdassa. Sen jälkeen lyhyt "suojatun" osa ohitetaan ja nähdään sitten uudelleen luokan jäsenfunktiolohkossa. Johdettu luokka ohitetaan ja nähdään sitten uudelleen main () -funktion laajuudessa (lohko).

Luokassa Cla muuttuja memPro nähdään ilmoituskohdassa. Julkisen toiminnon fn () osa ohitetaan ja nähdään sitten johdetussa luokkakuvauslohkossa. Se näkyy taas pääfunktiossa ().

Laajuuden tarkkuuden operaattori
Laajuusresoluutiooperaattori C ++: ssa on :: . Sitä käytetään luokan staattisen jäsenen käyttämiseen. Seuraava ohjelma kuvaa tätä:

#sisältää
käyttämällä nimitilaa vakio;
luokka Cla

julkinen:
staattinen int const mem = 5;
julkinen:
staattinen void fn ()

cout<
;
int main ()

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

Tuotos on:
5
5

Staattiset jäsenet näkyvät pääfunktiolohkossa (), joihin pääsee käyttämällä skaalausresoluutiooperaattoria.

Malliparametrien laajuus

Malliparametrinimen normaali laajuus alkaa ilmoituskohdasta lohkon loppuun, kuten seuraavassa koodissa:

sapluuna jäsennelty ikä

T Johannes = 11;
U Pietari = 12.3;
T Mary = 13;
U ilo = 14.6;
;

U ja T nähdään lohkossa.

Mallifunktion prototyypin laajuus alkaa ilmoituspisteestä funktioparametriluettelon loppuun, kuten seuraavassa lauseessa:

sapluuna void func (T-nro, U-cha, const-char * str);

Luokan kuvauksen (määritelmän) osalta soveltamisala voi kuitenkin olla myös eri osia, kuten seuraavassa koodissa:

#sisältää
käyttämällä nimitilaa vakio;
sapluuna luokka TheCla

julkinen:
T-numero;
staattinen U ch;
void func (U cha, const char * str)

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

staattinen tyhjä hauska (U ch)

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

;
int main ()

TheCla obj;
obj.numero = 12;
obj.func ('$', "500");
paluu 0;

Nimi piilossa

Esimerkki nimen piilottamisesta tapahtuu, kun saman objektityypin nimi ilmoitetaan uudelleen sisäkkäisessä lohkossa. Seuraava ohjelma kuvaa tätä:

#sisältää
käyttämällä nimitilaa vakio;
void fn ()

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

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

fn ();
paluu 0;

Tuotos on:
4
3

Se johtuu siitä, että sisäkkäisen lohkon var piilotti var ulkolohkossa.

Mahdollisuus toistaa julistus samalla laajuudella

Ilmoituksen kohta on se, missä nimi otetaan käyttöön (ensimmäistä kertaa) sen soveltamisalaan.

Toiminnon prototyyppi
Eri, jopa erityyppisiä kokonaisuuksia ei voida normaalisti ilmoittaa samassa laajuudessa. Funktion prototyyppi voidaan kuitenkin ilmoittaa useammin kuin kerran samassa laajuudessa. Seuraava ohjelma, jossa on kaksi toimintoprototyyppiä ja vastaava toimintomääritelmä, kuvaa tätä:

#sisältää
käyttämällä nimitilaa vakio;
void fn (int numero);
void fn (int numero);
void fn (int numero)

cout<
int main ()

fn (5);
paluu 0;

Ohjelma toimii.

Ylikuormitetut toiminnot
Ylikuormitetut toiminnot ovat toimintoja, joilla on sama nimi, mutta erilaiset toimintojen allekirjoitukset. Toisena poikkeuksena ylikuormitetut toiminnot, joilla on sama nimi, voidaan määritellä samassa laajuudessa. Seuraava ohjelma kuvaa tätä:

#sisältää
käyttämällä nimitilaa vakio;
void fn (int numero)

cout<
void fn (kelluva no)

cout<
int main ()

fn (5);
kelluva flt = 8.7;
fn (flt);
paluu 0;

Tuotos on:
5
8.7

Ylikuormitetut toiminnot on määritelty maailmanlaajuisesti.

Nimitilan laajuus

Nimitilan laajuus ansaitsee oman artikkelin. Mainittu artikkeli on kirjoitettu tälle verkkosivustolle, linuxhint.com. Kirjoita vain hakusanat ”Namespace Scope” tämän sivuston (sivu) hakukenttään ja napsauta OK, niin saat artikkelin.

Laajuus eri osina

Luokka ei ole ainoa järjestelmä, jossa laajuus voi olla eri osina. Ystäväspesifikaattori, laaditun tyypin määrittelijän tietyt käyttötavat ja käyttödirektiivit ovat muita järjestelmiä, joissa soveltamisala on eri paikoissa - lisätietoja, katso myöhemmin.

Johtopäätös

Soveltamisala on vakuuttava alue. Deklaratiivinen alue on suurin osa ohjelmatekstistä, jossa yksikön nimi on voimassa. Se voidaan jakaa useampaan kuin yhteen osaan tiettyjen ohjelmointijärjestelmien, kuten sisäkkäisten lohkojen, mukaisesti. Osat, joilla ei ole ilmoituskohtaa, muodostavat potentiaalisen laajuuden. Mahdollisella soveltamisalalla voi olla ilmoitus tai ei.