Cikk tartalma
- Deklarációs régió és hatály
- Globális hatókör
- Blokk hatókör
- Funkció hatóköre
- Felsorolás hatóköre
- Osztály hatóköre
- Sablonparaméter hatóköre
- Név elrejtése
- Lehetőség az ismételt bejelentésre ugyanabban a körben
- Névtér hatóköre
- Hatókör különböző adagokban
- Következtetés
Deklarációs 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 a régió, amelyben a minősítetlen név használható (látható) ugyanarra az entitásra való hivatkozáshoz. Tekintsük a következő rövid programot:
#befoglalni
segítségével névtérórák;
üresfn()
{
intahol= 3;
ha (1==1)
{
költség<<ahol<<' n';
}
}
intfő-()
{
fn();
Visszatérés 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. Az azonosító, a var, bevezetésre kerül és látható a külső blokkban. Látható a belső blokkban is, a cout állítással. 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 a belső blokkban levő úszó deklarálására. A következő kód ezt szemlélteti:
#befoglalni
segítségével névtérórák;
üresfn()
{
intahol= 3;
ha (1==1)
{
úszóahol= 7.5;
költség<<ahol<<' n';
}
}
intfő-()
{
fn();
Visszatérés 0;
}
A kimenet 7,5. Ebben az esetben a var név a továbbiakban nem használható a belső blokkban a 3. érték egész számára való hivatkozásra, amelyet a külső blokkban vezettünk be (deklaráltunk). Az ilyen belső blokkokat potenciális hatókörnek nevezik a külső blokkban deklarált entitások számára.
Megjegyzés: Az azonos típusú entitás, mint például a külső blokk, továbbra is deklarálható a belső blokkban. Azonban ebben az esetben a belső blokkban érvényes az új deklaráció és annak jelentése, míg a régi deklaráció és annak jelentése a belső blokkon kívül a külső blokkban marad érvényben.
Az azonos nevű nyilatkozat egy belső blokkban általában felülírja az azonos nevű nyilatkozatot a belső blokkon kívül. A belső blokkok más belső blokkokat is beágyazhatnak.
Globális hatókör
Amikor egy programozó csak elkezdi beírni a fájlt, ez a globális hatókör. Az alábbi rövid program ezt szemlélteti:
#befoglalnisegítségével névtérórák;
úszóahol= 9.4;
intfő-()
{
költség <<ahol<<' n';
költség <<::ahol<<' n';
Visszatérés 0;
}
A kimenet:
9.4
9.4
Ebben az esetben a var deklarációs régiója vagy hatóköre a var deklarálási pontjától kezdődik, és lefelé tart a fájl (fordítási egység) végéig.
A main () függvény blokkja eltérő hatókörű; ez a globális hatókör beágyazott hatóköre. A globális hatókörű entitás eléréséhez egy másik hatókörből az azonosítót közvetlenül vagy előtte használja a hatókörfeloldó operátor, ::.
Megjegyzés: A main () entitás szintén a globális hatókörben van deklarálva.
Blokk hatókör
Az if, while, do, for vagy switch utasítás mindegyike definiálhat egy blokkot. Egy ilyen állítás összetett állítás. A blokkban deklarált változó nevének van egy blokk hatóköre. Hatálya a nyilatkozat helyé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ónál:
#befoglalnisegítségével névtérórák;
intfő-()
{
ha (1==1)
{
/*néhány állítás*/
intazonosító= 5;
költség<<azonosító<<' n';
/*néhány állítás*/
}
Visszatérés 0;
}
A blokk hatókörében deklarált változó, például ident, helyi változó.
A blokk hatókörén kívül és fölötte deklarált változó látható a blokk fejlécében (például az if-block feltétele) és a blokkon belül is. A következő rövid program ezt szemlélteti az azonosító változó esetében:
#befoglalnisegítségével névtérórák;
intfő-()
{
intazonosít= 8;
ha (azonosít== 8)
{
költség<<azonosít<<' n';
}
Visszatérés 0;
}
A kimenet 8. Itt két blokk hatókör van: a main () függvény blokkja és a beágyazott if-complex utasítás. A beágyazott blokk a main () funkcióblokk lehetséges 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 áll össze, ezt a változó változóval szemlélteti:
#befoglalnisegítségével névtérórák;
intfő-()
{
ha (1 == 1)
{
intváltozó= tizenöt;
}
költség<<változó<<' n'; // hiba: a hatókörén kívül érhető el.
Visszatérés 0;
}
A fordító hibaüzenetet ad a változónak.
Az összetett függvény fejlécében deklarált entitás nem látható az összetett utasításon kívül (alatta). A következő for-loop kód nem lesz fordítva, ami hibaüzenetet eredményez:
#befoglalnisegítségével névtérórák;
intfő-()
{
számára (intén=0;én<4; ++én)
{
költség<<én<<'';
}
költség<<én<<'';
Visszatérés 0;
}
Az i iterációs változó a for-loop blokkon belül látható, de a for-loop blokkon kívül nem.
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 funkcióblokk végéig látható. Az alábbi rövid program ezt szemlélteti:
#befoglalni#befoglalni
segítségével névtérórák;
karakterlánc fn(string str)
{
charstri[] = 'banán';
/*egyéb állítások*/
string totalStr=o+stri;
VisszatéréstotalStr;
}
intfő-()
{
karakterlánc totStr=fn('enni ');
költség<<totStr<<' n';
Visszatérés 0;
}
A kimenet:
banánt eszik
Megjegyzés: A függvényen kívül (fölötte) deklarált entitás látható a funkcióparamé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:
#befoglalnisegítségével névtérórák;
üresfn()
{
menjlabl;
/*egyéb állítások*/
labl: intnem= 2;
költség<<nem<<' n';
}
intfő-()
{
fn();
Visszatérés 0;
}
A kimenet 2.
Felsorolás hatóköre
Áttekinthetetlen felsorolás
Fontolja meg a következő if-blokkot:
{
enum {a, b, c=b+2};
költség<<nak nek<<''<<b<<''<<c<<' n';
}
A kimenet 0 1 3.
A blokk első sora egy felsorolás, a, b és c a felsorolói. A felsoroló hatóköre a bejelentés helyétől a felsorolás mellékelő blokkjának végéig kezdődik.
Az alábbi utasítás nem áll össze, mert a c deklarálási pontja az a után van:
enum {nak nek=c+2, időszámításunk előtt};A következő kódszegmens nem lesz összeállítva, mert a felsorolók a felsorolás záró blokkja után érhetők el:
ha (1==1){
enum {a, b, c=b+2};
}
költség<<nak nek<<''<<b<<''<<c<<' n'; // hiba: hatókörön kívül
A fenti felsorolást letapogatott felsorolásként, felsorolóit pedig letapogatott felsorolóként írják le. Ez azért van, mert csak a fenntartott szóval kezdődik, enum. Az enum class vagy enum structure -val kezdődő felsorolásokat hatókör -felsorolásként írják le. Felsorolójukat hatókörű számlálónak írják le.
Hatósági felsorolás
A következő állítás rendben van:
Ez egy példa a hatókör -felsorolásra. Az osztály neve nam. Itt a felsoroló hatóköre a deklarálási ponttól a felsorolás definíciójának végéig kezdődik, és nem a felsoroláshoz tartozó záró blokk vége. A következő kód nem lesz lefordítva:
ha (1==1){
enum osztályférfi{a, b, c=b+2};
költség<<nak nek<<''<<b<<''<<c<<' n'; // hiba: kívül esik az enum osztályon vagy az enum szerkezeten
}
Osztály hatóköre
Normál hatókörrel a deklaratív régió egy pontból indul, majd folytatódik és egy másik ponton áll meg. A hatókör egy folyamatos régióban létezik. Az osztály használatával 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. Az alábbi program ezt szemlélteti:
#befoglalnisegítségével névtérórák;
// Alaposztály
osztályCla
{
magán:
intmemP= 5;
védett:
intmemPro= 9;
nyilvános:
üresfn()
{
költség<<memP<<' n';
}
};
// Származtatott osztály
osztályDerCla: nyilvánosCla
{
nyilvános:
intderMem=memPro;
};
intfő-()
{
Cla obj;
obj.fn();
DerCla derObj;
költség<<derObj.derMem<<' n';
Visszatérés 0;
}
A kimenet:
5
9
A Cla osztályban a memP változó látható a deklarációs ponton. Ezt követően a védett rövid rész kihagyásra kerül, majd újra látható az osztálytag 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ó látható a deklarációs ponton. Az fn () nyilvános függvény részét kihagyja, majd a származtatott osztályleíró blokkban látja. Ez ismét látható a main () függvényben.
Hatókör -felbontás kezelője
A hatókör -felbontás operátora a C ++ nyelvben ::. Az osztály statikus tagjának elérésére szolgál. Az alábbi program ezt szemlélteti:
segítségével névtérórák;
osztályCla
{
nyilvános:
statikus int constén én= 5;
nyilvános:
statikus üresfn()
{
költség<<én én<<' n';
}
};
intfő-()
{
költség<<Cla::én én<<' n';
Cla::fn();
Visszatérés 0;
}
A kimenet:
5
5
A statikus tagok a fő () funkcióblokkban láthatók, és a hatókör -felbontási operátorral érhetők el.
Sablonparaméter hatóköre
A sablonparaméter -név normál hatóköre a deklarációs ponttól a blokk végéig kezdődik, a következő kód szerint:
sablon<típusnévT,típusnévU> strukKorok{
T János= tizenegy;
Te Péter= 12.3;
T Mary= 13;
U Joy= 14.6;
};
U és T látható a blokkon belül.
A sablonfüggvény prototípus esetében a hatókör a deklarációs ponttól a függvényparaméter -lista végéig kezdődik, az alábbi utasítás szerint:
sablon<típusnévT,típusnévU> üresfunkció(Nem, te csaj,const char *o);Amikor azonban az osztályleírásról (definícióról) van szó, a hatókör különböző részekből is állhat, mint az alábbi kódban:
#befoglalnisegítségével névtérórák;
sablon<osztályT,osztályU> osztályTheCla
{
nyilvános:
t szám;
statikusU ch;
üresfunkció(Te apa,const char *o)
{
költség << 'Vannak ' <<az egyiken<< 'érdemes könyvek' <<nem<<o<< ' az áruházban.' << ' n';
}
statikus üresszórakoztató(U ch)
{
ha (ch== 'nak nek')
költség << „Hivatalos statikus tagfunkció” << ' n';
}
};
intfő-()
{
TheCla<int,char>obj;
obj.az egyiken = 12;
obj.funkció('$','500');
Visszatérés 0;
}
Név elrejtése
Példa a név elrejtésére akkor fordul elő, ha ugyanazon objektumtípus nevét újra bejelenti egy beágyazott blokkban. Az alábbi program ezt szemlélteti:
#befoglalnisegítségével névtérórák;
üresfn()
{
intahol= 3;
ha (1==1)
{
intahol= 4;
költség<<ahol<<' n';
}
költség<<ahol<<' n';
}
intfő-()
{
fn();
Visszatérés 0;
}
A kimenet:
4
3
Ez azért van, mert a var a beágyazott blokkban elrejtette a var -t a külső blokkban.
Lehetőség az ismételt bejelentésre ugyanabban a körben
A nyilatkozat lényege az, hogy a nevet (először) a hatókörébe vezetik be.
Funkció prototípus
Különböző entitások, akár különböző típusúak, általában nem deklarálhatók ugyanabba a körbe. Egy funkció prototípusa azonban többször is deklarálható ugyanabban a hatókörben. A következő program két funkció prototípussal és a megfelelő funkciódefinícióval szemlélteti ezt:
segítségével névtérórák;
üresfn(intaz egyiken);
üresfn(intaz egyiken);
üresfn(intaz egyiken)
{
költség<<az egyiken<<' n';
}
intfő-()
{
fn(5);
Visszatérés 0;
}
A program működik.
Túlterhelt funkciók
A túlterhelt függvények azonos nevű, de eltérő funkció -aláírással rendelkező funkciók. Más kivételként ugyanabban a néven túlterhelt függvények határozhatók meg ugyanabban a hatókörben. Az alábbi program ezt szemlélteti:
segítségével névtérórák;
üresfn(intaz egyiken)
{
költség<<az egyiken<<' n';
}
üresfn(úszónem)
{
költség<<nem<<' n';
}
intfő-()
{
fn(5);
úszóflt= 8.7;
fn(flt);
Visszatérés 0;
}
A kimenet:
5
8.7
A túlterhelt függvényeket a globális hatókör határozza meg.
Névtér hatóköre
A Namespace Scope megérdemli a saját cikkét. Az említett cikket erre a weboldalra írták, linuxhint.com. Csak írja be a keresett szavakat Namespace Scope az oldal (oldal) keresőmezőjébe, majd kattintson az OK gombra, és megkapja a cikket.
Hatókör különböző adagokban
Az osztály nem az egyetlen séma, ahol a hatókör különböző részekben lehet. Barátspecifikus, a kidolgozott típus-specifikátor bizonyos felhasználási módjai és a használati utasítások olyan más rendszerek, ahol a hatókör 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. A lehetséges hatókör tartalmazhatja vagy nem tartalmazza a nyilatkozatot.