Isaalang-alang ang sumusunod na dalawang mga pahayag ng skalar sa isang pandaigdigang saklaw, sa sumusunod na programa:
# isama
gamit ang namespace std;
intvarId= 5;
lumutangvarId= 2.3;
intpangunahing()
{
bumalik ka 0;
}
Ang isang pagtatangka na isama ang program na ito ay humantong sa isang error sa pagtitipon. Mayroong dalawang variable na may parehong pangalan, varId . Kahit na ang mga ito ay dalawang magkakaibang mga variable ng dalawang magkakaibang uri, int at lumutang , tinatanggihan ng tagatala ang dalawang deklarasyon sapagkat magkapareho ang kanilang pangalan. Nalulutas ng sumusunod na programa ang problemang ito sa pamamagitan ng pagdedeklara ng mga variable na may parehong pangalan sa dalawang magkakaibang pangkalahatang saklaw:
# isama
gamit ang namespace std;
namespace NA
{
intvarId= 5;
}
namespace NB
{
lumutangvarId= 2.3;
}
intpangunahing()
{
gastos<<NA::varId << ' n';
gastos<<NB::varId << ' n';
bumalik ka 0;
}
Ang output ay ang mga sumusunod:
5
2.3
Mayroong dalawang mga namespace sa program sa itaas: NA , na mayroong kahulugan ng isang integer, at NB , na mayroong kahulugan ng isang float ngunit may parehong pangalan bilang integer para sa NA. Panghuli, kapag naipatakbo ang programa, ginamit ang parehong pangalan para sa dalawang magkakaibang mga variable. Tandaan na upang mai-access ang parehong pangalan ng dalawang magkakaibang mga variable, ang partikular na pangalan para sa namespace ay dapat gamitin, na sinusundan ng karaniwang identifier. Ang pangalan ng namespace at ang karaniwang identifier ay pinaghihiwalay ng operator ng resolusyon ng saklaw, :: . Ang pangalan ng mga namespaces ay makakaiba ang mga object.
Saklaw ng artikulong ito ang pangunahing konsepto ng isang namespace at ang paggamit nito sa wikang C + + ng programa. Upang sundin ang artikulong ito, dapat kang magkaroon ng pangunahing kaalaman sa wikang C ++. Dapat ay mayroon ka ring kaalaman sa saklaw ng C ++, kahit na ito ay maikling ipinaliwanag sa artikulong ito. Upang matuto nang higit pa tungkol sa saklaw ng C ++, hanapin ang parirala, Saklaw sa C ++ (nang walang mga quote) sa kahon ng paghahanap ng anumang web page ng linuxhint.com at pindutin ang Enter. Hahantong ka sa artikulong isinulat ng may-akda na ito.
Nilalaman ng Artikulo
- Ano ang isang Namespace?
- Ang gamit na Direktiba
- Pugad ng mga Namespace
- Karaniwang Namespace
- Konklusyon
Ano ang isang Namespace?
Ang isang nagpapahayag na rehiyon ay ang pinakamalaking bahagi ng isang programa kung saan ang pangalan ng isang entity (variable) ay wasto. Ang rehiyon na ito ay tinatawag na isang saklaw. Ang isang namespace sa C ++ ay isang pangkalahatang saklaw na ang pangunahing layunin ay upang malutas ang mga salungatan sa pangalan. Ang isang namespace ay may pangunahing mga deklarasyon at / o kahulugan ng mga nilalang.
Global Namespace at Ang Suliranin Nito
Ang pandaigdigang namespace ay ang pandaigdigang saklaw. Isaalang-alang ang sumusunod na maikling programa:
# isamagamit ang namespace std;
intident= 55;
lumutangident= 12.17;
intpangunahing()
{
bumalik ka 0;
}
Sa program sa itaas, mayroong dalawang variable, parehong tinawag ident . Ang mga variable na ito ay nasa pandaigdigang saklaw; iyon ay, nasa pandaigdigang namespace sila. Ang isang pagtatangka na isama ang program na ito ay mabibigo sa isang mensahe ng error. Ang global na saklaw ay hindi tumatanggap ng higit sa isang variable na may parehong pangalan, kaya't kailangan ng isang pasadyang namespace.
Pasadyang Namespace
Ang isang namespace ay wala lamang isang pangalan. Sa halip, ang isang namespace ay may isang hanay ng mga pangalan upang maiwasan ang salungatan sa iba pang mga hanay ng mga pangalan. Upang maiwasang mas mababa ang salungatan sa code, mauna sa bawat pangalan na may pangalan ng namespace at :: . Inilalarawan ito ng sumusunod na programa gamit ang dalawang pasadyang namespaces:
# isamagamit ang namespace std;
namespace NA
{
intvarInt= 6;
lumutangflt;
}
namespace NB
{
intvarInt= 7;
lumutangflt;
}
intpangunahing()
{
gastos<<NA::varInt << ' n';
gastos<<NB::varInt << ' n';
NA::flt = 2.5;
NB::flt = 4.8;
gastos<<NA::flt << ' n';
gastos<<NB::flt << ' n';
bumalik ka 0;
}
Ang output ay:
67
2.5
4.8
Tandaan na ang mga pangalan NA :: flt at NB :: flt sa huli ay natukoy sa pangunahing () pagpapaandar Hindi pinapayagan ng C ++ ang gayong kahulugan sa pandaigdigang saklaw.
Tandaan na ang pasadyang namespace ay isang pugad na namespace para sa pandaigdigang namespace.
Ang gamit na Direktiba
Upang maiwasan ang pag-type ng namepace :: pangalan sa lahat ng oras sa halip na pangalan lamang pagkatapos na ideklara ang namespace, maaari mong gamitin ang gamit direktiba Ang syntax upang magamit ang gamit ang direktiba ay ang mga sumusunod:
gamit ang namespace Namespace_name;Ang gamit Ang direktiba ay hindi isang direktang preprocessor, kaya't nagtatapos ito sa isang kalahating titik (;).
Ang sumusunod na programa ay naglalarawan ng paggamit ng gamit direktiba at higit pa:
# isamagamit ang namespace std;
namespace NB
{
intvarInt= 7;
intpagpapaandar()
{
bumalik kavarInt;
}
}
intfn()
{
gamit ang namespace NB;
intmyVar2=pagpapaandar();
// iba pang mga bagay at pag-andar mula sa NB ay sumusunod.
bumalik kamyVar2;
}
intmyVar3=NB::pagpapaandar();
intpangunahing()
{
gastos<<fn() << ' <<myVar3<< ' n';
bumalik ka 0;
}
Ang output ng program na ito ay 7 7 . Ang termino gamit ang namespace NB; ay inilagay sa simula ng fn () kahulugan Ang func () mula sa namespace ng NB ay tinatawag lamang sa ibaba nito, nang hindi na nauuna sa NB :: .
Ang isang variable na idineklara sa pandaigdigang saklaw (pandaigdigang namespace) ay nakikita mula sa punto ng deklarasyon hanggang sa dulo ng file. Makikita rin ito sa mga pugad na mga namespace (naka-punong saklaw), tulad ng pugad fn () saklaw ng pag-andar sa itaas. Ang gamit sumasama ang direktiba sa namespace nito mula sa posisyon kung saan inilalagay ito sa dulo ng saklaw kung saan ito inilagay.
Ang pangalan func () mula sa namespace ng NB ay hindi makikita sa ibaba ng fn () kahulugan dahil gamit ang namespace NB; ay inilagay sa loob ng saklaw ng pag-andar (block). Sa ilalim ng kondisyong ito, upang magamit func () sa labas ng NB namespace block (saklaw), dapat itong maunahan ng NB :: , tulad ng sa sumusunod na pahayag:
intmyVar3=NB::pagpapaandar();Ang gamit ang direktiba ay sumali sa namespace nito sa panlabas na namespace ng pugad mula sa posisyon kung saan inilalagay ito sa dulo ng panlabas na namespace ng pugad. Sa sumusunod na programa, ang namespace NA ay sumali sa pandaigdigang namespace. Ang parehong mga namespace pagkatapos ay umaabot sa fn () pag-andar ng namespace kahulugan, kung saan sila ay sumali sa namespace ng NB. Nagtatapos ang namespace ng NB sa dulo ng fn () kahulugan ng pagpapaandar, at ang dalawang nakaraang mga namespace ay nagpapatuloy hanggang sa katapusan ng file (basahin ang code).
# isamagamit ang namespace std;
namespace NA
{
intvarInt= 6;
intpagpapaandar()
{
bumalik kavarInt;
}
}
namespace NB
{
intvarInt= 7;
intpagpapaandar()
{
bumalik kavarInt;
}
}
gamit ang namespace NA;
intmyVar0=varInt;
// iba pang mga bagay at pag-andar mula sa :: at sinusundan ang NB.
intfn()
{
intmyVar1=varInt;
gamit ang namespace NB;
intmyVar2=NB::pagpapaandar();
// iba pang mga bagay at pag-andar mula sa NB na sumusunod, hanggang sa katapusan ng saklaw na ito.
bumalik kamyVar1+myVar2;
}
// Mga bagay at pag-andar lamang mula sa :: at NB ang sumusunod.
intmyVar3=NB::pagpapaandar();
intpangunahing()
{
gastos<<myVar0<< ' <<fn() << ' <<myVar3<< ' n';
bumalik ka 0;
}
Ang output ay 6, 13, 7 .
Tandaan: Ang pandaigdigang namespace ay ipinahiwatig kasama ng :: , nangangahulugang walang anuman bago ang sumusunod na operator ng resolusyon ng saklaw.
Sa ibaba ng pahayag, ang gamit ang namespace NA; ang mga variable mula sa pandaigdigan at NA namespaces ay maaaring magamit nang walang pahiwatig ng kanilang pinagmulan ng namespace. Ang susunod na pahayag ay gumagamit ng varInt ng namespace NA. Ang pandaigdigang at NA pinagsamang namespace na rehiyon ay umaabot sa fn () namespace ng pag-andar. Kaya ang varInt ng unang pahayag sa fn () saklaw ng pag-andar, ay ng namespace NA.
Dahil ang rehiyon para sa pandaigdigan at NA mga namespace ay umaabot sa buong fn () saklaw, pagkatapos ng int myVar2 = NB :: func (); , ang anumang pangalan mula sa namespace ng NB ay maaari lamang magamit sa fn () saklaw nang hindi nauuna ito sa NB :: , kung hindi ito naganap sa NA at pandaigdigang mga namespace (bloke). Kung hindi man, dapat itong mauna sa NB :: . Ang rehiyon ng pinagsamang namespaces para sa NA at pandaigdigan ay nagpapatuloy sa ibaba ng fn () kahulugan at sa pangunahing () gumana hanggang sa katapusan ng file.
Ang pagpapalawak ng namespace ng NB ay nagsisimula sa int myVar2 = NB :: func (); nasa fn () harangan at magtatapos sa dulo ng fn () kahulugan ng bloke.
Tandaan: Ang mga namespaces na ang mga rehiyon ay sumali ay hindi dapat magkaroon ng parehong variable pangalan sa kanilang iba't ibang mga bloke ng namespace, dahil magdulot pa rin ito ng tunggalian.
Mga Rehiyon ng namespace
Ang namespace ay isang saklaw. Bukod sa pandaigdigang namespace (pandaigdigang saklaw), ang anumang namespace ay dapat ideklara sa isang bloke. Ang bloke na iyon ay ang unang bahagi ng maaaring ibinahagi na mga rehiyon ng namespace. Gamit ang paggamit ng direktiba, ang namespace ay maaaring mapalawak bilang mga rehiyon sa iba pang mga saklaw.
Ang mga nilalang na idineklara sa isang namespace body ay sinasabing miyembro ng namespace, at ang mga pangalan na ipinakilala ng mga deklarasyong ito sa nagpapahayag na rehiyon ng namespace ay sinasabing mga pangalan ng miyembro ng namespace.
Pugad ng mga Namespace
Ipinapakita ng sumusunod na programa ang mga pugad na mga namespace:
# isamagamit ang namespace std;
namespace A
{
intako= 1;
namespace B
{
intako= 2;
namespace C
{
intako= 3;
}
}
}
intpangunahing()
{
gastos<<SA::ako << ' <<SA::B::ako << ' <<SA::B::C::ako << ' n';
bumalik ka 0;
}
Ang output ay:
1 2 3Pansinin na na-access ang tatlong mga halaga gamit ang operator ng resolusyon ng saklaw.
Karaniwang Namespace
Ang C ++ ay may isang library na tinatawag na standard library. Ang mga pangalan ng mga bagay, pag-andar, at iba pang mga nilalang sa library na ito ay mula sa isang namespace na tinatawag na karaniwang namespace, nakasulat bilang oras . Naglalaman ang karaniwang silid-aklatan ng mga sub-aklatan, at ang isa sa mga sub-aklatan na ito ay iostream . Ang iostream naglalaman ang aklatan ng object gastos , na ginagamit upang magpadala ng mga resulta sa console (terminal).
Ang pangalan gastos dapat nasa oras namespace. Para magamit iostream kasama ang mga oras namespace, ang programa ay dapat na tulad ng sumusunod:
# isamagamit ang namespace std;
Tandaan ang paggamit ng gamit direktiba at oras . Ang termino # isama ay isang preprocessor na direktiba at hindi nagtatapos sa isang semicolon. Kabilang dito ang iostream file sa posisyon ng direktiba nito.
Konklusyon
Ang namespace ay isang saklaw. Ang paglalarawan ng namespace (kahulugan) ay naglalaman ng pangunahing mga deklarasyon at / o mga kahulugan ng C ++ na mga bagay, pag-andar, at iba pang mga nilalang. Sa labas ng kahulugan ng namespace, maaaring ma-access ang pangalan gamit ang syntax, namespaceName :: pangalan . Bukod sa pandaigdigang namespace (pandaigdigang saklaw), ang anumang namespace ay dapat ideklara sa isang bloke. Ang bloke na iyon ay ang unang bahagi ng maaaring ibinahagi na mga rehiyon ng namespace. Kasama ang gamit direktiba, ang namespace ay maaaring mapalawak bilang mga rehiyon sa iba pang mga saklaw. Ang mga namespaces na ang mga rehiyon ay sumali ay hindi dapat magkaroon ng magkakaibang variable name sa kanilang iba't ibang mga blocks ng namespace, dahil magiging sanhi pa rin ito ng salungatan sa pangalan.
Chrys