Ginagamit ang Namespace sa C ++ upang ayusin ang code sa mga lohikal na grupo at upang maiwasan ang mga banggaan sa pangalan na maaaring mangyari lalo na kapag nagsasama ang iyong codebase ng maraming mga aklatan. Sa artikulong ito ang mga sumusunod na Turo ay sakop:
- Ang pangangailangan para sa Namespace
- Pagtukoy sa isang Namespace sa C ++
- Mga puntong dapat tandaan habang tinutukoy ang isang Namespace
- Paggamit ng Namespace sa C ++
- Hindi matalinong mga Namespace
- Pugad ng mga Namespace
Ang pangangailangan para sa Namespace
Isaalang-alang ang isang sitwasyon, nagsusulat kami ng ilang code na may pagpapaandar na tinatawag na abc () at may isa pang paunang natukoy na library na magagamit na nagkakaroon din ng parehong function na abc (). Ngayon sa oras ng pagtitipon, ang tagatala ay walang bakas kung aling bersyon ng abc () ang pagpapaandar na tinutukoy namin sa loob ng aming code.
kung paano simulan ang isang bagay sa sawa
Upang mapagtagumpayan ang kahirapan ng namespace na ito ay dinisenyo at ginagamit bilang karagdagang impormasyon upang maiiba ang mga katulad na pag-andar, variable, klase, atbp na may parehong pangalan na magagamit sa iba't ibang mga aklatan. Gamit ang namespace, maaari naming tukuyin ang konteksto kung saan tinukoy ang mga pangalan. Sa kakanyahan, ang isang namespace ay tumutukoy sa isang saklaw.
Ang lahat ng mga karaniwang uri at pag-andar ng library ng C ++ ay ipinahayag sa std namespace o namespaces na nakapugad sa loob ng std kaya't malawak itong ginagamit sa karamihan ng mga programa.
Pagtukoy sa isang Namespace
Upang tukuyin ang namespace nagsisimula kami sa namespace ng keyword na sinusundan ng pangalan ng namespace tulad ng sumusunod:
namespace namespace_name {int a, b // code declarations kung saan ang // a at b ay idineklara sa // namespace_name's sakop}Mga puntong dapat tandaan habang tinutukoy ang isang Namespace
- Ang mga pagdeklara ng namespace ay lilitaw lamang sa pandaigdigang saklaw.
- Ang mga pagdeklara ng namespace ay walang mga detalye sa pag-access.
- Ang mga pagdeklara ng namespace ay maaaring makapugad sa loob ng isa pang namespace.
- Hindi na kailangang magbigay ng semicolon pagkatapos ng pagsasara ng brace ng kahulugan ng namespace.
- Ang kahulugan ng namespace ay maaaring hatiin sa maraming mga yunit.
# isama ang paggamit ng namespace std namespace first_unction {void func () {cout<< 'Inside first_function' << endl } } namespace second_function { void func() { cout << 'Inside second_function' << endl } } int main () { // Calls function from first name space. first_function::func() // Calls function from second name space. second_function::func() return 0 }Output:
Sa halimbawa sa itaas upang tukuyin ang func () na pag-andar ng dalawang magkakaibang oras, ginagamit namin ang konsepto ng namespace. Tinutukoy namin ang unang pag-andar sa ilalim ng namespace first_unction atpangalawang pag-andar sa ilalim ng namespace pangalawang_function. Upang tawagan ang mga pagpapaandar na ito ginagamit namin ang operator ng resolusyon ng saklaw sa sumusunod na pamamaraan - first_unction :: func () at second_unction :: func ().
pag-uri-uriin ang listahan c ++
Paggamit ng Namespace sa C ++
Mayroong tatlong paraan upang magamit ang isang namespace sa programa,
- Ang paggamit ng direktiba
- Ang paggamit-deklarasyon
- Operator ng Resolution ng Saklaw (: :)
Ang paggamit ng direktiba
Maaari naming maiwasan ang paghahanda ng mga namespace kasama ang gamit direktiba ng namespace. gamit Pinapayagan kami ng keyword na mag-import ng isang buong namespace sa iyong programa na may isang pandaigdigang saklaw. Maaari itong magamit upang mag-import ng isang namespace sa isa pang namespace o anumang programa alinsunod sa aming kinakailangan.
Isaalang-alang ang isang header file na Namespace_first.h:
namespace Una {int a class First_class {int i}}Kasama ang nasa itaas na namespace header file sa Namespace_second.h file: isama ang “Namespace_first.h”
namespace Pangalawa {using namespace First First_class obj int y}Ina-import namin ang namespace_First sa namespace_Second, samakatuwid ang klase ng First_class ay magagamit na ngayon sa namespace_Second. Kaya't maaari nating isulat ang sumusunod na programa sa isang magkahiwalay na file, sabihin nating new_file.cpp.
# isama ang 'Namespace_second.h' walang bisa na pagsubok () {gamit ang namespace Pangalawa // lumilikha ng bagay ng klase First_class First_class obj2}Dahil dito , ang paggamit ng direktiba ay ginagawang mas madali ang paggamit ng isang namespace sa C ++, saan mo man gusto.
Ang paggamit-deklarasyon
Sa paggamit-deklarasyon, nag-i-import kami ng isang tukoy na pangalan nang paisa-isang magagamit lamang sa loob ng kasalukuyang saklaw at tinawag ito sa tulong ng resolusyon ng saklaw. TANDAAN: Ang pangalang na-import gamit ang paggamit ng-deklarasyon ay maaaring mapawalang bisa ang pang-import na pangalan gamit ang paggamit ng direktiba. Makikita natin ito sa halimbawa sa ibaba.
Isaalang-alang natin ang isang header file na New_File.h:
mga tutorial sa visual studio para sa mga nagsisimula
namespace Una {void A () {cout<< 'A of First namespacen' } } namespace Second { void A() { cout << 'A of Second namespacen' } }Ngayon ay gumawa tayo ng isang bagong file ng programa na may pangalang New_file_2.cpp na may code sa ibaba:
# isama ang 'New_file.h' walang bisa B () {gamit ang namespace Una // gamit ang direktiba gamit ang Pangalawa: A // gamit ang deklarasyon Una :: A () // klase A () ng Unang namespace A () // tawag A () ng Pangalawang namespace}Operator ng resolusyon sa saklaw (: :)
Maaari naming malinaw na tukuyin ang anumang pangalan na idineklara sa isang namespace gamit ang pangalan ng namespace at ang resolusyon ng saklaw na ' :: ' operator na may identifier.
namespace New_space {class X {static int i public: void func ()} // class name declaration class Y} // Initializing static class variable int New_space :: X :: i = 23 class New_space :: Y {int a public: int getdata () {cout<< a } // Constructor declaration Y() } // Constructor definition explicitly New_space::Y::Y() { a=0 }Hindi mag-atubiling Namespace sa C ++
Tulad ng alam natin ang isang namespace sa C ++ ay maaaring tukuyin sa maraming bahagi sa gayon ito ay binubuo ng kabuuan ng mga hiwalay na tinukoy nitong bahagi. Kaya, kung ang isang bahagi ng namespace ay nangangailangan ng isang pangalan na tinukoy sa ibang file, ang pangalang iyon ay dapat pa ring ideklara sa saklaw nito. Ang pagsusulat ng sumusunod na namespace sa sumusunod na paraan ay tumutukoy sa isang bagong namespace o nagdaragdag ng mga bagong elemento sa isang mayroon nang:
namespace namespace_name {// code body}Pugad ng Namespace sa C ++
Ang mga namespace ay madaling mapupugutan at maaari naming tukuyin ang isang namespace sa loob ng isa pang namespace tulad ng sumusunod:
namespace namespace_name1 {// code body ng namespace_name1 namespace namespace_name2 {// body code pugad namamespace_name2}}Sa pamamagitan nito, natapos namin ang Namespace sa artikulong C ++. Inaasahan kong nakakuha ka ng ideya kung ano ang eksaktong namespace sa C ++ at kung ano ang iba't ibang mga paraan ng pagtukoy nito. Kung nais mong matuto nang higit pa, tingnan ang ni Edureka, isang pinagkakatiwalaang kumpanya sa pag-aaral sa online. Ang kurso sa pagsasanay at sertipikasyon ng Java J2EE at SOA ng Edureka ay idinisenyo upang sanayin ka para sa parehong core at advanced na mga konsepto ng Java kasama ang iba't ibang mga balangkas ng Java tulad ng Hibernate & Spring.
May tanong ba sa amin? Mangyaring banggitin ito sa seksyon ng mga komento ng blog na ito at babalikan ka namin sa lalong madaling panahon.