}
that closes the function definition), but not outside it:
|
|
|
|
|
|
inner block: x: 50 y: 50 outer block: x: 10 y: 50 |
y
is not hidden in the inner block, and thus accessing y
still accesses the outer variable.namespace identifier { named_entities } |
identifier
is any valid identifier and named_entities
is the set of variables, types and functions that are included within the namespace. For example:
|
|
a
and b
are normal variables declared within a namespace called myNamespace
.a
or b
), but if accessed from outside the myNamespace
namespace they have to be properly qualified with the scope operator ::
. For example, to access the previous variables from outside myNamespace
they should be qualified like:
|
|
|
|
5 6.2832 3.1416 |
value
. One is defined within the namespace foo
, and the other one in bar
. No redefinition errors happen thanks to namespaces. Notice also how pi
is accessed in an unqualified manner from within namespace bar
(just as pi
), while it is again accessed in main
, but here it needs to be qualified as bar::pi
.
|
|
a
and c
are in namespace foo
, while b
is in namespace bar
. Namespaces can even extend across different translation units (i.e., across different files of source code).using
introduces a name into the current declarative region (such as a block), thus avoiding the need to qualify the name. For example:
|
|
5 2.7183 10 3.1416 |
main
, the variable x
(without any name qualifier) refers to first::x
, whereas y
refers to second::y
, just as specified by the using
declarations. The variables first::y
and second::x
can still be accessed, but require fully qualified names.using
can also be used as a directive to introduce an entire namespace:
|
|
5 10 3.1416 2.7183 |
first
, all direct uses of x
and y
without name qualifiers were also looked up in namespace first
.using
and using namespace
have validity only in the same block in which they are stated or in the entire source code file if they are used directly in the global scope. For example, it would be possible to first use the objects of one namespace and then those of another one by splitting the code in different blocks:
|
|
5 3.1416 |
namespace new_name = current_name;
std
namespace. Most examples in these tutorials, in fact, include the following line:
|
|
std
namespace into the code. This is done in these tutorials to facilitate comprehension and shorten the length of the examples, but many programmers prefer to qualify each of the elements of the standard library used in their programs. For example, instead of:
|
|
|
|
std
namespace are introduced with using
declarations or are fully qualified on every use does not change the behavior or efficiency of the resulting program in any way. It is mostly a matter of style preference, although for projects mixing libraries, explicit qualification tends to be preferred.
|
|
0 4285838 |
x
is guaranteed to be zero. y
can actually contain just about any value (including zero).Previous: Overloads and templates | Index | Next: Arrays |