logo

TechCodeview

Przestrzeń nazw w C++ | Zestaw 1 (Wprowadzenie)

  • Przestrzeń nazw zapewnia przestrzeń, w której możemy zdefiniować lub zadeklarować identyfikator, czyli zmienną, metodę, klasy.
  • Korzystając z przestrzeni nazw, można zdefiniować przestrzeń lub kontekst, w którym definiowane są identyfikatory tj. zmienna, metoda, klasy. Zasadniczo przestrzeń nazw definiuje zakres.

Zaleta przestrzeni nazw, aby uniknąć kolizji nazw.

  • Przykład: możesz pisać kod mający funkcję o nazwie xyz() i dostępna jest inna biblioteka, która również ma tę samą funkcję xyz(). Teraz kompilator nie ma możliwości sprawdzenia, do której wersji funkcji xyz() odwołujesz się w swoim kodzie.
  • Przestrzeń nazw ma na celu przezwyciężenie tej trudności i służy jako dodatkowa informacja w celu odróżnienia podobnych funkcji, klas, zmiennych itp. o tej samej nazwie, dostępnych w różnych bibliotekach.
  • Najlepszym przykładem zakresu przestrzeni nazw jest standardowa biblioteka C++ (std), w której zadeklarowane są wszystkie klasy, metody i szablony. Dlatego pisząc program w C++, zwykle dołączamy dyrektywę używając przestrzeni nazw std;

Definiowanie przestrzeni nazw:

  • Definicja przestrzeni nazw zaczyna się od słowa kluczowego namespace, po którym następuje nazwa przestrzeni nazw w następujący sposób:
namespace namespace_name { // code declarations i.e. variable (int a;) method (void add();) classes ( class student{};) }>
  • Należy zauważyć, że po nawiasie zamykającym nie ma średnika (;).
  • Aby wywołać wersję funkcji lub zmiennej obsługującą przestrzeń nazw, dodaj nazwę przestrzeni nazw na początku w następujący sposób:
  • nazwa_przestrzeni nazw: :kod; // kod może być zmienną, funkcją lub klasą.

Dyrektywa using:

  • Można także uniknąć dodawania przestrzeni nazw za pomocą dyrektywy using namespace. Ta dyrektywa informuje kompilator, że kolejny kod wykorzystuje nazwy z określonej przestrzeni nazw.
  • Przestrzeń nazw jest zatem implikowana dla następującego kodu:

C++








#include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> }> // second name space> namespace> second_space> {> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> }> using> namespace> first_space;> int> main ()> {> >// This calls function from first name space.> >func();> >return> 0;> }> 

>



>

Wyjście 

Inside first_space>
  • Nazwy wprowadzone w dyrektywie using podlegają normalnym zasadom zakresu. Nazwa widoczna jest od miejsca dyrektywy using aż do końca zakresu, w którym dyrektywa się znajduje. Jednostki o tej samej nazwie zdefiniowane w zakresie zewnętrznym są ukryte.

Zagnieżdżone przestrzenie nazw:

  • Przestrzenie nazw można zagnieżdżać, umożliwiając zdefiniowanie jednej przestrzeni nazw w innej przestrzeni nazw w następujący sposób:
SYNTAX: namespace namespace_name1 { // code declarations namespace namespace_name2 { // code declarations } }>

Dostęp do członków zagnieżdżonej przestrzeni nazw można uzyskać za pomocą operatorów rozpoznawania w następujący sposób:
// aby uzyskać dostęp do członków przestrzeni nazw2
używając przestrzeni nazw nazwa_przestrzeni_nazw1::nazwa_przestrzeni_nazw2;
// aby uzyskać dostęp do członków przestrzeni nazw_nazwa1
używając przestrzeni nazw nazwa_przestrzeni_nazw1;

W powyższych instrukcjach, jeśli używasz nazwy przestrzeni nazw1, elementy przestrzeni nazw2 zostaną udostępnione w następującym zakresie:

C++




#include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> >// second name space> >namespace> second_space> >{> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> >}> }> using> namespace> first_space::second_space;> int> main ()> {> >// This calls function from second name space.> >func();> > >return> 0;> }> 

>

>

Wyjście 

Inside second_space>

Zobaczmy, jak przestrzeń nazw obejmuje jednostki, w tym zmienne i funkcje:

C++




#include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> }> // second name space> namespace> second_space> {> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> }> int> main ()> {> >// Calls function from first name space.> >first_space :: func();> >// Calls function from second name space.> >second_space :: func();> >return> 0;> }> 

>

>

Wyjście 

Inside first_space Inside second_space>

Rozważmy następujący program w C++:

CPP




// A program to demonstrate need of namespace> int> main()> {> >int> value;> >value = 0;> >double> value;>// Error here> >value = 0.0;> }> 

>

>

Wyjście :

Compiler Error: 'value' has a previous declaration as 'int value'>

W każdym zakresie nazwa może reprezentować tylko jedną jednostkę. Zatem w tym samym zakresie nie mogą znajdować się dwie zmienne o tej samej nazwie. Korzystając z przestrzeni nazw, możemy utworzyć dwie zmienne lub funkcje składowe o tej samej nazwie.

CPP




// Here we can see that more than one variables> // are being used without reporting any error.> // That is because they are declared in the> // different namespaces and scopes.> #include> using> namespace> std;> // Variable created inside namespace> namespace> first {> int> val = 500;> }> // Global variable> int> val = 100;> int> main()> {> >// Local variable> >int> val = 200;> >// These variables can be accessed from> >// outside the namespace using the scope> >// operator ::> >cout << first::val <<>' '>;> >return> 0;> }> 

>

>

Wyjście 

500>

Definicja i utworzenie: Przestrzenie nazw pozwalają nam grupować nazwane jednostki, które w przeciwnym razie miałyby Zakres globalny w węższych zakresach, dając je zakres przestrzeni nazw . Umożliwia to organizowanie elementów programów w różne zakresy logiczne, oznaczone nazwami. Przestrzenie nazw zapewniają przestrzeń, w której możemy definiować lub deklarować identyfikatory, tj. nazwy zmiennych, metod, klas itp.

  • Przestrzeń nazw to funkcja dodana w C++, która nie występuje w C.
  • Przestrzeń nazw to deklaratywny region, który zapewnia zakres znajdującym się w niej identyfikatorom (nazwom funkcji, zmiennych lub innym typom danych zdefiniowanym przez użytkownika).
  • Dozwolonych jest wiele bloków przestrzeni nazw o tej samej nazwie. Wszystkie deklaracje w tych blokach są zadeklarowane w nazwanym zakresie.

Definicja przestrzeni nazw zaczyna się od słowa kluczowego przestrzeń nazw po której następuje nazwa przestrzeni nazw w następujący sposób:

namespace namespace_name { int x, y; // code declarations where // x and y are declared in // namespace_name's scope }>
  • Deklaracje przestrzeni nazw pojawiają się tylko w zasięgu globalnym.
  • Deklaracje przestrzeni nazw można zagnieżdżać w innej przestrzeni nazw.
  • Deklaracje przestrzeni nazw nie mają specyfikatorów dostępu (publicznego lub prywatnego).
  • Nie ma potrzeby stawiania średnika po nawiasie zamykającym definicji przestrzeni nazw.
  • Definicję przestrzeni nazw możemy podzielić na kilka jednostek.

Definiowanie przestrzeni nazw:

Definicja przestrzeni nazw zaczyna się od słowa kluczowego namespace, po którym następuje nazwa przestrzeni nazw w następujący sposób:

C++




namespace> namespace_name{> >// code declarations i.e. variable (int a;)> >method (>void> add();)> >classes (>class> student{};)> }> 

>

>

Należy zauważyć, że po nawiasie zamykającym nie ma średnika (;).
Aby wywołać wersję funkcji lub zmiennej obsługującą przestrzeń nazw, dodaj nazwę przestrzeni nazw na początku w następujący sposób:

nazwa_przestrzeni nazw: :kod; // kod może być zmienną, funkcją lub klasą.

C++




// Let us see how namespace scope the entities including variable and functions:> #include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> }> // second name space> namespace> second_space> {> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> }> int> main ()> {> >// Calls function from first name space.> >first_space::func();> >// Calls function from second name space.> >second_space::func();> >return> 0;> }> // If we compile and run above code, this would produce the following result:> // Inside first_space> // Inside second_space> 

>

>

Wyjście 

Inside first_space Inside second_space>

Dyrektywa using:

Możesz uniknąć dodawania przestrzeni nazw za pomocą dyrektywy using namespace. Ta dyrektywa informuje kompilator, że kolejny kod wykorzystuje nazwy z określonej przestrzeni nazw. Przestrzeń nazw jest zatem implikowana dla następującego kodu:

C++




#include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> }> // second name space> namespace> second_space> {> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> }> using> namespace> first_space;> int> main ()> {> >// This calls function from first name space.> >func();> >return> 0;> }> // If we compile and run above code, this would produce the following result:> // Inside first_space> 

>

>

tabela opisów w mysql
Wyjście 

Inside first_space>

Zamiast uzyskiwać dostęp do całej przestrzeni nazw, inna opcja (znana jako za pomocą deklaracja) polega na uzyskaniu dostępu do określonego elementu w przestrzeni nazw. Na przykład, jeśli jedyną częścią przestrzeni nazw std, której zamierzasz używać, jest cout, możesz odwołać się do niej w następujący sposób:
używając std::cout;
Kolejny kod może odwoływać się do cout bez poprzedzania przestrzeni nazw, ale inne elementy w przestrzeni nazw std nadal będą musiały być jawne w następujący sposób:

C++




#include> using> std::cout;> int> main ()> {> >cout <<>'std::endl is used with std!'> << std::endl;> >return> 0;> }> 

>

>

Wyjście 

std::endl is used with std!>

Nazwy wprowadzone w dyrektywie using podlegają normalnym zasadom zakresu, tj. są widoczne od momentu wystąpienia dyrektywy using do końca zakresu, w którym dyrektywa się znajduje. Jednostki o tej samej nazwie zdefiniowane w zakresie zewnętrznym są ukryte.

C++




// Creating namespaces> #include> using> namespace> std;> namespace> ns1 {> int> value() {>return> 5; }> }>// namespace ns1> namespace> ns2 {> const> double> x = 100;> double> value() {>return> 2 * x; }> }>// namespace ns2> int> main()> {> >// Access value function within ns1> >cout << ns1::value() <<>' '>;> >// Access value function within ns2> >cout << ns2::value() <<>' '>;> >// Access variable x directly> >cout << ns2::x <<>' '>;> >return> 0;> }> 

>

>

Wyjście: 

5 200 100>

Klasy i przestrzeń nazw: Poniżej przedstawiono prosty sposób tworzenia klas w przestrzeni nazw:

C++




// A C++ program to demonstrate use of class> // in a namespace> #include> using> namespace> std;> namespace> ns> {> >// A Class in a namespace> >class> geek> >{> >public>:> >void> display()> >{> >cout<<>'ns::geek::display()'>< } }; } int main() { // Creating Object of geek Class ns::geek obj; obj.display(); return 0; }> 

>

>

Wyjście 

ns::geek::display()>

Klasę można również zadeklarować w przestrzeni nazw i zdefiniować poza nią używając następującej składni:

CPP




// A C++ program to demonstrate use of class> // in a namespace> #include> using> namespace> std;> namespace> ns {> // Only declaring class here> class> geek;> }>// namespace ns> // Defining class outside> class> ns::geek {> public>:> >void> display() { cout <<>'ns::geek::display() '>; }> };> int> main()> {> >// Creating Object of geek Class> >ns::geek obj;> >obj.display();> >return> 0;> }> 

>

>

Wyjście 

ns::geek::display()>

Metody możemy definiować także poza przestrzenią nazw . Poniżej znajduje się przykładowy kod:

C++




// A C++ code to demonstrate that we can define> // methods outside namespace.> #include> using> namespace> std;> // Creating a namespace> namespace> ns {> void> display();> class> geek {> public>:> >void> display();> };> }>// namespace ns> // Defining methods of namespace> void> ns::geek::display()> {> >cout <<>'ns::geek::display() '>;> }> void> ns::display() { cout <<>'ns::display() '>; }> // Driver code> int> main()> {> >ns::geek obj;> >ns::display();> >obj.display();> >return> 0;> }> 

>

>

Wyjście: 

ns::display() ns::geek::display():>

Zagnieżdżone przestrzenie nazw:

Przestrzenie nazw można zagnieżdżać, tzn. można zdefiniować jedną przestrzeń nazw w innej przestrzeni nazw w następujący sposób:

C++




namespace> namespace_name1 {> >// code declarations> >namespace> namespace_name2 {> >// code declarations> >}> }> 

>

>

co to jest plik desktop.ini

Dostęp do elementów zagnieżdżonej przestrzeni nazw można uzyskać za pomocą operatora rozpoznawania (::) w następujący sposób:

C++




// to access members of namespace_name2> using> namespace> namespace_name1::namespace_name2;> // to access members of namespace:name1> using> namespace> namespace_name1;> 

>

>

W powyższych instrukcjach, jeśli używasz nazwy przestrzeni nazw1, elementy przestrzeni nazw2 zostaną udostępnione w następującym zakresie:

C++




#include> using> namespace> std;> // first name space> namespace> first_space> {> >void> func()> >{> >cout <<>'Inside first_space'> << endl;> >}> >// second name space> >namespace> second_space> >{> >void> func()> >{> >cout <<>'Inside second_space'> << endl;> >}> >}> }> using> namespace> first_space::second_space;> int> main ()> {> > >// This calls function from second name space.> >func();> > >return> 0;> }> // If we compile and run above code, this would produce the following result:> // Inside second_space> 

>

>

Wyjście 

Inside second_space>

Przestrzeń nazw zapewnia tę zaletę, że pozwala uniknąć kolizji nazw: -

Na przykład możesz pisać kod zawierający funkcję o nazwie xyz(), a w twoim kodzie dostępna jest inna biblioteka, która również ma tę samą funkcję xyz(). Teraz kompilator nie ma możliwości sprawdzenia, do której wersji funkcji xyz() odwołujesz się w swoim kodzie.
Przestrzeń nazw ma na celu przezwyciężenie tej trudności i służy jako dodatkowa informacja w celu odróżnienia podobnych funkcji, klas, zmiennych itp. o tej samej nazwie dostępnych w różnych bibliotekach.
Najlepszym przykładem zakresu przestrzeni nazw jest standardowa biblioteka C++ (std), w której zadeklarowane są wszystkie klasy, metody i szablony. Dlatego pisząc program w C++, zwykle dołączamy tę dyrektywę
używając przestrzeni nazw std;

przestrzeń nazw w C++ | Zestaw 2 (rozszerzająca przestrzeń nazw i nienazwana przestrzeń nazw) Przestrzeń nazw w C++ | Zestaw 3 (Dostęp, tworzenie nagłówka, zagnieżdżanie i aliasing) Czy przestrzenie nazw można zagnieżdżać w C++? Odniesienie : http://www.cplusplus.com/doc/tutorial/namespaces/