Nilalaman ng Artikulo
- Declarative Region at Saklaw
- Global Saklaw
- Saklaw ang Saklaw
- Saklaw ng Pag-andar
- Saklaw ng Enumerasyon
- Saklaw ng Klase
- Saklaw ng Parameter ng Template
- Pagtatago ng Pangalan
- Posibilidad para sa Pag-uulit ng Pagpapahayag sa Parehong Saklaw
- Saklaw ng Namespace
- Saklaw sa Iba't ibang Mga Bahagi
- Konklusyon
Declarative Region at Saklaw
Ang isang nagpapahayag na rehiyon ay ang pinakamalaking bahagi ng isang teksto ng programa kung saan may bisa ang pangalan ng isang entity. Ito ang rehiyon kung saan maaaring magamit (makita) ang hindi kwalipikadong pangalan upang mag-refer sa parehong nilalang. Isaalang-alang ang sumusunod na maikling programa:
# isama
gamit namespaceoras;
walang bisafn()
{
intkung saan= 3;
kung (1==1)
{
gastos<<kung saan<<' n';
}
}
intpangunahing()
{
fn();
bumalik ka 0;
}
Ang pagpapaandar fn () ay may dalawang mga bloke: isang panloob na bloke para sa kung-kondisyon at isang panlabas na bloke para sa pagpapaandar ng katawan. Ang identifier, var, ay ipinakilala at nakikita sa panlabas na bloke. Makikita rin ito sa panloob na bloke, kasama ang pahayag ng cout. Ang panlabas at panloob na mga bloke ay pareho ang saklaw para sa pangalan, var.
Gayunpaman, ang pangalan na var ay maaari pa ring magamit upang magdeklara ng ibang entity tulad ng float sa panloob na bloke. Ang sumusunod na code ay naglalarawan nito:
# isama
gamit namespaceoras;
walang bisafn()
{
intkung saan= 3;
kung (1==1)
{
lumutangkung saan= 7.5;
gastos<<kung saan<<' n';
}
}
intpangunahing()
{
fn();
bumalik ka 0;
}
Ang output ay 7.5. Sa kasong ito, ang pangalan, var, ay hindi na magagamit sa panloob na bloke upang mag-refer sa integer ng halagang 3, na ipinakilala (idineklara) sa panlabas na bloke. Ang nasabing mga panloob na bloke ay tinukoy bilang potensyal na saklaw para sa mga nilalang na idineklara sa panlabas na bloke.
Tandaan: Ang isang nilalang na may parehong uri, tulad ng panlabas na bloke, ay maaari pa ring ideklara sa panloob na bloke. Gayunpaman, sa kasong ito, kung ano ang wasto sa panloob na bloke ay ang bagong deklarasyon at ang kahulugan nito, habang ang dating deklarasyon at ang kahulugan nito sa labas ng panloob na bloke ay mananatiling wasto sa panlabas na bloke.
Ang isang pagdeklara ng parehong pangalan sa isang panloob na bloke ay karaniwang overrides ang deklarasyon ng parehong pangalan sa labas ng panloob na bloke. Ang mga bloke ng panloob ay maaaring pugad ng iba pang mga panloob na bloke.
Global Saklaw
Kapag nagsimula lang ang isang programmer sa pagta-type ng isang file, iyon ang pandaigdigang saklaw. Ang sumusunod na maikling programa ay naglalarawan nito:
# isamagamit namespaceoras;
lumutangkung saan= 9.4;
intpangunahing()
{
gastos <<kung saan<<' n';
gastos <<::kung saan<<' n';
bumalik ka 0;
}
Ang output ay:
9.4
9.4
Sa kasong ito, ang nagpapahayag na rehiyon o saklaw para sa var ay nagsisimula mula sa punto ng deklarasyon para sa var, ay patuloy na pababa hanggang sa katapusan ng file (yunit ng pagsasalin).
Ang bloke ng pangunahing () pagpapaandar ay isang iba't ibang mga saklaw; ito ay isang pugad na saklaw para sa pandaigdigang saklaw. Upang ma-access ang isang entity ng pandaigdigang saklaw, mula sa ibang saklaw, ang tagakilala ay ginagamit nang direkta o naunahan ng operator ng resolusyon ng saklaw, ::.
Tandaan: Ang nilalang, pangunahing (), ay idineklara rin sa pandaigdigang saklaw.
Saklaw ang Saklaw
Ang kung, habang, gawin, para sa, o lumipat ng pahayag ay maaaring tukuyin ang bawat isang bloke. Ang nasabing pahayag ay isang compound statement. Ang pangalan ng isang variable na idineklara sa isang bloke ay may saklaw ng isang bloke. Ang saklaw nito ay nagsisimula sa kanyang punto ng deklarasyon at nagtatapos sa dulo ng bloke nito. Ang sumusunod na maikling programa ay naglalarawan nito para sa variable, ident:
# isamagamit namespaceoras;
intpangunahing()
{
kung (1==1)
{
/ * ilang mga pahayag * /
intident= 5;
gastos<<ident<<' n';
/ * ilang mga pahayag * /
}
bumalik ka 0;
}
Ang isang variable, tulad ng ident, na idineklarang sa saklaw ng block ay isang lokal na variable.
Ang isang variable na idineklara sa labas ng saklaw ng block at sa itaas nito ay makikita sa header ng bloke (hal., Kondisyon para sa if-block) at nasa loob din ng bloke. Ang sumusunod na maikling programa ay naglalarawan nito para sa variable, identif:
# isamagamit namespaceoras;
intpangunahing()
{
intidentif= 8;
kung (identif== 8)
{
gastos<<identif<<' n';
}
bumalik ka 0;
}
Ang output ay 8. Mayroong dalawang mga saklaw ng block dito: ang bloke para sa pangunahing () pag-andar at ang pugad na pahayag na kung-compound. Ang naka-block na bloke ay ang potensyal na saklaw ng pangunahing () function block.
Ang isang deklarasyon na ipinakilala sa isang saklaw ng block ay hindi maaaring makita sa labas ng bloke. Ang sumusunod na maikling programa, na hindi nag-iipon, ay naglalarawan nito sa variable, variab:
# isamagamit namespaceoras;
intpangunahing()
{
kung (1 == 1)
{
intvariab= labinlimang;
}
gastos<<variab<<' n'; // error: na-access sa labas ng saklaw nito.
bumalik ka 0;
}
Gumagawa ang tagatala ng isang mensahe ng error para sa variab.
Ang isang entity na ipinakilala, idineklara sa header ng isang compound function, ay hindi makikita sa labas (sa ibaba) ng pahayag ng tambalan. Ang sumusunod na for-loop code ay hindi makakaipon, na nagreresulta sa isang mensahe ng error:
# isamagamit namespaceoras;
intpangunahing()
{
para sa (intako=0;ako<4; ++ako)
{
gastos<<ako<<';
}
gastos<<ako<<';
bumalik ka 0;
}
Ang variable ng pag-ulit, i, ay nakikita sa loob ng for-loop block ngunit hindi sa labas ng for-loop block.
Saklaw ng Pag-andar
Ang isang parameter ng pag-andar ay nakikita sa function block. Ang isang nilalang na idineklara sa isang function block ay makikita mula sa punto ng deklarasyon hanggang sa katapusan ng function block. Ang sumusunod na maikling programa ay naglalarawan nito:
# isama# isama
gamit namespaceoras;
string fn(string str)
{
charstri[] = 'saging';
/ * iba pang mga pahayag * /
string totalStr=p+stri;
bumalik katotalStr;
}
intpangunahing()
{
string totStr=fn('kumakain');
gastos<<totStr<<' n';
bumalik ka 0;
}
Ang output ay:
kumakain ng saging
Tandaan: Ang isang nilalang na idineklara sa labas ng pagpapaandar (sa itaas nito) ay maaaring makita sa listahan ng parameter ng pag-andar at gayundin sa pag-andar ng pag-andar.
Tatak
Ang saklaw ng isang label ay ang pagpapaandar kung saan ito lilitaw. Ang sumusunod na code ay naglalarawan nito:
# isamagamit namespaceoras;
walang bisafn()
{
pumunta salabl;
/ * iba pang mga pahayag * /
labl: inthindi= 2;
gastos<<hindi<<' n';
}
intpangunahing()
{
fn();
bumalik ka 0;
}
Ang output ay 2.
Saklaw ng Enumerasyon
Unscoped Enumeration
Isaalang-alang ang sumusunod na if-block:
{
enum {a, b, c=b+2};
gastos<<sa<<'<<b<<'<<c<<' n';
}
Ang output ay 0 1 3.
Ang unang linya sa bloke ay isang enumerasyon, a, b, at c ang mga enumerator nito. Ang saklaw ng isang enumerator ay nagsisimula mula sa punto ng deklarasyon hanggang sa katapusan ng nakapaloob na bloke ng pagpaparehistro.
Ang sumusunod na pahayag ay hindi makakaipon dahil ang punto ng pagdedeklara ng c ay pagkatapos ng isang:
enum {sa=c+2, b, c};Ang sumusunod na segment ng code ay hindi makakaipon dahil ang mga enumerator ay na-access pagkatapos ng nakapaloob na bloke ng pag-enumerate:
kung (1==1){
enum {a, b, c=b+2};
}
gastos<<sa<<'<<b<<'<<c<<' n'; // error: wala sa saklaw
Ang pag-bilang sa itaas ay inilarawan bilang isang walang korteng enumerasyon, at ang mga enumerator nito ay inilarawan bilang mga walang kategoryang enumerator. Ito ay sapagkat nagsisimula lamang ito sa nakalaang-salita, enum. Ang mga bilang na nagsisimula sa klase ng enum o enum na istruktura ay inilarawan bilang mga nasusukat na enumerasyon. Ang kanilang mga enumerator ay inilarawan bilang mga scoped enumerator.
Saklaw na Enumerasyon
Ang sumusunod na pahayag ay OK:
Ito ay isang halimbawa ng isang scoped enumeration. Ang pangalan ng klase ay nam. Dito, ang saklaw ng enumerator ay nagsisimula mula sa punto ng deklarasyon hanggang sa katapusan ng kahulugan ng pag-enumerate, at hindi ang dulo ng enclosing block para sa pag-enumerate. Ang sumusunod na code ay hindi makakaipon:
kung (1==1){
enum klaselalaki{a, b, c=b+2};
gastos<<sa<<'<<b<<'<<c<<' n'; // error: wala sa saklaw para sa enum na klase o enum na istruktura
}
Saklaw ng Klase
Sa normal na pagsasakop, ang nagpapahayag na rehiyon ay nagsisimula mula sa isang punto, pagkatapos ay nagpapatuloy at humihinto sa ibang punto. Ang saklaw ay umiiral sa isang tuluy-tuloy na rehiyon. Sa klase, ang saklaw ng isang entity ay maaaring nasa iba't ibang mga rehiyon na hindi pinagsama. Nalalapat pa rin ang mga panuntunan para sa mga naka-block na bloke. Inilalarawan ito ng sumusunod na programa:
# isamagamit namespaceoras;
// Base class
klaseCla
{
pribado:
intmemP= 5;
protektado:
intmemPro= 9;
pampubliko:
walang bisafn()
{
gastos<<memP<<' n';
}
};
// Hinirang Klase
klaseDerCla: pampublikoCla
{
pampubliko:
intderMem=memPro;
};
intpangunahing()
{
Cla obj;
objfn();
DerCla derObj;
gastos<<derObj.derMem<<' n';
bumalik ka 0;
}
Ang output ay:
5
9
Sa klase na Cla, ang variable na memP, ay makikita sa puntong ng deklarasyon. Pagkatapos nito, ang maikling bahagi ng protektado ay lumaktaw, pagkatapos ay makikita muli sa pagpapaandar ng miyembro ng klase. Ang nakuha na klase ay nilaktawan, pagkatapos ay nakita muli sa pangunahing () saklaw ng pag-andar (block).
Sa klase na Cla, ang variable na memPro, ay makikita sa puntong pagdedeklara. Nilaktawan ang bahagi ng pagpapaandar ng publiko fn (), pagkatapos ay makikita sa hinango na paglalarawan ng klase. Ito ay makikita muli pababa sa pangunahing () pagpapaandar.
Operator ng Resolusyon sa Saklaw
Ang operator ng resolusyon ng saklaw sa C ++ ay ::. Ginagamit ito upang ma-access ang isang static na miyembro ng klase. Inilalarawan ito ng sumusunod na programa:
gamit namespaceoras;
klaseCla
{
pampubliko:
static int Constmeme= 5;
pampubliko:
static walang bisafn()
{
gastos<<meme<<' n';
}
};
intpangunahing()
{
gastos<<Cla::meme<<' n';
Cla::fn();
bumalik ka 0;
}
Ang output ay:
5
5
Ang mga static na miyembro ay nakikita sa pangunahing () function block, na-access gamit ang operator ng resolusyon ng saklaw.
Saklaw ng Parameter ng Template
Ang normal na saklaw ng isang pangalan ng parameter ng template ay nagsisimula mula sa punto ng deklarasyon hanggang sa katapusan ng bloke nito, tulad ng sa sumusunod na code:
template<typenameT,typenameU> istrukturaMga edad{
T Juan= labing-isang;
Ikaw Pedro= 12.3;
T Maria= 13;
U Joy= 14.6;
};
Ang U at T ay makikita sa loob ng bloke.
Para sa isang prototype na function ng template, nagsisimula ang saklaw mula sa punto ng deklarasyon hanggang sa katapusan ng listahan ng parameter ng pag-andar, tulad ng sa sumusunod na pahayag:
template<typenameT,typenameU> walang bisapagpapaandar(Ikaw hindi, u cha,Const char *p);Gayunpaman, pagdating sa paglalarawan ng klase (kahulugan), ang saklaw ay maaari ding maging ng iba't ibang mga bahagi tulad ng sa sumusunod na code:
# isamagamit namespaceoras;
template<klaseT,klaseU> klaseAngCla
{
pampubliko:
t num;
staticU ch;
walang bisapagpapaandar(U ama,Const char *p)
{
gastos << 'Meron' <<sa isa<< 'librong nagkakahalaga' <<hindi<<p<< ' sa tindahan.' << ' n';
}
static walang bisamasaya(U ch)
{
kung (ch== 'to')
gastos << 'Opisyal na pag-andar ng static member' << ' n';
}
};
intpangunahing()
{
AngCla<int,char>obj;
objsa isa = 12;
objpagpapaandar('$','500');
bumalik ka 0;
}
Pagtatago ng Pangalan
Ang isang halimbawa ng pagtatago ng pangalan ay nangyayari kapag ang pangalan ng parehong uri ng object ay muling idineklara sa isang pugad na bloke. Inilalarawan ito ng sumusunod na programa:
# isamagamit namespaceoras;
walang bisafn()
{
intkung saan= 3;
kung (1==1)
{
intkung saan= 4;
gastos<<kung saan<<' n';
}
gastos<<kung saan<<' n';
}
intpangunahing()
{
fn();
bumalik ka 0;
}
Ang output ay:
4
3
Ito ay dahil ang var sa naka-punong bloke ay nagtago ng var sa panlabas na bloke.
Posibilidad para sa Pag-uulit ng Pagpapahayag sa Parehong Saklaw
Ang punto ng deklarasyon ay kung saan ipinakilala ang pangalan (sa kauna-unahang pagkakataon) sa saklaw nito.
Prototype ng Pag-andar
Ang iba't ibang mga entity, kahit na ng iba't ibang mga uri, ay hindi maaaring ideklara sa parehong saklaw. Gayunpaman, ang isang function na prototype ay maaaring ideklara nang higit sa isang beses sa parehong saklaw. Ang sumusunod na programa na may dalawang mga prototype ng pag-andar at kaukulang kahulugan ng pag-andar ay naglalarawan nito:
gamit namespaceoras;
walang bisafn(intsa isa);
walang bisafn(intsa isa);
walang bisafn(intsa isa)
{
gastos<<sa isa<<' n';
}
intpangunahing()
{
fn(5);
bumalik ka 0;
}
Gumagana ang programa.
Overloaded na mga pag-andar
Ang mga sobrang pag-andar ay mga pagpapaandar na may parehong pangalan ngunit magkakaibang mga lagda ng pag-andar. Bilang isa pang pagbubukod, ang labis na pag-andar na may parehong pangalan ay maaaring tukuyin sa parehong saklaw. Inilalarawan ito ng sumusunod na programa:
gamit namespaceoras;
walang bisafn(intsa isa)
{
gastos<<sa isa<<' n';
}
walang bisafn(lumutanghindi)
{
gastos<<hindi<<' n';
}
intpangunahing()
{
fn(5);
lumutangflt= 8.7;
fn(flt);
bumalik ka 0;
}
Ang output ay:
5
8.7
Ang mga sobrang karga na pag-andar ay tinukoy sa pandaigdigang saklaw.
Saklaw ng Namespace
Nararapat ang Saklaw ng Namespace ng sarili nitong artikulo. Ang nasabing artikulo ay isinulat para sa website na ito, linuxhint.com. I-type lamang ang mga salitang paghahanap sa Saklaw ng Namespace sa search box ng site na ito (pahina) at i-click ang OK, at makukuha mo ang artikulo.
Saklaw sa Iba't ibang Mga Bahagi
Ang klase ay hindi lamang ang pamamaraan kung saan ang saklaw ay maaaring nasa iba't ibang mga bahagi. Ang specifier ng kaibigan, ilang paggamit ng elaborated-type-specifier, at using-directives ay iba pang mga scheme kung saan ang saklaw ay nasa iba't ibang mga lugar - para sa mga detalye, tingnan sa paglaon.
Konklusyon
Ang isang saklaw ay isang nagpapahayag na rehiyon. Ang isang nagpapahayag na rehiyon ay ang pinakamalaking bahagi ng isang teksto ng programa kung saan may bisa ang pangalan ng isang entity. Maaari itong nahahati sa higit sa isang bahagi alinsunod sa ilang mga iskema ng programa, tulad ng mga pugad na bloke. Ang mga bahagi na walang deklarasyon point ay bumubuo ng potensyal na saklaw. Ang potensyal na saklaw ay maaaring mayroon o maaaring walang deklarasyon.