关于c ++：使用std命名空间

Using std Namespace

对于在std名称空间中使用"using"似乎有不同的观点。

有些人说使用"EDOCX1"(0)，另一些人说不使用，而是使用前缀std函数，这些函数将与"EDOCX1"(1)一起使用，而另一些人说使用类似这样的函数：

1
2
3
4
5

using std::string;
using std::cout;
using std::cin;
using std::endl;
using std::vector;

用于所有要使用的标准函数。

每种方法的优缺点是什么？

相关讨论

大多数C++用户都非常乐意阅读EDCOX1，8，EDCOX1，9，等等。事实上，看到原始EDOCX1的10度，这让我想知道这是EDCOX1还是9，还是一个不同的用户定义的EDCOX1，10？

我一直反对使用using namespace std;。它将各种名称导入到全局命名空间中，并可能导致各种不明显的歧义。

下面是std名称空间中的一些常见标识符：count、sort、find、equal、reverse。有一个称为count的局部变量意味着using namespace std不能使您使用count而不是std::count。

不需要的名称冲突的典型示例如下所示。想象一下，你是个初学者，不了解std::count。假设您在中使用了其他东西，或者它被一个看起来不相关的头拉入。

1
2
3
4
5
6
7
8
9

#include
using namespace std;

int count = 0;

int increment()
{
return ++count; // error, identifier count is ambiguous
}

这个错误通常很长而且不友好，因为std::count是一个具有长嵌套类型的模板。

但这是正常的，因为std::count进入全局名称空间，而函数计数隐藏了它。

1
2
3
4
5
6
7
8

#include
using namespace std;

int increment()
{
static int count = 0;
return ++count;
}

也许有点奇怪，这还可以。导入到声明性作用域中的标识符出现在公共命名空间中，该命名空间包含定义它们的位置和导入它们的位置。换句话说，std::count在全局命名空间中可视为count，但仅在increment中可见。

1
2
3
4
5
6
7
8

#include

int increment()
{
using namespace std;
static int count = 0;
return ++count;
}

由于类似的原因，count在这里是模棱两可的。using namespace std不会引起std::count，按预期隐藏外部count。using namespace规则意味着std::count看起来(在increment函数中)好像是在全球范围内声明的，即在与int count = 0;相同的范围内，从而导致歧义。

1
2
3
4
5
6
7
8
9

#include

int count = 0;

int increment()
{
using namespace std;
return ++count; // error ambiguous
}

相关讨论

但是如果没有std：：前缀，输入sooo就容易多了！
@不，没有。五个字符在打字时没有那么重要，但是这五个字符在阅读时可能很重要。而且，代码的易读性比源代码的键入容易得多，因为代码的可读性比写的要大得多。
std:：xxx显然是明确的
您可以添加using语句在作用域规则中的行为是正确的。
但是，如果您有诸如count、sort等标识符与"using namespace std"；一起使用，那么如果您尝试在std命名空间中使用该名称，并且必须对其进行限定，则会出现命名冲突错误，就像您没有该指令一样。所以你真的没有失去任何指令，只是在这个特定的例子中，它也没有给你买任何东西。
@Martin York：更新了说明范围规则的示例。@迈克尔·伯尔：可以说，这并不是那么糟糕，我真正不喜欢的是简单错误的错误信息难以解释，或者根本就不会发生。例如，如果一个函数被认为是在作用域内，但不是在作用域内，而std：：函数是在作用域内，而不是得到一个有用的"标识符不可识别"错误，那么您通常会得到一个更模糊的"无法转换参数x"或"无法从模板生成函数"样式错误。更糟糕的是，如果一个错误的函数被静默调用。这很罕见，但确实发生了。
@查尔斯——悄悄地调用错误函数的可能性是合法的——但正如你所说，这种可能性很小，我不确定危险是否需要"禁止"使用"EDOCX1"〔8〕。但我同意这是一个合理的观点。我不太相信这些令人困惑的错误消息——发生这些错误消息的原因是编译器为模板生成了令人困惑的错误消息(尽管它们正在变得更好)，实际上与using指令没有任何关系。我不认为有人会说永远不应该使用模板，因为它们会产生难以破译的错误。
@迈克尔·伯尔：这可能只是我个人的一场战争，但我确实认为，令人困惑的错误消息是一个重大问题，特别是对于初学者来说。using namespace std;经常被作为帮助初学者的工具出售，但我经常看到这样的例子，它会导致大量令人困惑的错误。
作为一个实验，我编写了一个名为equals的函数，它需要3倍的时间。然后我用有效参数调用它，但故意将其拼写错误为equal。没有u n s;，我收到一条简单的消息，"equal"没有在这个范围内声明。有了它，我得到了27行关于2个错误的消息，比如"double"不是类、结构或联合类型，"uuu simple"不是类型"bool"的有效模板参数，因为它是一个非常量表达式。有经验的C++开发人员可能不会涉足其中找到根本原因，但大多数初学者会被难住。(GCC 4.4.0)
值得注意的是，如果您有：int swap; using namespace std; int main() { ::swap = 1; }，它总是不含糊的：显式指定作用域将搜索使用using指令放置的命名空间-但它不会导致与现有声明的冲突。这只发生在非限定名称查找中
好吧，我很惊讶没有人讨论过using std::xxx;的选择。它不会造成名称空间污染，编写代码会更短，我认为copy比std::copy更容易阅读。
如果您使用的是IDE(Eclipse)，输入"std:："将在该名称空间中列出所有可能的选择。使用写工具，看起来更长的代码实际上更少的输入！
@SBI：我认为有些代码实际上更容易阅读，当它不与整个地方的std::混乱的时候。与过长的标识符名称(即使它们具有很强的描述性)一样，也会损害可读性。
@迈克：读这个。

排除基础知识(必须在所有STL对象/函数之前添加std:：infont，如果没有"使用命名空间std"，则冲突的可能性更小)

同样值得注意的是，你不应该

1	using namespace std

在头文件中，因为它可以传播到包含该头文件的所有文件，即使它们不想使用该名称空间。

在某些情况下，使用诸如

1	using std::swap

就像有专门版本的swap一样，编译器将使用它，否则它将回到std：：swap上。

如果调用std：：swap，则始终使用基本版本，它不会调用优化版本(如果存在)。

相关讨论

首先，一些术语：

使用声明：using std::vector;。
使用指令：using namespace std;。

我认为使用using指令是可以的，只要它们不在头文件的全局范围内使用。所以拥有

1	using namespace std;

在您的.cpp文件中并不是一个真正的问题，如果结果是这样的话，它完全在您的控制之下(如果需要的话，它甚至可以被限定到特定的块范围内)。我看不出有什么特别的理由用大量的std::限定符来混乱代码——它只是变成了一堆视觉噪声。但是，如果代码中没有使用std名称空间中的一大堆名称，那么我也认为省略该指令没有问题。这是一个重言式-如果指令不必要，那么就没有必要使用它。

同样，如果您可以在std名称空间中对特定类型使用一些声明(而不是使用指令)，那么就没有理由不将这些特定的名称直接引入当前名称空间。同样，我认为当一个单独的using指令也能做到这一点时，使用25个或30个声明会让簿记工作变得很麻烦。

记住有时必须使用using声明也是一件好事。请参阅Scott Meyers的"项目25：考虑支持非投掷交换"从有效的C++，第三版。为了让一个通用的、模板化的函数对参数化类型使用"最佳"交换方法，您需要使用using声明和依赖于参数的查找(也称为adl或koenig查找)：

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

template< typename T >
void foo( T& x, T& y)
{
using std::swap; // makes std::swap available in this function

// do stuff...

swap( x, y); // will use a T-specific swap() if it exists,
// otherwise will use std::swap<T>()

// ...
}

我认为我们应该看看各种语言的常见习惯用法，这些语言大量使用名称空间。例如，Java和C语言在很大程度上使用命名空间(可以说是MeSeo而不是C++)。在这些语言中使用名称空间中最常见的方法是将名称空间集中到当前作用域中，并使用相当于using指令的方法。这并没有引起广泛的问题，而且很少的问题是在"异常"的基础上处理的，通过完全限定的名称或别名处理所涉及的名称——就像C++中可以完成的一样。

Habor萨特和Andrei Alexandrescu在"第59项：不要在头文件中使用命名空间，或者在他们的书、C++编码标准之前包含"命名空间"：101条规则、指南和最佳实践：

In short: You can and should use namespace using declarations and directives liberally in your implementation files after #include directives and feel good about it. Despite repeated assertions to the contrary, namespace using declarations and directives are not evil and they do not defeat the purpose of namespaces. Rather, they are what make namespaces usable.

在"C++编程语言，第三版"中，Stroupstrup经常被引用为"不要污染全局命名空间"。他确实这么说(c.14[15])，但提到了c.10.1章，他说：

A using-declaration adds a name to a
local scope. A using-directive does
not; it simply renders names
accessible in the scope in which they
were declared. 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
26
27
28
29
30
31
32
namespaceX {
int i , j , k ;
}

int k ;
void f1()
{
int i = 0 ;

using namespaceX ; // make names from X accessible

i++; // local i
j++; // X::j
k++; // error: X::k or global k ?

::k ++; // the global k

X::k ++; // X’s k
}

void f2()
{
int i = 0 ;

using X::i ; // error: i declared twice in f2()
using X::j ;
using X::k ; // hides global k

i++;
j++; // X::j
k++; // X::k
}

A locally declared name (declared
either by an ordinary declaration or
by a using-declaration) hides nonlocal
declarations of the same name, and any
illegal overloadings of the name are
detected at the point of declaration.

Note the ambiguity error for k++ in
f1(). Global names are not given
preference over names from namespaces
made accessible in the global scope.
This provides significant protection
against accidental name clashes, and –
importantly – ensures that there are
no advantages to be gained from
polluting the global namespace.

When libraries declaring many names
are made accessible through
using-directives, it is a significant
advantage that clashes of unused names
are not considered errors.

...

I hope to see a radical decrease in
the use of global names in new
programs using namespaces compared to
traditional C and C++ programs. The
rules for namespaces were specifically
crafted to give no advantages to a
‘‘lazy’’ user of global names over
someone who takes care not to pollute
the global scope.

如何与"懒惰的全局名称用户"有相同的优势？通过利用using指令，它可以安全地使名称空间中的名称对当前作用域可用。

请注意，std命名空间中的名称有一个区别，即通过正确使用using指令(通过将该指令放在#includes之后)可用于某个作用域，这不会污染全局命名空间。它只是让这些名字很容易被使用，并持续防止冲突。

相关讨论

关于最后一点：Java和C语言还有很多新的命名空间。如果BCL中的所有内容都存在于系统中，"使用系统"将导致与"使用命名空间std"同样多的问题。
但是，我看到的Java和C语言程序通常会带来它们使用的所有命名空间——而不仅仅是"系统"(或它的等价物)。因此，有5个或10个指令可以或多或少地执行相同的操作，而不是一个引入所有所用名称的using指令。另外，"使用名称空间std；"真的会带来那么多麻烦吗？
问题是，std有太多的通用名称，而包含一个标准头的名称可能包含所有其他名称。我们对进口商品没有很好的控制，风险太大。我对Java和C语言了解不多，但我知道艾达的模块系统比C++好得多，而且导入名字通常是不赞成的。一般来说，首先是命名约定(我见过人们使用前缀和名称空间，不导入没有意义)，然后是样式。
我仍然不相信这是一个现实世界的问题。我看到使用指令一直在使用，没有严重的缺点。再说一次，我不介意不使用它们。我只是希望std::限定符不要把代码弄得乱七八糟——还有其他的方法可以避免这种情况(使用声明或typedef通常可以做到这一点)。
@迈克尔，你接受我的话吗？因为冲突，我花时间删除了使用声明。list是用于在Lisp解释器中标识列表的自然标识符。现在，如果您使用的命名约定可以自然地防止与标准库(即以大写字母开头的类型名…)发生冲突，那么您通常不会看到问题。你是幸运的，C++0X已经放弃了概念，你不会很快得到这样的名字…
@我当然会接受你的话，那会给你带来麻烦。然而，我保留顽固地坚持我的观点的权利，即使这是错误的)。用巴特·辛普森的话说，我不会承诺不再不必要地在我的代码中使用"namspace-std"，但我会尝试。
@程序：你说，"list是在lisp解释器中标识list的自然标识符"——但是有"using namespace std;指令并不妨碍你声明你的自然标识符"list"——只是如果你这样做了，你就不能再使用std::list而不限定它了。这与没有"using namespace std;指令"没有区别。还是我错过了什么？
@迈克尔，我修改了我的答案来解释发生了什么。这个故事太长了，无法发表评论。

不要在头文件的全局范围内使用命名空间。这可能导致冲突，并且冲突出现的文件负责人对原因没有控制权。

在实现文件中，选择要少得多。

放置一个using-namespace-std会带来该名称空间中的所有符号。这可能会很麻烦，因为几乎没有人知道所有的符号(因此在实践中不可能有冲突的政策)，而不提到将要添加的符号。C++标准允许头从其他头添加符号(C一个不允许)。在控制案例中简化写作，在实践中仍能取得较好的效果。如果出现错误，则在出现问题的文件中检测到错误。
使用std：：name；的优点是编写简单，不存在导入未知符号的风险。代价是您必须显式地导入所有需要的符号。
明确限定添加了一点混乱，但我认为这是一些实践中较少的麻烦。

在我的项目中，我对所有名称都使用明确的限定条件，我接受使用std:：name，我反对反对使用名称空间std(我们有一个lisp解释器，它有自己的列表类型，所以冲突是必然的)。

对于其他名称空间，还必须考虑使用的命名约定。我知道一个项目使用名称空间(用于版本控制)和名称前缀。那么做一个using namespace X几乎是没有风险的，不这样做会导致看起来很愚蠢的代码PrefixNS::pfxMyFunction(...)。

在某些情况下，您希望导入符号。std：：swap是最常见的情况：导入std：：swap，然后使用swap unqualified。依赖于参数的查找将在类型的命名空间中找到适当的交换(如果有)，如果没有，则返回到标准模板。

编辑：

在评论中，迈克尔·伯尔怀疑冲突是否发生在现实世界中。这是一个真实的实例。我们有一种扩展语言，它是Lisp方言。我们的解释器有一个include文件，lisp.h包含

1	typedef struct list {} list;

我们必须集成并修改一些代码(我将其命名为"引擎")，这些代码如下所示：

1
2
3
4
5

#include <list>
...
using std::list;
...
void foo(list const&) {}

所以我们修改如下：

1
2
3
4
5
6
7

#include <list>

#include"module.h"
...
using std::list;
...
void foo(list const&) {}

很好。一切正常。几个月后，"module.h"被修改为包含"list.h"。测试通过了。"模块"没有以影响其ABI的方式进行修改，因此可以在不重新编译用户的情况下使用"引擎"库。集成测试正常。发布了新的"模块"。引擎的下一次编译在其代码未被修改时中断。

相关讨论

两个

1	using std::string;

和

1	using namespace std;

向全局命名空间添加一些符号(一个或多个)。在头文件中，向全局名称空间添加符号是不应该做的事情。您无法控制谁将包含您的头，有许多包含其他头的头(以及包含包含头的头等等…)。

在实现(.cpp)文件中，这取决于您(只有记住在所有include指令之后才这样做)。您可以只破坏这个特定文件中的代码，这样更容易管理和找出名称冲突的原因。如果您喜欢在标识符之前使用std:：(或任何其他前缀，项目中可能有许多名称空间)，这是可以的。如果您想将使用的标识符添加到全局名称空间中，可以。如果您想让整个名称空间出现在您的头上：—)，这取决于您自己。虽然效果仅限于单个编译单元，但可以接受。

对我来说，我更喜欢尽可能使用::。

1	std::list<int> iList;

我讨厌写：

1
2
3
4

for(std::list<int>::iterator i = iList.begin(); i != iList.end(); i++)
{
//
}

希望，用C++ 0x我会写这个：

1
2
3
4

for(auto i = iList.begin(); i != iList.end(); i++)
{
//
}

如果名称空间很长，

1
2
3
4
5
6
7
8
9
10

namespace dir = boost::filesystem;

dir::directory_iterator file("e:/boost");
dir::directory_iterator end;

for( ; file != end; file++)
{
if(dir::is_directory(*file))
std::cout << *file << std::endl;
}

相关讨论

如果代码中没有与std和其他库发生名称冲突的风险，则可以使用：

1	using namespace std;

但是，如果您希望准确了解代码对文档的依赖性，或者存在名称冲突的风险，请使用另一种方式：

1 2	using std::string; using std::cout;

第三个解决方案是，不要使用这些解决方案，在代码中每次使用之前都要编写std：：以提高安全性，但是，代码中可能会有一些负担…

在头中的名称空间范围内，不应该是using namespace std。另外，我想大多数程序员会想，当他们看到没有std::的vector或string时，不是using namespace std更好。因此，我主张永远不要做江户。

如果您认为必须这样做，请添加本地using声明，如using std::vector。但是问问你自己：这值多少钱？一行代码写了一次(可能两次)，但读了一万、十万或一千次。与读取代码的工作量相比，添加using声明或指令所节省的键入工作量是微乎其微的。

考虑到这一点，在十年前的一个项目中，我们决定用它们的完整名称空间名称显式地限定所有标识符。起初看起来很尴尬的事情在两周内就变成了例行公事。现在，在整个公司的所有项目中，没有人再使用指令或声明了。(有一个例外，见下文)看了十年后的代码(几个MLOC)，我觉得我们做出了正确的决定。

我发现，通常情况下，那些反对取缔using的人通常不会只为一个项目而尝试。那些尝试过的人通常会发现，在很短的时间内使用指令/声明比使用指令/声明更好。

注意：唯一的例外是using std::swap，它是收集不能放入std命名空间的swap()的重载所必需的(特别是在通用代码中)(因为我们不允许将std函数的重载放入此命名空间)。

相关讨论

std：：swap的专门化是完全的专门化-不能部分专门化函数模板。只要专门化依赖于用户定义的类型，任何程序都可以部分地专门化任何标准库模板。
@查尔斯：是的，你是对的，当然，没有FTPS。我可以专门化std中的模板，但不能超载。对不起，那个脑残。我会更正这个帖子的。
我认为using namespace指令的目的也不是为了让打字更容易；相反，它是为了让阅读更容易，因为正如您所说，代码必须被读取几十、数百或数千次。对一些人来说，它读起来容易得多，而且std::的杂乱更少。但这可能取决于个人的感知能力；有些人过滤掉std::，甚至需要它来指导(如serif)，另一些人在它上面挣扎，感觉像在崎岖的路上。
@鲁米：不管你喜欢短文还是长文都是主观的，但是前缀客观上增加了代码的清晰度。
@斯比：不，这不客观。这取决于您是否认为std：：有用，或者杂乱无章。更杂乱->更不清晰。
@约书亚：我们能同意编译器是客观的吗？
也许是吧。；-)不同的编译器将处理不同的事情。有时是对的，有时是错的，有时是好的，有时是坏的(主观上)，很难做出一个普遍的声明，这是好的，因为我不喜欢别人告诉我"必须"做什么，除非它真的是无可否认的好。
约书亚：叹息。我们能同意完全符合标准是客观的吗？(还要注意，我的回答以"你应该……"开头，我曾经站在你的立场上。)
@当然，我们可以同意标准一致性可以被客观地评估。但你的观点是什么——我有兴趣知道你是如何从那里"客观地为代码添加清晰的前缀"的？我不是真的在评论你最初的答案，只是你最后一次对鲁米的评论。你最初的回答是以你的观点为框架的，它涉及到一个有趣的经验，这将帮助人们决定他们自己的想法，所以谢谢。
@我的意思是编译器更喜欢前缀的清晰性。(如果你忽略了它们，它们有时会"困惑"，并称之为意外的过载。如果在名称空间前面加前缀，它们总是调用正确的名称空间。)

名称空间包含代码，以防止混淆和污染函数签名。

下面是一个完整的、有文档记录的正确名称空间使用示例：

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

#include <iostream>
#include <cmath> // Uses ::log, which would be the log() here if it were not in a namespace, see https://stackoverflow.com/questions/11892976/why-is-my-log-in-the-std-namespace

// Silently overrides std::log
//double log(double d) { return 420; }

namespace uniquename {
using namespace std; // So we don't have to waste space on std:: when not needed.

double log(double d) {
return 42;
}

int main() {
cout <<"Our log:" << log(4.2) << endl;
cout <<"Standard log:" << std::log(4.2);
return 0;
}
}

// Global wrapper for our contained code.
int main() {
return uniquename::main();
}

输出：

1 2	Our log: 42 Standard log: 1.43508

using namespace std导入当前std命名空间的内容。因此，优点是您不必在该名称空间的所有函数前面键入std::。但是，可能会有不同的名称空间具有相同名称的函数。因此，你可能不会给你想要的人打电话。

手动指定要在EDOCX1中导入的内容可以防止这种情况发生，但可能会导致在文件开头出现一长串使用列表，有些开发人员会发现这很难看；)！

就个人而言，我更喜欢在每次使用函数时指定名称空间，除非名称空间太长，在这种情况下，我在文件的开头使用了一些。

编辑：正如另一个答案所指出的，您不应该将using namespace放在头文件中，因为它将传播到包括此头文件在内的所有文件，从而可能产生不需要的行为。

伊迪丝2：感谢查尔斯的评论，更正了我的回答。

相关讨论

有几种方法可以解决这个问题。

第一：像你做的那样使用。

第二：做namespace S = std;，减少2个字符。

第三：使用static。

第四：不要使用std使用的名字。

只要您使用的IDE不够灵活，无法显示或隐藏所需的准确信息，此讨论就将继续进行。

这是因为您希望代码的外观取决于手头的任务。

在创建源代码时，我更喜欢确切地看到我使用的是哪个类：是std::string类还是BuzFlox::Obs::string类？

在设计控制流时，我甚至对变量的类型不感兴趣，但我希望重点关注if和while和continue。

所以我的建议是：

根据代码的受众和工具的功能，选择最容易阅读或提供最多信息的方式。

非常类似于Java，您可以在其中使用Java或UTI.*，也可以单独选择每个类，这取决于样式。请注意，您不希望在文件/宽范围的开头使用一个using namespace std，因为您会污染命名空间，可能会发生冲突，从而破坏命名空间的作用点。但是，如果您有一个使用大量STL的函数，那么它会使代码变得混乱，从而在逻辑中产生混乱的前缀语法，您可能应该考虑使用using namespace std(在使用各种类时)或单个using(在经常使用一些类时)。

例如，为什么不呢

1
2
3
4

typedef std::vector<int> ints_t;
ints_t ints1;
....
ints_t ints2;

而不是笨拙的

1
2
3

std::vector<int> ints1;
...
std::vector<int> ints2;

我发现它更易读，它是我的编码标准。

甚至可以使用它为读者提供一些语义信息。例如，考虑函数原型

1	void getHistorgram(std::vector<unsigned int>&, std::vector<unsigned int>&);

哪一个是回报值？

换一个怎么样

1
2
3
4

typedef std::vector<unsigned int> values_t;
typedef std::vector<unsigned int> histogram_t;
...
void getHistogram(values_t&, histogram_t&);

What are the pros and cons of each

离开std：：的唯一原因是，理论上，您可以自己重新实现所有stl函数。然后您的函数可以从使用std：：vector切换到my：：vector，而无需更改代码。

相关讨论