namespaces c
Пълен преглед на пространствата от имена в C ++ с прости примери.
Досега в предишните ни уроци видяхме всичко за променливи, декларации, функции и други подобни обекти, използвани в C ++.
Докато разработват приложения в C ++, могат да възникнат някои особени ситуации, като едни и същи имена на променливи да се използват два пъти или функции, дефинирани с едни и същи прототипи и т.н. .
=> Вижте Перфектното ръководство за обучение на C ++ тук.
Какво ще научите:
софтуер за изтегляне на видеоклипове от всеки уебсайт
- Какво е пространство от имена?
- Определяне на пространство от имена
- Достъп до членове на пространство от имена
- Директивата за използване
- Вложени пространства от имена
- Външни пространства от имена
- Съседни пространства от имена
- Заключение
- Препоръчително четене
Какво е пространство от имена?
Нека видим следния пример:
#include #include int main() { int var; double var; std::cin>>var; }
Изход:
Във функция ‘int main ()’:
8:10: грешка: противоречива декларация „двойна вариация“
7: 7: бележка: предишна декларация като „int var“
В горния пример дефинирахме две променливи с различни типове, но един и същ идентификатор. Така че, когато компилираме този пример, получаваме грешка, както е показано в изходния прозорец. Тези противоречиви декларации възникват поради един и същ идентификатор, който се използва за назоваване на две променливи.
Този тип ситуации пораждат неяснота в приложенията.
C ++ въвежда нещо, наречено „ пространства от имена ”, За да разрешите този проблем. Пространството от имена в C ++ е точно като пакет или регион или библиотека, която се използва за разграничаване на променливата или функциите със същите идентификатори.
Пространството от имена може да съдържа променливи, функции, класове или други обекти и дори друго пространство от имена. Всеки член на пространството от имена може да бъде отнесен с помощта на пространство на имена. Това помага на компилатора да прави разлика между различни програмни обекти, дори ако те имат еднакви имена.
Определяне на пространство от имена
В C ++ можем да дефинираме пространство от имена, използвайки ключовата дума „ пространство от имена ”, Както е показано по-долу:
namespace namespace_name{ namespace_declarations; }
Така че, ако трябва да дефинираме пространство от имена с име 'test_space', можем да го направим както по-долу:
namespace test_space{ int var=10; }
Горната декларация дефинира пространство от имена, наречено „test_space“. Както е показано, той има целочислена променлива var като свой член.
Достъп до членове на пространство от имена
Сега дефинирахме собственото си пространство от имена „test_space“ и как да осъществим достъп до съдържанието на това пространство от имена?
В програмата C ++ можем да получим достъп до членовете на пространството от имена, използвайки синтаксиса:
namespace_name::namespace_member;
По този начин целочислената променлива var, декларирана в пространството на имената „test_space“ по-горе, може да бъде достъпна, както следва:
test_space::var;
Вижте пълния пример по-долу, за да демонстрирате пространства от имена и тяхното използване.
#include #include namespace test_space{ int var = 10; } int main() { double var = 20.53; std::cout<<'local var = '< Изход:
локален вар = 20,53
мобилен телефон шпионски софтуер за android -
test_space :: var = 10
Демонстрирахме всичко за създаването и достъпа до пространство от имена в горния пример за програмиране. Както виждаме, „test_space“ е пространство от имена, което сме дефинирали. В него има дефинирана единична целочислена променлива. След това в основната функция имаме друга двойна променлива var, която се инициализира.
По-късно показваме и двете променливи. Имайте предвид, че докато локалната двойна променлива вътре в main може да бъде отпечатана директно, за да отпечатаме променливата на пространството от имена, ние трябва да я предшестваме с името на пространството от имена.
Това се е погрижило и за проблема със сблъсъците между променливите поради същите имена, които обсъдихме по-рано.
Директивата за използване
В предишната ни тема видяхме, че можем да осъществим достъп до членовете на пространството от имена, използвайки namespace_name :: namespace_member.
Ако не искаме да посочваме име на пространство от имена навсякъде в програмата, можем да използваме „ използвайки Директива за включване на пространството от имена в програмата.
Това се прави по следния начин:
#include #include namespace test_space{ int var = 10; } using namespace std; using namespace test_space; int main() { double var = 20.53; cout<<'local var = '< Изход:
локален вар = 20,53
test_space :: var = 10
В горния пример използвахме две изрази, след като дефинирахме пространството от имена “test_space”.
Това са:
using namespace std; using namespace test_space;
Първият израз използва декларацията за достъп до пространство на имената „std“, което е предварително дефинирано стандартно пространство от имена в библиотеката C ++. Това пространство от имена се използва за достъп до различни функции като cin, cout и др.
Вторият израз се използва за включване на пространството от имена “test_space” в програмата.
В основната функция можем да видим, че функциите като cout и променлива var не е необходимо да се предшестват от име на пространство от имена. Можем директно да се позовем на тях. Но тъй като var има сблъсък на име с локална променлива в основната функция, ние го отнасяме с помощта на оператора за разделителна способност на обхвата (: :), тъй като пространствата от имена също винаги имат глобален обхват.
Вложени пространства от имена
C ++ също позволява да има вложени пространства от имена, т.е.пространство от имена, дефинирано в друго пространство от имена.
Общият синтаксис на вложени пространства от имена е както следва:
namespace ns1{ ns1_code; namespace ns2{ ns2_code; } }
Ако имаме нужда от достъп до ns2_code, тогава можем да го осъществим, както следва:
ns1::ns2::ns2_code;
Нека демонстрираме вложени пространства от имена, като използваме следния пример за код.
#include #include namespace first{ int var = 10; namespace second{ int secVar = 20; } } using namespace std; using namespace first; using namespace first::second; int main() { double var = 20.53; cout<<'local var = '< Изход:
локален вар = 20,53
първо :: var = 10
второ :: var = 20
Използвали сме вложени пространства от имена в горната програма. Моля, обърнете внимание на начина, по който директивата за използване се използва за достъп до пространства от имена. Не е достатъчно да се позове само на най-вътрешното пространство от имена веднъж. Ако се нуждаем от код от най-отдалеченото пространство на имена, тогава трябва да го препращаме отделно.
Можем да използваме друго име за пространства от имена, известни като „псевдоним“. Това е особено полезно при използване на вложени пространства от имена и степента на влагане е висока.
Можем да демонстрираме псевдонима за пространство от имена, като модифицираме горния пример.
#include #include namespace first{ int var = 10; namespace second{ int secVar = 20; } } using namespace std; using namespace first; namespace nested = first::second; int main() { double var = 20.53; cout<<'local var = '< Изход:
java как да се направи опашка
локален вар = 20,53
първо :: var = 10
второ :: var = 20
Обърнете внимание на псевдонима, вложен, който е дефиниран за пространството от имена first :: second. След като псевдонимът е дефиниран, можем да се обърнем към пространството от имена, като използваме псевдоним.
Външни пространства от имена
Понякога, когато имаме твърде много пространства от имена, които да използваме в нашето приложение, може да поискаме да поставим всички пространства от имена в отделен файл. Това може лесно да се направи. Когато пространствата с имена са в отделен файл, ние просто включваме този файл в нашата програма и след това директно използваме пространствата от имена и съдържанието му в нашата програма.
Например, ако имаме файл с име ns.h, който съдържа следното пространство от имена.
//ns.h namespace first{ int var = 25; }
Сега в нашата програма можем да използваме пространството от имена „first“, както следва:
#include #include “ns.h” using namespace std; int main() { cout<Така че след като включим файла, съдържащ пространства от имена в нашата програма, можем да използваме пространствата от имена, сякаш е деклариран глобално в същата програма.
Съседни пространства от имена
C ++ също ни позволява да дефинираме нещо, наречено непрекъснати пространства от имена. Непрекъснати пространства от имена са пространствата от имена, които се дефинират повече от веднъж, като имат едно и също име. В действителност това не са отделни пространства от имена, а разширенията на едно и също пространство от имена.
Съседните пространства от имена са очевидни в примера по-долу.
#include #include . namespace first{ int var = 10; } namespace first{ namespace second{ int secVar = 20; } } using namespace std; using namespace first; namespace nested = first::second; int main() { double var = 20.53; cout<<'local var = '< Изход:
локален вар = 20,53
първо :: var = 10
второ :: var = 20
Забележете в горния пример, че сме дефинирали едно и също пространство от имена два пъти. В първата дефиниция имаме променлива с име var. Докато във втората декларация имаме определено друго пространство от имена.
В основната функция имаме достъп до членовете на външното, както и на вътрешното пространство от имена и имаме предвид, че членовете са лесно достъпни.
Това е примерът за съседни пространства от имена, което понякога е известно и като „прекъснати пространства от имена“. Дефинициите им изглеждат отделни, но в действителност те са непрекъснати пространства от имена.
Заключение
С това стигнахме до края на този урок за пространства от имена в C ++. Пространства от имена по един начин, който ни позволява да отделим нашия код в различни пространства или региони, така че да имаме яснота при четенето му, както и при използването на неговите членове.
В следващите ни уроци ще научим повече за различните основни теми на C ++ като обработка на изключения, въвеждане / извеждане на файлове и др.
=> Проверете тук, за да видите A-Z на C ++ уроци за обучение тук.
Препоръчително четене
- Най-добрият БЕЗПЛАТЕН урок за C #: Най-доброто ръководство за C # за начинаещи
- Тестване на натоварване с уроци за HP LoadRunner
- Библиотечни функции в C ++
- 70+ НАЙ-ДОБРИ уроци за C ++, за да научите БЕЗПЛАТНО програмиране на C ++
- Обектно-ориентирано програмиране в C ++
- Списъци за инициализация в C ++
- Итератори в STL
- Капсулиране в C ++