Namespaces
Namespaces allow to group entities like classes, objects and functions under a name. This way the global scope can be divided in "sub-scopes", each one with its own name.
The format of namespaces is:
namespace identifier
{
entities
}
Where
identifier is any valid identifier and
entities is the set of classes, objects and functions that are included within the namespace. For example:
1
2
3
4
|
namespace myNamespace
{
int a, b;
}
|
In this case, the variables
a and
b are normal variables declared within a namespace called
myNamespace. In order to access these variables from outside the
myNamespace namespace we have to use the scope operator
::. For example, to access the previous variables from outside
myNamespace we can write:
1
2
|
myNamespace::a
myNamespace::b
|
The functionality of namespaces is especially useful in the case that there is a possibility that a global object or function uses the same identifier as another one, causing redefinition errors. For example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
// namespaces
#include <iostream>
using namespace std;
namespace first
{
int var = 5;
}
namespace second
{
double var = 3.1416;
}
int main () {
cout << first::var << endl;
cout << second::var << endl;
return 0;
}
|
5
3.1416
|
In this case, there are two global variables with the same name:
var. One is defined within the namespace
first and the other one in
second. No redefinition errors happen thanks to namespaces.
using
The keyword
using is used to introduce a name from a namespace into the current declarative region. For example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
// using
#include <iostream>
using namespace std;
namespace first
{
int x = 5;
int y = 10;
}
namespace second
{
double x = 3.1416;
double y = 2.7183;
}
int main () {
using first::x;
using second::y;
cout << x << endl;
cout << y << endl;
cout << first::y << endl;
cout << second::x << endl;
return 0;
}
|
5
2.7183
10
3.1416
|
Notice how in this code,
x (without any name qualifier) refers to
first::x whereas
y refers to
second::y, exactly as our
using declarations have specified. We still have access to
first::y and
second::x using their fully qualified names.
The keyword using can also be used as a directive to introduce an entire namespace:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
// using
#include <iostream>
using namespace std;
namespace first
{
int x = 5;
int y = 10;
}
namespace second
{
double x = 3.1416;
double y = 2.7183;
}
int main () {
using namespace first;
cout << x << endl;
cout << y << endl;
cout << second::x << endl;
cout << second::y << endl;
return 0;
}
|
5
10
3.1416
2.7183
|
In this case, since we have declared that we were
using namespace first, all direct uses of
x and
y without name qualifiers were referring to their declarations in
namespace first.
using and
using namespace have validity only in the same block in which they are stated or in the entire code if they are used directly in the global scope. For example, if we had the intention to first use the objects of one namespace and
then those of another one, we could do something like:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
// using namespace example
#include <iostream>
using namespace std;
namespace first
{
int x = 5;
}
namespace second
{
double x = 3.1416;
}
int main () {
{
using namespace first;
cout << x << endl;
}
{
using namespace second;
cout << x << endl;
}
return 0;
}
|
5
3.1416
|
Namespace alias
We can declare alternate names for existing namespaces according to the following format:
namespace new_name = current_name;
Namespace std
All the files in the C++ standard library declare all of its entities within the
std namespace. That is why we have generally included the
using namespace std; statement in all programs that used any entity defined in
iostream.
分享到:
相关推荐
Fix: C++: Anonymous namespaces were not parsed correctly. Fix: C/C++: designated initializers were not being parsed. Fix: C++: Templated class was not parsed correctly for member functions. For ...
Chapter 20: Namespaces and Preprocessor Directives 493 Chapter 21: Standard Template Library 509 Chapter 22: Sequence Containers–vector, list and deque 532 Chapter 23: Associative Containers–set, ...
Namespaces Chapter 15. Source Files and Programs Part III: Abstraction Mechanisms Chapter 16. Classes Chapter 17. Construction, Cleanup, Copy, and Move Chapter 18. Overloading Chapter 19. Special ...
Name lookup, namespaces, and the Interface Principle Memory management issues and techniques Traps, pitfalls, and anti-idioms Optimization Try your skills against the C++ masters and come away ...
Namespaces, The Class String, And User-Defined Simple Data Types. Chapter 8. Arrays. Chapter 9. Records (Structs). Chapter 10. Classes And Data Abstraction. Chapter 11. Inheritance And Composition. ...
In addition to the facilities provided by C, C++ provides additional data types, classes, templates, exceptions, namespaces, operator overloading, function name overloading, references, free store ...
1.1 INTRODUCTION TO C++ 2 Origins of the C++ Language 2 C++ and Object-Oriented Programming 3 The Character of C++ 3 C++ Terminology 4 A Sample C++ Program 4 1.2 VARIABLES, EXPRESSIONS, AND ASSIGNMENT...
Chapter 7: Building Namespaces Chapter 8: Introducing Inheritance Chapter 9: Using Templates Chapter 10: Using Streams and Files Chapter 11: Errors and Exception Chapter 12: Programming with Windows ...
Namespaces 3. 出错处理 Exception handling 4. 类型转换高级 Advacned Class Type-casting 5. 预处理指令 Preprocessor Directives 7. C++ 标准函数库 C++ Standard Library 1. 文件的输入输出 Input/...
1.1 INTRODUCTION TO C++ 2 Origins of the C++ Language 2 C++ and Object-Oriented Programming 3 The Character of C++ 3 C++ Terminology 4 A Sample C++ Program 4 1.2 VARIABLES, EXPRESSIONS, AND ASSIGNMENT...
Variable Scope and Functions Scope and Storage Class Namespaces Functions Summary of Parameter Types Recursion Structured Programming Basics Real-World Programming Programming Exercises Answers to ...
Namespaces, the class string, and User-Defined Simple Data Types. Chapter 8. Arrays. Chapter 9. Records (structs). Chapter 10. Classes and Data Abstraction. Chapter 11. Inheritance and Composition. ...
Scoping Namespaces Nested Classes Nonmember, Static Member, and Global Functions Local Variables Static and Global Variables Classes Doing Work in Constructors Default Constructors Explicit ...
In addition to the facilities provided by C, C++ provides additional data types, classes, templates, exceptions, namespaces, operator overloading, function name overloading, references, free store ...
Exploring C++ divides C++ up into bite-sized chunks that will help you learn the language one step at a time. Assuming no familiarity with C++, or any other C-based language, you’ll be taught ...
一些经过验证的用来改善程序效率的方法,包括检验C++... 介绍新的语言特性,包括bool、mutable、explicit、namespaces、成员模板、标准模板库等。如果你的编译器不支持这些特性,本书还介绍了如何不利用它们完成工作。
are introduced including the syntax of C++, namespaces, the C++ standard library and optimization with compile time constants. This chapter uses our target system with the 8-bit microcontroller.
the facilities provided by C, C++ provides additional data types, classes, templates, exceptions, namespaces, operator overloading, function name overloading, references, free store management ...
this new fourth edition covers them all, including nested namespaces, structured bindings, string_view, template argument deduction for constructors, parallel algorithms, generalized sum algorithms, ...
一些经过验证的用来改善程序效率的方法,包括检验C++..., 介绍新的语言特性,包括bool、mutable、explicit、namespaces、成员模板、标准模板库等。如果你的编译器不支持这些特性,本书还介绍了如何不利用它们完成工作。