名称的知名度

命名实体，如变量，函数和复合型需要C ++在使用前进行声明。在这个声明发生在程序的点影响其知名度：

任何块之外声明实体具有 全球范围内，这意味着它的名字是有效的代码的任何地方。而一个实体块内声明，如函数或选择性声明，具有 阻止范围，并且仅在它被声明的特定块中可见的，但不是外面。

与块作用域的变量称为 局部变量。

例如，在一个函数的主体声明的变量是一个 局部变量延伸直到所述功能的结束（即，直至托架 }关闭所述函数定义），但不外面：

1 2 3 4 5 6 7 8 9 10 11 12 13

int foo; // global variable int some_function () { int bar; // local variable bar = 0; } int other_function () { foo = 1; // ok: foo is a global variable bar = 2; // wrong: bar is not visible from this function }

在每个范围内，一个名字只能代表一个实体。例如，不能有两个变量与在同一范围内相同的名称：

1 2 3 4 5 6 7

int some_function () { int x; x = 0; double x; // wrong: name already used in this scope x = 0.0; }

与实体的可视性 块范围延伸直到该块的末端，包括内块。尽管如此，一个内部块时，因为它是一个不同的块，可以重新利用现有的外部范围来指代不同的实体的名称; 在这种情况下，名称将参考不同的实体只有内块内，隐藏外实体它的名字。虽然外面，它仍然会引用原始实体。例如：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// inner block scopes #include <iostream> using namespace std; int main () { int x = 10; int y = 20; { int x; // ok, inner scope. x = 50; // sets value to inner x y = 50; // sets value to (outer) y cout << "inner block:\n"; cout << "x: " << x << '\n'; cout << "y: " << y << '\n'; } cout << "outer block:\n"; cout << "x: " << x << '\n'; cout << "y: " << y << '\n'; return 0; }

内部块： X：50 Y：50 外块： X：10 Y：50

编辑及运行

请注意， y是不是隐藏在内层块，从而访问 y仍然访问外部变量。

在引入块声明，如函数参数和循环和条件（如那些在支持或如果申报）声明的变量声明的变量是局部的，他们引进了块。

命名空间

只有一个实体可以在一个特定的范围内特定名称存在。这是很少的本地名称的问题，因为块往往比较短，名称有在其中的特殊用途，例如命名一个计数器变量，参数，等等... 

但非本地名称带来名称冲突更多的可能性，尤其是考虑到图书馆可以声明许多功能，类型和变量，在本质上都没有地方，其中一些非常普通。

命名空间允许我们组命名的实体，否则将有 全球范围内为较窄的范围，给他们 命名空间范围。这使得组织的计划成的名字被称为不同的逻辑范围的元素。

声明一个命名空间的语法是：

命名空间标识 { named_entities }

哪里 identifier是任何有效的标识符，并且 named_entities是一组包含在命名空间中的变量，类型和函数。例如：

1 2 3 4

namespace myNamespace { int a, b; }

在这种情况下，变量 a和 b是一个称为空间内声明正常变量 myNamespace。

这些变量可以从他们的命名空间通常内（无论是被访问，其标识 a或 b），但如果从外部访问的 myNamespace命名空间它们必须与范围操作者适当资格 ::。例如，为了访问以前的变量，从外面 myNamespace就应该加以限定，如：

1 2

myNamespace::a myNamespace::b

命名空间是非常有用的，以避免名称冲突。例如：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

// namespaces #include <iostream> using namespace std; namespace foo { int value() { return 5; } } namespace bar { const double pi = 3.1416; double value() { return 2*pi; } } int main () { cout << foo::value() << '\n'; cout << bar::value() << '\n'; cout << bar::pi << '\n'; return 0; }

五 6.2832 3.1416

编辑及运行

在这种情况下，存在具有相同名称的两个功能： value。一个被命名空间中定义 foo，以及对方一 bar。无重定义错误发生感谢命名空间。还要注意如何 pi在不合格的方式从命名空间中访问 bar（正如 pi），而它再次访问的 main，但在这里它需要被定性为 bar::pi。

命名空间可以拆分：一码的两个片段可以在同一个命名空间中声明：

1 2 3

namespace foo { int a; } namespace bar { int b; } namespace foo { int c; }

这声明三个变量： a和 c在命名空间 foo，而 b在命名空间 bar。命名空间，甚至可以在不同的翻译单元扩展（即跨越的源代码不同的文件）。

运用

关键字 using引入了一个名字到当前声明区域（例如块），从而避免了需要来限定的名称。例如：

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 << '\n'; cout << y << '\n'; cout << first::y << '\n'; cout << second::x << '\n'; return 0; }

五 2.7183 10 3.1416

编辑及运行

请注意，在 main中，变量 x（没有任何名称限定符）是指 first::x，而 y指的是 second::y，正如由指定 using声明。变量 first::y和 second::x仍然可以访问，但需要完全限定名。

关键字 using也可以用来作为一个指令来介绍整个名字空间：

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 << '\n'; cout << y << '\n'; cout << second::x << '\n'; cout << second::y << '\n'; return 0; }

五 10 3.1416 2.7183

编辑及运行

在这种情况下，通过声明我们使用的命名空间 first，所有的直接用途 x，并 y没有名字的预选赛也分别在命名空间中抬起头来 first。

using并且 using 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 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 << '\n'; } { using namespace second; cout << x << '\n'; } return 0; }

五 3.1416

编辑及运行

命名空间别名

现有的命名空间可以使用新名称的别名，语法如下：

namespace new_name = current_name;

std命名空间

所有实体C ++标准库（变量，类型，常量和功能）的内声明 std的命名空间。在这些教程中的大多数例子，其实包括以下行：

using namespace std;

这里主要介绍的所有名称直接查看 std命名空间到代码。这是在这些教程做是为了方便理解和缩短的例子长度，但很多程序员喜欢限定每个在其方案中使用的标准库的元素。例如，而不是：

cout << "Hello world!";

这是常见的，而不是看：

std::cout << "Hello world!";

无论是在元素 std命名空间中引入了 using声明或完全有资格在每一个用途不改变以任何方式或行为所产生的程序的效率。它主要是风格喜好问题，虽然用于混合库项目，明确限定的倾向是优选的。

存储类

与变量存储 全局或 命名空间范围分配给该程序的整个过程。这被称为 静态存储，并将其与存储的对比 局部变量（这些块内声明）。这些使用了被称为自动存储。局部变量的存储是在声明它们的块时可用; 在此之后，该相同的存储可用于一些其他函数的局部变量，或以其他方式使用。

但与变量之间的另一种本质的区别 静态存储与和变量 自动存储：
-使用变量 静态存储未明确初始化自动初始化为0（如全局变量）。
-变量与 自动存储未明确初始化（如局部变量）未初始化，因此有一个不确定的值。

例如：

1 2 3 4 5 6 7 8 9 10 11 12 13

// static vs automatic storage #include <iostream> using namespace std; int x; int main () { int y; cout << x << '\n'; cout << y << '\n'; return 0; }

0 4285838

编辑及运行

实际的输出可能会有所不同，但只的值 x保证是零。 y 实际上可以包含几乎任何值（包括零）。