Interpretation of C + + namespaces "Go"

The purpose of using namespaces is to localize the names of identifiers to avoid naming conflicts. In C + +, variables, functions, and classes exist in large numbers. Without namespaces, the names of these variables, functions, and classes will all exist in the global namespace, causing many conflicts. For example, if we define a function toupper () in our own program, this overrides the ToUpper () function in the standard library, because both functions are in the global namespace. Naming conflicts can also occur in cases where a program uses two or more third-party libraries. At this point, it is quite possible that the name in one of the libraries is the same as the name in the other library, which is a conflict. This situation often occurs on the name of the class. For example, we define a stack class in our own program, and a library in our program may have a class with the same name, and the name conflicts.

The advent of the Namespace keyword is aimed at this problem. Because this mechanism is localized for the names declared therein, the same name can be used in different contexts without causing a name conflict. Perhaps the biggest beneficiaries of namespaces are the standard libraries in C + +. Before a namespace occurs, the entire C + + library is defined in the global namespace (which is, of course, the only namespace). With the introduction of namespaces, the C + + library is defined in its own namespace, called Std. This reduces the likelihood of name collisions. We can also create our own namespaces in our own programs so that we can localize names that we think might cause conflicts. This is especially important when we are creating classes or libraries of functions.

Namespace Basics

The namespace keyword allows us to separate the global namespace by creating a scope. Essentially, a namespace defines a scope. The basic form of defining the namespace is as follows:

namespace name {//declaration}

Anything defined in a namespace is confined to that namespace.

Here is an example of a namespace where a class that implements a simple decrement counter is localized. A counter class is defined in this namespace to implement the count, where Upperbound and lowerbound are used to represent the upper and lower bounds of the counter.

Demo namespaces

2. Namespace Counternamespace
4. {
8. int upperbound;
10. int lowerbound;
14. Class counter
16. {
20. int count;
22. Public
24. Counter (int n)
26. {
30. if (n <= upperbound) {
32. Count = N;
34. } else {
36. Count = Upperbound;
38. }
40. }
42. void Reset (int n)
44. {
46. if (n < upperbound)
48. {
50. Count = N;
52. }
54. }
56. int run () {
58. if (Count > Lowerbound)
60. {
62. return count--;
64. } else {
66. return lowerbound;
68. }
70. }
72. };
74. }

The Upperbound,lowerbound and class counter are all part of a namespace counternamespace definition scope.

An identifier declared in a namespace is a modifier that can be directly referenced and does not require any namespace. For example, in the Counternamesapce namespace, the run () function can refer to lowerbound directly in the statement:

Click (here) to collapse or open

1. if (Count > Lowerbound)
3. {
5. return count--;
7. }

However, since namespaces define a scope, we need to use the scope resolution operator to refer to the objects in the namespace outside of the namespace. For example, assigning a value of 10 to a upperbound outside the scope defined by the namespace Counternamespace must be written like this:

Counternamespace::upperbound = 10;

Or the object that you want to declare a counter class outside the scope of the Counternamespace definition must be written like this:

Counternamespace::counter obj;

In general, a member who wants to access the inside of a namespace outside the namespace needs to precede the member with the namespace and scope resolution operators.

The following program shows how to use the Counternamespace namespace:

Demo namespaces

2. #include <iostream>
4. using namespace Std;
6. Namespace Counternamespace
8. {
10. int upperbound;
12. int lowerbound;
16. Class counter
18. {
20. int count;
22. Public
24. Counter (int n)
26. {
28. if (n <= upperbound)
30. {
32. Count = N;
34. } else
36. {
38. Count = Upperbound;
40. }
42. }
44. void Reset (int n)
46. {
48. if (n < upperbound)
50. {
52. Count = N;
54. }
56. }
58. int run ()
60. {
62. if (Count > Lowerbound)
64. {
66. return count--;
68. }
70. Else
72. return lowerbound;
74. }
76. };
78. }
82. int main ()
84. {
86. Counternamespace::upperbound = 100;
88. Counternamespace::lowerbound = 0;
90. Counternamespace::counter Ob1 (10);
92. int i;
94. do {
96. i = Ob1.run ();
98. cout << i << "";
100. } while (i > Counternamespace::lowerbound);
102. cout << Endl;
104. Counternamespace::counter Ob2 (20);
106. do {
108. i = Ob2.run ();
110. cout << i << "";
112. } while (i > Counternamespace::lowerbound);
116. cout << Endl;
118. Ob2.reset (100);
120. Do
122. {i = Ob2.run ();
124. cout << i << "";
128. } while (i > Counternamespace::lowerbound);
130. cout << Endl;
132. return 0;
134. }

Note: The counter class and the references to Upperbound and Lowerbound are preceded by a counternamespace modifier. However, once an object of type counter is declared, there is no need to use this modifier on any member of the object. So Ob1.run () can be called directly. The namespaces can be parsed.

The same space names can be declared multiple times, and such declarations are complementary to each other. This allows namespaces to be split into several files or even different places in the same file. For example:

Click (here) to collapse or open

1. Namespace NS
3. {
5. int i;
7. }
11. //...
14. Namespace NS
16. {
18. Int J;
20. }

Where the namespace NS is divided into two parts, but the contents of the two parts are in the same namespace. i.e. NS. The last point: namespaces can be nested. This means that you can declare additional namespaces inside a namespace.

using Key Words

If you need to refer to a member of a namespace more than once in a program, it is cumbersome to use the scope resolver to specify the namespace each time, as we have previously said. To solve this problem, the Using keyword has been introduced. Using statements are typically used in two ways:

using namespace namespace name;

Using namespace name:: member;

The namespace name in the first form is the namespace we want to access. All members in the namespace are introduced into the current scope. That is, they are all part of the current namespace and are no longer required to use the scope qualifier. The second form simply makes the specified member in the specified namespace visible in the current scope. We use the preceding counternamespace for example, the following using statements and assignment statements are valid:

Using Counternamespace::lowerbound; Only the lowerbound is currently visible

Lowerbound = 10; This is legal because the Lowerbound member is currently visible

Using Counternamespace; All members of the Counternamespace space are currently visible

Upperbound = 100; This is legal because all the counternamespace members are now visible.

Here are the results of the changes we made to the previous program:

Use using

2. #include <iostream>
10. using namespace Std;
18. Namespace Counternamespace
22. {
26. int upperbound;
30. int lowerbound;
34. Class counter
38. {
42. int count;
46. Public
50. Counter (int n)
54. {
58. if (n < upperbound)
62. {
66. Count = N;
70. }
74. Else
78. {
82. Count = Upperbound;
86. }
90. }
98. void Reset (int n)
102. {
106. if (n <= upperbound)
110. {
114. Count = N;
118. }
122. }
130. int run ()
134. {
138. if (Count > Lowerbound)
142. {
146. return count--;
150. }

2. Else
4. {
6. return lowerbound;
8. }
10. }
12. };
14. }
16. int main ()
20. {
24. It's just a upperbound in Counternamespace.
28. Using Counternamespace::upperbound;
36. Access to Upperbound does not require the use of the range qualifier at this time
40. Upperbound = 100;
44. However, when using lowerbound, it is still necessary to use the range qualifier
48. Counternamespace::lowerbound = 0;
52. Counternamespace::counter Ob1 (10);
56. int i;
64. Do
68. {
72. i = Ob1.run ();
76. cout << i << "";
80. }while (i > Counternamespace::lowerbound);
84. cout << Endl;
92. Below we will use the entire Counternamespace namespace
96. using namespace Counternamespace;
100. Counter OB2 (20);
104. Do
108. {
112. i = Ob2.run ();
116. cout << i << "";
120. }while (i > Counternamespace::lowerbound);
124. cout << Endl;
132. Ob2.reset (100);
136. Lowerbound = 90;
140. Do
144. {
148. i = Ob2.run ();
152. cout << i << "";
156. }while (i > Lowerbound);
164. return 0;
168. }
172. The above program also demonstrates an important point: when we introduce a namespace using the using, if we have previously referenced other namespaces (or the same namespace), we will not overwrite the previous introduction, but rather supplement the previous introduction. That is, in the end, both the STD and Counternamespace namespaces in the above program become global spaces.
176. Namespaces with no Name
180. There is a special namespace called an unnamed namespace. This namespace with no name allows us to create namespaces that are available in a file scope. Its general form is as follows:
184. Namespace
188. {
192. Statement
196. }

We can use this unnamed namespace to create identifiers that are visible only in the file that declares him. That is, only in the file that declares the namespace, its members are visible, its members can be used directly, and no namespace names are required to be decorated. For other files, the namespace is not visible. As we mentioned earlier, restricting the scope of the global name to declaring his file is a way of declaring it static. Although C + + supports static global declarations, a better approach is to use the unnamed namespaces here.

STD name Space

Standard C + + defines its entire library in the Std namespace. This is why most of the programs in this book have the following code:

using namespace Std;

This is written in order to introduce the members of the Std namespace into the current namespace so that we can directly use the functions and classes in it, without having to write the STD every time::.

Of course, we can specify STD every time a member is used::, as long as we like. For example, we can display the following statement to specify cout:

Std::cout << "show using std:: to specify cout";

If our program uses only a small number of members in the Std namespace, or if the introduction of the Std namespace could lead to a namespace conflict, we would have no need to use the using namespace Std. However, if we are going to use the STD namespace members multiple times in the program, it would be much easier to introduce the members of the Std namespace into the current namespace by using namespace Std, rather than displaying the specified at the time of use alone.

Reprint Address: http://blog.renren.com/share/730973714/7874424429

Interpretation of C + + namespaces "Go"