Hatály C ++ -ban

A C ++ kategóriában lévő entitásnak van egy neve, amely deklarálható és / vagy meghatározható. A nyilatkozat definíció, de a definíció nem feltétlenül deklaráció. Egy definíció lefoglalja a memóriát a megnevezett entitás számára, de egy deklaráció lefoglalhatja a memóriát a megnevezett entitás számára. A deklaratív régió a program legnagyobb része, amelyben egy entitás (változó) neve érvényes. Ezt a régiót hatókörnek vagy potenciális hatókörnek nevezzük. Ez a cikk elmagyarázza a hatókört C-ben++. Ezenkívül a cikk megértéséhez alapvető ismeretek szükségesek a C ++ nyelven.

A cikk tartalma

Nyilatkozati régió és hatály
Globális hatály
Blokk hatálya
Funkció hatóköre
Felsorolási kör
Osztály hatálya
Sablonparaméter hatóköre
Név rejtőzik
Lehetőség a nyilatkozat megismétlésére ugyanabban a körben
Névtér hatóköre
Hatókör különböző részekben
Következtetés

Nyilatkozati régió és hatály

A deklaratív régió a program szövegének legnagyobb része, amelyben az entitás neve érvényes. Ez az a régió, ahol a minősítés nélküli név felhasználható (látható) ugyanazon entitásra való hivatkozásra. Fontolja meg a következő rövid programot:

#include
névtér használata std;
void fn ()

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

cout<

int main ()

fn ();
visszatér 0;

Az fn () függvénynek két blokkja van: egy belső blokk az if-feltételhez és egy külső blokk a függvénytesthez. A var azonosító beillesztésre kerül és látható a külső blokkban. A belső blokkban is látható, a cout utasítással együtt. A külső és a belső blokk egyaránt a név hatóköre, var.

A var név azonban továbbra is használható egy másik entitás, például egy úszó deklarálására a belső blokkban. A következő kód ezt szemlélteti:

#include
névtér használata std;
void fn ()

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

úszó var = 7.5;
cout<

int main ()

fn ();
visszatér 0;

A kimenet 7.5. Ebben az esetben a var, név már nem használható a belső blokkban a 3. érték egészére való hivatkozásra, amelyet a külső blokkban vezettünk be (deklaráltunk). Ezeket a belső blokkokat a külső blokkban deklarált entitások potenciális hatókörének nevezzük.

Megjegyzés: Azonos típusú entitás, mint a külső blokké, továbbra is deklarálható a belső blokkban. Ebben az esetben azonban a belső blokkban érvényes az új deklaráció és annak jelentése, míg a régi deklaráció és a belső blokkon kívüli jelentése továbbra is érvényes a külső blokkban.

Az azonos nevű deklaráció egy belső blokkban általában felülírja az ugyanazon név deklarációját a belső blokkon kívül. A belső blokkok más belső blokkokat is beágyazhatnak.

Globális hatály

Amikor egy programozó éppen elkezdi beírni a fájlt, ez a globális hatókör. A következő rövid program ezt szemlélteti:

#include
névtér használata std;
úszó var = 9.4;
int main ()

cout <cout <<::var<<'\n';
visszatér 0;

A kimenet:
9.4
9.4

Ebben az esetben a deklaratív régió vagy a var hatóköre a var deklarálásának pontjától kezdődik, lefelé folytatódik a fájl végéig (fordítási egység).

A main () függvény blokkja egy másik hatókör; ez a globális hatókör beágyazott hatóköre. A globális hatókörű entitásokhoz egy másik hatókörből való hozzáféréshez az azonosítót közvetlenül használja vagy megelőzi a hatókör-felbontás operátor: .

Megjegyzés: Az entitás, a main () szintén deklarálva van a globális hatókörben.

Blokk hatálya

Az if, while, do, for vagy switch utasítás mindegyike meghatározhat egy blokkot. Az ilyen állítás összetett állítás. A blokkban deklarált változó neve rendelkezik egy blokk hatókörével. Hatálya a nyilatkozat kezdetén kezdődik és a blokk végén ér véget. A következő rövid program ezt szemlélteti az ident változóval:

#include
névtér használata std;
int main ()

ha (1 == 1)

/ * néhány állítás * /
int azonos = 5;
cout</ * néhány állítás * /

visszatér 0;

A blokk hatókörében deklarált változó, például ident, egy lokális változó.

A blokk hatókörén kívül és azon felül deklarált változó látható a blokk fejlécében (pl.g., if-block feltétel) és a blokkon belül is. A következő rövid program ezt szemlélteti az identif változóval:

#include
névtér használata std;
int main ()

int azonos = 8;
if (azonosító == 8)

cout<
visszatér 0;

A kimenet 8. Két blokkkör van itt: a main () függvény blokkja és a beágyazott if-összetett utasítás. A beágyazott blokk a main () függvényblokk potenciális hatóköre.

A blokk hatókörében bevezetett deklaráció nem látható a blokkon kívül. A következő rövid program, amely nem fordítja össze, ezt a változóval, a változóval szemlélteti:

#include
névtér használata std;
int main ()

ha (1 == 1)

int változó = 15;

cout<visszatér 0;

A fordító hibaüzenetet állít elő a változó számára.

Az összetett függvény fejlécében deklarált entitás nem látható az összetett utasításon kívül (alatt). A következő for-loop kód nem fordítható le, és hibaüzenetet kap:

#include
névtér használata std;
int main ()

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

cout<
cout<visszatér 0;

Az iterációs változó, i, a for-loop blokkon belül látható, de nem a for-loop blokkon kívül.

Funkció hatóköre

Egy funkcióparaméter látható a funkcióblokkban. A funkcióblokkban deklarált entitás a deklarációs ponttól a függvényblokk végéig látható. A következő rövid program ezt szemlélteti:

#include
#include
névtér használata std;
string fn (string str)

char stri [] = "banán";
/ * egyéb állítások * /
string totalStr = str + stri;
return totalStr;

int main ()

string totStr = fn ("eszik");
cout<visszatér 0;

A kimenet:
banánt eszik

Megjegyzés: A függvényen kívül (annak fölött) deklarált entitás látható a függvényparaméter-listában és a funkcióblokkban is.

Címke

A címke hatóköre az a funkció, amelyben megjelenik. A következő kód ezt szemlélteti:

#include
névtér használata std;
void fn ()

goto labl;
/ * egyéb állítások * /
labl: int inte = 2;
cout<
int main ()

fn ();
visszatér 0;

A kimenet 2.

Felsorolási kör

Fel nem sorolt felsorolás
Vegye figyelembe a következő if-blokkot:

ha (1 == 1)

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

A kimenet 0 1 3.

A blokk első sora egy felsorolás, a, b és c a felsorolója. A felsoroló hatóköre a nyilatkozattól kezdve a felsorolás mellékelő blokkjának végéig kezdődik.

A következő állítás nem áll össze, mert a c deklarálás pontja az a után áll:

enum a = c + 2, b, c;

A következő kódszegmens nem áll össze, mert a felsorolókhoz a felsorolás záró blokkja után férnek hozzá:

ha (1 == 1)

enum a, b, c = b + 2;

cout<A fenti felsorolást le nem írt felsorolásként, a felsorolókat pedig le nem sorolt felsorolóként írják le. Ennek oka, hogy csak a fenntartott szóval, az enum kezdődik. Az enum osztállyal vagy enum struktúrával kezdődő felsorolásokat hatókörű felsorolásként írjuk le. A felsorolókat körükben felsoroltaknak tekintik.

Hatályos felsorolás
A következő állítás rendben van:

enum osztály nam a, b, c = b + 2;

Ez egy példa a hatókörű felsorolásra. Az osztály neve nam. Itt a felsoroló hatóköre a deklarálás pontjától a felsorolás definíciójának végéig kezdődik, és nem a felsorolás mellékelő blokkjának végétől kezdődik. A következő kód nem áll össze:

ha (1 == 1)

enum osztály nam a, b, c = b + 2;
cout<

Osztály hatálya

Normál hatókörrel a deklaratív régió egy ponttól kezdődik, majd folytatódik és egy másik ponton áll meg. A hatókör egy folyamatos régióban létezik. Az osztállyal az entitás hatóköre különböző régiókban lehet, amelyek nincsenek összekapcsolva. A beágyazott blokkokra vonatkozó szabályok továbbra is érvényesek. A következő program ezt szemlélteti:

#include
névtér használata std;
// Alaposztály
osztály Cla

magán:
int memP = 5;
védett:
int memPro = 9;
nyilvános:
void fn ()

cout<
;
// Származtatott osztály
osztály DerCla: nyilvános Cla

nyilvános:
int derMem = memPro;
;
int main ()

Cla obj;
obj.fn ();
DerCla derObj;
cout<visszatér 0;

A kimenet:
5
9

A Cla osztályban a memP változó a deklarálás pontján látható. Ezt követően a „védett” rövid része kihagyásra kerül, majd újra látható az osztálytagok funkcióblokkjában. A származtatott osztály kihagyásra kerül, majd újra látható a main () függvény hatókörén (blokk).

A Cla osztályban a memPro változó a deklarálás pontján látható. Az fn () nyilvános függvény része kihagyásra kerül, majd a származtatott osztályleíró blokkban látható. A main () függvényben újra lent látható.

Hatályfeloldás kezelő
A hatókörfeloldás operátora a C ++ nyelven: . Az osztály statikus tagjának elérésére szolgál. A következő program ezt szemlélteti:

#include
névtér használata std;
osztály Cla

nyilvános:
statikus int const mem = 5;
nyilvános:
static void fn ()

cout<
;
int main ()

cout<Cla :: fn ();
visszatér 0;

A kimenet:
5
5

A statikus tagok a main () funkcióblokban láthatók, amelyekhez a hatókör-felbontás operátor segítségével férhetünk hozzá.

Sablonparaméter hatóköre

A sablonparaméter nevének normál hatóköre a deklaráció helyétől a blokk végéig kezdődik, a következő kód szerint:

sablon strukturált korok

T János = 11;
U Péter = 12.3;
T Mária = 13;
U Öröm = 14.6;
;

U és T látható a blokkon belül.

Egy sablonfüggvény prototípus esetén a hatókör a deklaráció pontjától a függvényparaméter-lista végéig kezdődik, a következő utasítás szerint:

sablon void func (T no, U cha, const char * str);

Ha azonban az osztályleírásról (definícióról) van szó, akkor a hatókör különböző részekből állhat, mint a következő kódban:

#include
névtér használata std;
sablon osztály TheCla

nyilvános:
T szám;
statikus U ch;
void func (U cha, const char * str)

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

statikus üresség (U ch)

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

;
int main ()

TheCla obj;
obj.szám = 12;
obj.func ('$', "500");
visszatér 0;

Név rejtőzik

A név elrejtésére példa akkor fordul elő, amikor ugyanazon objektumtípus nevét újból deklarálják egy beágyazott blokkban. A következő program ezt szemlélteti:

#include
névtér használata std;
void fn ()

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

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

fn ();
visszatér 0;

A kimenet:
4
3

Ez azért van, mert a beágyazott blokk var-je elrejtette a var-t a külső blokkban.

Lehetőség a nyilatkozat megismétlésére ugyanabban a körben

A nyilatkozat lényege, hogy a nevet (először) bevezetik annak hatálya alá.

Funkció prototípus
Különböző entitások, még különböző típusúak sem, általában nem deklarálhatók ugyanabban a körben. A függvény prototípusa azonban többször is deklarálható ugyanabban a hatókörben. A következő program két függvény prototípussal és a megfelelő funkciódefinícióval szemlélteti ezt:

#include
névtér használata std;
void fn (int szám);
void fn (int szám);
void fn (int szám)

cout<
int main ()

fn (5);
visszatér 0;

A program működik.

Túlterhelt funkciók
A túlterhelt függvények ugyanazon névvel, de eltérő függvényaláírással rendelkező függvények. További kivételként a túlterhelt, azonos nevű függvények ugyanabban a hatókörben definiálhatók. A következő program ezt szemlélteti:

#include
névtér használata std;
void fn (int szám)

cout<
void fn (float no)

cout<
int main ()

fn (5);
úszó flt = 8.7;
fn (flt);
visszatér 0;

A kimenet:
5
8.7

A túlterhelt függvényeket a globális hatókörben definiálták.

Névtér hatóköre

A névtér hatóköre megérdemli a saját cikkét. Az említett cikket erre a weboldalra, a linuxhint-re írták.com. Csak írja be a „Névtér hatóköre” keresőszavakat a webhely (oldal) keresőmezőjébe, majd kattintson az OK gombra, és megkapja a cikket.

Hatókör különböző részekben

Az osztály nem az egyetlen séma, ahol a hatókör különböző részekben lehet. Az ismerős specifikátor, a kidolgozott típus-specifikátor bizonyos felhasználási módjai és az irányelvek használata olyan sémák, amelyek hatóköre különböző helyeken található - a részleteket lásd később.

Következtetés

A hatókör deklaratív régió. A deklaratív régió a program szövegének legnagyobb része, amelyben az entitás neve érvényes. Bizonyos programozási sémáknak megfelelően több részre osztható, például beágyazott blokkokra. Azok a részek, amelyek nem rendelkeznek a deklarációs ponttal, alkotják a lehetséges hatókört. Lehetséges, hogy a hatókörben szerepel a nyilatkozat.