另一个原因是惊讶。

如果我看到cout<<blah，而不是std:：cout<<blah，我会想：这是什么cout？这是正常的服装吗？有什么特别的吗？

考虑两个名为Foo和Bar的库：

using namespace foo;
using namespace bar;

一切都很好，你可以从Foo调用Blah（），从Bar调用Qux（）。但有一天你升级到了Foo 2.0的新版本，它现在提供了一个名为Qux（）的函数。现在出现了一个冲突：Foo 2.0和Bar都将Qux（）导入到全局命名空间中。这将需要一些努力来解决，特别是如果函数参数恰好匹配。

如果您使用了foo:：Blah（）和bar:：Qux（），那么引入foo:：Qux（）将是一个非事件。

这都是关于管理复杂性的。使用名称空间会将您不想要的东西拉进来，因此可能会使调试变得更困难（我说可能）。到处使用std:：很难阅读（更多的文本等等）。

马的课程-管理你的复杂性，尽你最大的能力和感觉。

这取决于它的位置。如果它是一个公共的头，那么通过将其合并到全局名称空间中，可以减小名称空间的值。请记住，这可能是制作模块全局的一种简单方法。

考虑

// myHeader.h
#include <sstream>
using namespace std;


// someoneElses.cpp/h
#include "myHeader.h"

class stringstream {  // Uh oh
};

请注意，这是一个简单的示例。如果您有包含20个include和其他导入的文件，那么您将有大量的依赖项来解决问题。更糟糕的是，根据冲突的定义，在其他模块中可能会出现不相关的错误。

这并不可怕，但如果不在头文件或全局名称空间中使用它，您将省去麻烦。在非常有限的范围内执行它可能是正确的，但我从未遇到过键入额外的五个字符来澄清我的函数来自何处的问题。

在类的头文件中使用名称空间的问题在于，它迫使任何想要使用您的类（通过包括头文件）的人也“使用”（即查看其他名称空间中的所有内容）。

但是，您可以随意在（私有）*.cpp文件中放入using语句。

请注意，有些人不同意我这样说的“感觉自由”，因为尽管cpp文件中的using语句比头文件中的要好（因为它不会影响包含头文件的人），但他们认为这仍然不好（因为根据代码的不同，这可能会使类的实现更难维护）。这个C++超级FAQ条目说，

using指令存在于遗留的C++代码中，用于简化向命名空间的转换，但您可能不应该定期使用它，至少不应该在新的C++代码。

常见问题解答建议了两种选择：

使用声明：使用std:：cout；//using声明允许您无条件使用coutcout<<“值：”；只需键入std:：std:：cout<<“值：”；

如果您导入了右侧的头文件，您的全局范围中会突然出现十六进制、左侧、加号或count等名称。如果您不知道std:：包含这些名称，这可能会令人惊讶。如果您也尝试在本地使用这些名称，可能会导致一些混淆。

如果所有的标准内容都在自己的命名空间中，那么就不必担心与代码或其他库的名称冲突。

我不认为这在任何情况下都是不好的做法，但在使用它时都需要小心。如果你正在编写一个库，你可能应该在命名空间中使用作用域解析运算符，以防止你的库与其他库冲突。对于应用程序级代码，我看不出它有什么问题。

您需要能够阅读与您不同风格和最佳实践意见的人编写的代码。如果你只使用cout，没有人会感到困惑。但是，当你有很多名称空间到处飞的时候，你看到这个类，你不太确定它做什么时，让名称空间显式充当某种注释。您可以第一眼看到，“哦，这是一个文件系统操作”或“这是在做网络工作”。

这可能比Greg写的更糟！

Library Foo 2.0可能会引入一个函数Qux（），它无疑比多年来代码调用的bar:：Qux）更适合您对Qux的某些调用。然后你的代码仍然可以编译，但它会默默地调用错误的函数，上帝知道会发生什么。这是最糟糕的事情了。

请记住，std名称空间有大量的标识符，其中许多是非常常见的标识符（例如列表、排序、字符串、迭代器等），这些标识符也很可能出现在其他代码中。

如果你认为这不太可能：在我给出这个答案大约半年后，在Stack Overflow上有一个问题（由于省略了std:：前缀而调用了错误的函数）。这是这一问题的另一个最近的例子。所以这是一个真正的问题。

这里还有一个数据点：很多很多年前，我还发现必须在标准库中的所有内容前面加上std:：，这很烦人。然后我在一个项目中工作，一开始就决定禁止使用指令和声明，但函数作用域除外。猜猜怎么了？我们中的大多数人花了几周的时间才习惯写前缀，再过几周，我们中的大部分人甚至同意这实际上使代码更可读。这是有原因的：你喜欢较短或较长的散文是主观的，但前缀客观上增加了代码的清晰度。不仅是编译器，您也会发现更容易看到引用的是哪个标识符。

在十年内，该项目发展到拥有数百万行代码。由于这些讨论一次又一次出现，我一度很好奇项目中实际使用（允许）函数范围的频率。我查阅了它的来源，只找到了一两打使用它的地方。对我来说，这表明，一旦尝试过，即使在允许使用std:：的地方，开发人员也不会觉得每100kLoC使用一次指令就足够痛苦。

一句话：明确地给每件事加上前缀不会造成任何伤害，只需要很少的时间就可以习惯，而且有客观的优势。特别是，它使编译器和人类读者更容易解释代码，这可能是编写代码时的主要目标。

我也认为这是一种糟糕的做法。为什么？就在一天，我认为名称空间的功能是划分内容，所以我不应该将所有内容都放在一个全局包中而破坏它。

然而，如果我经常使用“cout”和“cin”，我会写：使用std:：cout；使用std:：cin；在.cpp文件中（当它使用include传播时，不会在头文件中）。我想，没有一个理智的人会说出一条小溪的名字

不应该在全局范围内使用using指令，尤其是在头中。但是，在某些情况下，即使是在头文件中，也会出现这种情况：

template <typename FloatType> inline
FloatType compute_something(FloatType x)
{
    using namespace std; // No problem since scope is limited
    return exp(x) * (sin(x) - cos(x * 2) + sin(x * 3) - cos(x * 4));
}

这比显式限定（std:：sin，std:：cos…）更好，因为它更短，并且能够处理用户定义的浮点类型（通过依赖于参数的查找（ADL））。

我最近遇到了关于VisualStudio2010的投诉。事实证明，几乎所有的源文件都有这两行：

using namespace std;
using namespace boost;

许多Boost功能将进入C++0x标准，而Visual Studio 2010有许多C++0x功能，因此这些程序突然无法编译。

因此，避免使用名称空间X；是一种未来校对的形式，一种确保对正在使用的库和/或头文件的更改不会破坏程序的方法。

有经验的程序员使用任何解决他们问题的方法，避免任何产生新问题的方法。出于这个确切的原因，他们避免使用头文件级别的指令。

经验丰富的程序员也尽量避免在源文件中使用完全限定的名称。这样做的一个次要原因是，除非有充分的理由，否则在代码较少的情况下编写更多的代码是不优雅的。一个主要原因是关闭参数依赖查找（ADL）。

这些好理由是什么？有时程序员明确希望关闭ADL，有时他们希望消除歧义。

因此，以下内容是可以的：

函数级使用指令并在函数的实现中使用声明使用源文件内声明的源文件级别（有时）使用指令的源文件级别

不要全局使用它

只有在全球范围内使用时，它才被认为是“坏的”。因为：

你把正在编程的命名空间弄得乱七八糟。当您使用许多名称空间xyz；时，读者将很难看到特定标识符的来源；。无论对你的源代码的其他读者来说是什么，对最经常阅读源代码的读者来说更是如此：你自己。一两年后回来看看。。。如果您只讨论使用名称空间std；你可能不知道你抓取的所有内容——当你添加另一个#include或移动到一个新的C++修订版时，你可能会遇到你不知道的名称冲突。

您可以在本地使用

继续，在本地（几乎）自由使用它。当然，这可以防止你重复std:：--，重复也是不好的。

本地使用它的习惯用法

在C++03中，有一种习惯用法——样板代码——用于为类实现交换函数。有人建议您实际使用本地using命名空间std；--或至少使用std:：swap；：

class Thing {
    int    value_;
    Child  child_;
public:
    // ...
    friend void swap(Thing &a, Thing &b);
};
void swap(Thing &a, Thing &b) {
    using namespace std;      // make `std::swap` available
    // swap all members
    swap(a.value_, b.value_); // `std::stwap(int, int)`
    swap(a.child_, b.child_); // `swap(Child&,Child&)` or `std::swap(...)`
}

这有以下魔力：

编译器将为value_选择std:：swap，即void std:：swap（int，int）。如果实现了重载void swap（Child&，Child&），编译器将选择它。如果没有重载，编译器将使用void std:：swap（Child&，Child&），并尽可能地交换这些。

对于C++11，没有理由再使用这种模式了。对std:：swap的实现进行了更改，以找到一个潜在的过载并选择它。

是的，名称空间很重要。在我的项目中，我需要将一个var声明导入到源代码中，但在编译时，它与另一个第三方库冲突。

最后，我不得不用其他方法来解决这个问题，并使代码变得不那么清晰。

对于不合格的导入标识符，您需要像grep这样的外部搜索工具来查找标识符的声明位置。这使得关于程序正确性的推理更加困难。

“为什么在C++中‘使用命名空间std；’被认为是一种糟糕的做法？”

我反过来说：为什么有些人认为额外键入五个字符很麻烦？

例如，考虑编写一个数字软件。当“vector”是问题领域最重要的概念之一时，我为什么还要考虑将通用的“std:：vector”缩减为“vector”来污染我的全局命名空间？

为了回答你的问题，我实际上是这样看的：很多程序员（不是所有人）都调用命名空间std。因此，人们应该养成习惯，不要使用与命名空间std中的名称冲突或使用相同名称的东西。这是一个很大的事实，但与严格来说可能出现的连贯单词和假名的数量相比，这并不是那么多。

我是说真的。。。说“不要依赖于这个存在”只是让你依赖于它不存在。您经常会遇到借用代码片段并不断修复它们的问题。只需将用户定义的和借用的内容保持在有限的范围内，并且非常节省全局变量（老实说，全局变量几乎永远是“现在编译，以后理智”的最后手段）。我真的认为这是你老师的坏建议，因为使用std对“cout”和“std:：cout”都有效，但不使用std只对“std:”cout有效。你不会总是幸运地编写自己的代码。

注意：在真正了解编译器的工作原理之前，不要过于关注效率问题。只要有一点编码经验，在你意识到他们能够将好的代码概括成简单的东西之前，你不必了解他们太多。每一点都很简单，就像你用C语言写了整件事一样。

我同意不应该在全球范围内使用它，但在本地使用它并没有那么糟糕，就像在命名空间中一样。下面是“C++编程语言”中的一个示例：

namespace My_lib {

    using namespace His_lib; // Everything from His_lib
    using namespace Her_lib; // Everything from Her_lib

    using His_lib::String; // Resolve potential clash in favor of His_lib
    using Her_lib::Vector; // Resolve potential clash in favor of Her_lib

}

在本例中，我们解决了由它们的组合引起的潜在名称冲突和歧义。

在那里显式声明的名称（包括通过使用His_lib:：String等声明声明的名称）优先于通过using指令（使用名称空间Her_lib）在另一个作用域中可访问的名称。

我认为本地或全球使用应取决于应用程序。

因为，当我们在本地使用库时，有时代码会变得一团糟。可读性将下降。

因此，只有在可能发生冲突时，我们才应该在本地使用库。

我不是一个更有经验的人。所以，如果我错了，请告诉我。

同时使用多个命名空间显然是一个灾难，但在我看来，使用JUST命名空间std和仅使用命名空间std并不是什么大问题，因为重新定义只能由您自己的代码进行。。。

因此，只需将它们的函数视为保留名称，如“int”或“class”即可。

人们不应该对此如此吹毛求疵。你的老师一直都是对的。只需使用一个名称空间；这就是首先使用名称空间的全部意义。您不应该同时使用多个。除非它是你自己的。因此，再次定义不会发生。

很高兴看到代码并知道它做什么。如果我看到std:：cout，我知道这是std库的cout流。如果我看到cout，我不知道。它可能是std库的cout流。或者有一个int cout=0；在同一函数中高出十行。或该文件中名为cout的静态变量。它可能是任何东西。

现在以一百万行代码库为例，它不是特别大，你正在搜索一个bug，这意味着你知道在这一百万行代码中有一行没有完成它应该做的事情；可以读取名为cout的静态int，将其向左移动一位，然后丢弃结果。要找bug，我必须检查一下。你能看出我真的更喜欢看std:：cout吗？

如果你是一名教师，并且从未以编写和维护代码为生，那么这是一个非常好的主意。我喜欢看到代码：（1）我知道它做什么；而且，（2）我相信写它的人知道它的作用。

我同意其他人的看法——这是在要求名字冲突、歧义，但事实是它不够明确。虽然我可以看到使用的用途，但我个人倾向于限制它。我也会强烈考虑其他人所指出的：

如果你想找到一个可能是一个相当常见的名称的函数名，但你只想在std命名空间中找到它（或者反过来——你想更改所有不在命名空间std、命名空间X…中的调用），那么你打算怎么做？

你可以编写一个程序来完成它，但花时间在项目本身上而不是编写一个维护项目的程序，这不是更好吗？

就我个人而言，我其实并不介意std:：前缀。我更喜欢它的外观而不是没有它。我不知道这是因为它很明确，并对我说“这不是我的代码……我正在使用标准库”，还是因为它是其他东西，但我觉得它看起来更好。这可能很奇怪，因为我最近才接触C++（使用C和其他语言的时间更长，而且C是我一直以来最喜欢的语言，就在汇编语言之上）。

还有一件事，尽管它与上述内容和其他人指出的内容有些关联。虽然这可能是不好的做法，但我有时会为标准库版本保留std:：name，为特定于程序的实现保留名称。是的，这确实会咬你，咬你很厉害，但归根结底，我是从零开始这个项目的，我是唯一的程序员。例如：我重载std:：string并将其称为string。我有一些有用的补充。我之所以这样做，部分原因是我的C和Unix（+Linux）倾向于小写名称。

除此之外，还可以使用命名空间别名。这里是一个可能没有提到的有用的例子。我使用C++11标准，特别是libstdc++。它没有完全的std:：regex支持。当然，它可以编译，但它会抛出一个异常，这是程序员端的错误。但它缺乏实施。

下面是我解决这个问题的方法。安装Boost的正则表达式，并将其链接进来。然后，我执行以下操作，以便在libstdc++完全实现它时，我只需删除这个块，代码保持不变：

namespace std
{
    using boost::regex;
    using boost::regex_error;
    using boost::regex_replace;
    using boost::regex_search;
    using boost::regex_match;
    using boost::smatch;
    namespace regex_constants = boost::regex_constants;
}

我不会争论这是不是个坏主意。然而，我会争辩说，它为我的项目保持了干净，同时又使它变得具体：没错，我必须使用Boost，但我使用它就像libstdc++最终会使用它一样。是的，启动自己的项目并从一开始就使用标准（…）对帮助维护、开发和项目所涉及的一切都有很大的帮助！

只是想澄清一下：我实际上并不认为在STL中使用类名或其他名称来代替它是一个好主意。字符串对我来说是个例外（忽略第一个，上面的，或者这里的第二个，如果必须的话双关语），因为我不喜欢“字符串”这个概念。

事实上，我仍然非常倾向于C和C++。省略细节，我所做的很多工作更适合C（但这是一个很好的练习，也是让自己学会另一种语言的好方法）。不要对对象/类等抱有偏见，这可能更好地表述为不那么封闭、不那么傲慢、更容易接受。）。但有用的是一些人已经提出的建议：我确实使用了列表（它相当通用，不是吗？），并排序（相同的事情）以命名两个，如果我使用名称空间std；，因此，为了达到这个目的，我更喜欢具体、可控，并且知道如果我打算将其作为标准用途，那么我必须指定它。简单地说：不允许假设。

至于让Boost的正则表达式成为标准的一部分。我这样做是为了将来的集成，而且——再次，我完全承认这是偏见——我不认为它像Boost:：正则表达式：：。。。。事实上，这对我来说是另一回事。C++中有很多东西我还没有完全接受，包括外观和方法（另一个例子：varadic模板与var参数[尽管我承认varadic模版非常有用！]）。即使那些我确实接受的人也很困难，我仍然对他们有意见。

短版本：不要在头文件中使用全局using声明或指令。可以在实现文件中使用它们。以下是Herb Sutter和Andrei Alexandrescu在C++编码标准中对这个问题的看法（我用粗体强调）：

总结命名空间using是为了方便您，而不是为了强加给他人：不要在#include指令之前编写using声明或using指令。推论：在头文件中，不要使用指令或声明编写命名空间级别；相反，显式命名空间限定所有名称。（第二条规则与第一条规则相同，因为标头永远无法知道后面可能出现的其他标头#includes。）讨论简而言之：在#include指令之后，你可以也应该在你的实现文件中自由地使用命名空间使用声明和指令，并对此感到满意。尽管重复了相反的断言，但使用命名空间的声明和指令并不是邪恶的，它们不会破坏命名空间的目的。相反，它们使名称空间可用。

一个例子是，使用名称空间std会因为计数的模糊性而引发编译错误，这也是算法库中的一个函数。

#include <iostream>
#include <algorithm>

using namespace std;

int count = 1;
int main() {
    cout << count << endl;
}

我同意这里的其他观点，但我想解决有关可读性的问题——您可以通过在文件、函数或类声明的顶部使用typedef来避免所有这些问题。

我通常在类声明中使用它，因为类中的方法倾向于处理类似的数据类型（成员），typedef是一个在类上下文中分配有意义的名称的机会。这实际上有助于类方法定义的可读性。

// Header
class File
{
   typedef std::vector<std::string> Lines;
   Lines ReadLines();
}

在实施过程中：

// .cpp
Lines File::ReadLines()
{
    Lines lines;
    // Get them...
    return lines;
}

而不是：

// .cpp
vector<string> File::ReadLines()
{
    vector<string> lines;
    // Get them...
    return lines;
}

or:

// .cpp
std::vector<std::string> File::ReadLines()
{
    std::vector<std::string> lines;
    // Get them...
    return lines;
}

命名空间是命名作用域。命名空间用于对相关声明进行分组并保持独立项目分开。例如，两个单独开发的库可以使用相同的名称来表示不同的项，但用户仍然可以同时使用这两个：

namespace Mylib{
    template<class T> class Stack{ /* ... */ };
    // ...
}

namespace Yourlib{
    class Stack{ /* ... */ };
    // ...
}

void f(int max) {
    Mylib::Stack<int> s1(max); // Use my stack
    Yourlib::Stack    s2(max); // Use your stack
    // ...
}

重复名称空间名称可能会分散读者和作者的注意力。因此，有可能声明来自特定命名空间的名称在没有明确限定的情况下可用。例如：

void f(int max) {
    using namespace Mylib; // Make names from Mylib accessible
    Stack<int> s1(max); // Use my stack
    Yourlib::Stack s2(max); // Use your stack
    // ...
}

命名空间为管理不同库和不同版本的代码提供了强大的工具。特别是，它们为程序员提供了如何明确引用非本地名称的备选方案。

来源：C++编程语言概述作者：Bjarne Stroustrup

下面是一个示例，展示了如何使用命名空间std；可能会导致名称冲突问题：

无法在C中定义全局变量++

在本例中，一个非常通用的算法名称（std:：count）与一个非常合理的变量名称（count）冲突。

根据我的经验，如果你有多个库使用cout，但出于不同的目的，你可能会使用错误的cout。

例如，如果我键入，使用名称空间std；并使用命名空间otherlib；如果只键入cout（恰好两者都有），而不是std:：cout（或'otherlib:：cout'），则可能会使用错误的一个，并出现错误。使用std:：cout更有效。

一个具体的例子来澄清这个问题。假设您有两个库，foo和bar，每个库都有自己的名称空间：

namespace foo {
    void a(float) { /* Does something */ }
}

namespace bar {
    ...
}

现在假设您在自己的程序中同时使用foo和bar，如下所示：

using namespace foo;
using namespace bar;

void main() {
    a(42);
}

现在一切都很好。当你运行程序时，它会“做一些事情”。但后来你更新了这个栏，让我们假设它变成了这样：

namespace bar {
    void a(float) { /* Does something completely different */ }
}

此时将出现编译器错误：

using namespace foo;
using namespace bar;

void main() {
    a(42);  // error: call to 'a' is ambiguous, should be foo::a(42)
}

因此，您需要进行一些维护，以澄清“a”是指foo:：a。这是不可取的，但幸运的是它非常容易（只需在编译器标记为不明确的所有调用前面添加foo:：）。

但想象一下另一种情况，酒吧改成了这样：

namespace bar {
    void a(int) { /* Does something completely different */ }
}

此时，您对a（42）的调用突然绑定到bar:：a而不是foo:：a，并且它不做“某事”，而是做“完全不同的事情”。没有编译器警告或任何内容。你的程序只是默默地开始做一些与以前完全不同的事情。

当你使用一个名称空间时，你会面临这样的风险，这就是为什么人们不喜欢使用名称空间的原因。名称空间中的东西越多，冲突的风险就越大，因此与其他名称空间相比，人们可能更不喜欢使用名称空间std（由于该名称空间中有很多东西）。

最终，这是可写性与可靠性/可维护性之间的权衡。可读性也可能是其中的一个因素，但无论哪种方式，我都能看到这样做的理由。通常，我会说可靠性和可维护性更重要，但在这种情况下，您将不断为相当罕见的可靠性/可维护性影响支付可写性成本。“最佳”权衡将决定您的项目和优先级。

这里有一个我在其他答案中都没有找到的观点：只使用一个名称空间。根据大多数答案，命名空间不好的主要原因是，你可能会有冲突的函数名，这会导致一片混乱。但是，如果只使用一个名称空间，则不会发生这种情况。确定您将使用最多的库（可能使用名称空间std；）并坚持使用它。

可以认为它有一个不可见的库前缀-std:：vector变成了vector。在我看来，这是两全其美的：一方面，它减少了必须进行的键入（正如名称空间所预期的那样），另一方面，为了清晰和安全，它仍然需要使用前缀。如果有一个函数或对象没有名称空间前缀，那么您知道它来自您声明的一个名称空间。

请记住，如果您决定在全球范围内使用一个，请不要在本地使用其他。这又回到了其他答案，即本地名称空间通常比全局名称空间更有用，因为它们提供了各种便利。

老实说，对我来说，这就像讨论缩进空间的数量。

在标头中使用指令会导致损坏。但是在C++文件中呢？如果同时使用两个名称空间，可能会发生这种情况。但如果你使用一个，它更多的是风格而不是真正的效率。

你知道为什么关于缩进的线索如此流行吗？任何人都可以说些什么，听起来非常聪明和有经验。

这是一种糟糕的做法，通常被称为全局命名空间污染。当多个名称空间具有相同的函数名和签名时，可能会出现问题，那么编译器决定调用哪个名称空间是不明确的，当您使用std:：cout这样的函数调用指定名称空间时，这一切都可以避免。希望这有帮助。：）

它不会使您的软件或项目性能更差。在源代码开头包含名称空间还不错。using namespace std指令的包含根据您的需求以及开发软件或项目的方式而有所不同。

命名空间std包含C++标准函数和变量。当您经常使用C++标准函数时，这个名称空间非常有用。

如本页所述：使用命名空间std的语句通常被认为是错误的实践此语句的替代方法是指定使用作用域运算符（：：）将标识符所属的命名空间每次我们声明一个类型。请参阅以下意见：在源文件中使用“using namespace std”没有问题当您大量使用命名空间并确信任何东西都不会碰撞。

有些人曾说过，在源文件中包含using命名空间std是一种不好的做法，因为您正在从该命名空间调用所有函数和变量。当您想定义一个与命名空间std中包含的另一个函数同名的新函数时，您会重载该函数，因为编译或执行可能会产生问题。它不会像您期望的那样编译或执行。

如本页所述：尽管该语句使我们不必在任何时候输入std:：我们希望访问std命名空间中定义的类或类型将整个std命名空间导入当前命名空间该计划的一部分。让我们举几个例子来理解为什么可能不是什么好事...现在，在开发的后期阶段，我们希望使用cout是在某个名为“foo”的库中自定义实现的（用于示例）...注意这里有一个歧义，cout指向哪个库？编译器可能会检测到这一点，而不会编译程序。在最坏的情况下在这种情况下，程序仍可能编译，但调用了错误的函数，因为我们从未指定标识符属于哪个命名空间。

这是个案。我们希望在软件的生命周期内最大限度地降低软件的“总拥有成本”。声明“using namespace std”有一定的代价，但不使用它也有易读性的代价。

人们正确地指出，当使用它时，当标准库引入新的符号和定义时，您的代码将停止编译，您可能被迫重命名变量。然而，这可能是一个很好的长期目标，因为如果您出于某种令人惊讶的目的使用关键字，未来的维护人员将暂时感到困惑或分心。

你不希望有一个名为vector的模板，比如说，它不是其他人都知道的向量。因此，C++库中引入的新定义的数量非常少，可能根本找不到。必须进行这种更改是有代价的，但代价并不高，而且通过不将std符号名称用于其他目的而获得的清晰性来抵消。

考虑到类、变量和函数的数量，在每一个上声明std:：可能会使代码出错50%，并使您更难理解。一个算法或方法中的一个步骤可以在一屏代码上执行，现在需要前后滚动才能执行。这是一个真实的成本。可以说，这可能不是一个高成本，但那些否认它存在的人是缺乏经验的、教条的，或者根本就是错误的。

我提供以下规则：

std不同于所有其他库。这是每个人基本上都需要知道的一个库，在我看来，最好将其视为语言的一部分。一般来说，使用命名空间std是一个很好的例子，即使没有其他库。永远不要通过将此using放在头中来迫使编译单元（.cpp文件）的作者做出决定。始终将决定权交给编译单元的作者。即使在一个决定在任何地方使用名称空间std的项目中，也可能会有一些模块作为该规则的例外处理。尽管名称空间功能允许您有许多定义相同符号的模块，但这样做会令人困惑。请尽可能保持名称不同。即使不使用名称空间特性，如果您有一个名为foo的类，并且std引入了一个名foo的类型，那么长期来说重命名您的类可能会更好。使用名称空间的另一种方法是通过前缀手动命名符号。我有两个库，我用了几十年，实际上都是从C库开始的，每个符号的前缀都是“AK”或“SCWin”。一般来说，这就像避免使用“using”构造，但不使用双冒号。AK:：foo（）改为AKFoo（）。它使代码更密集5-10%，更不冗长，唯一的缺点是，如果必须使用两个具有相同前缀的这样的库，则会遇到很大的麻烦。注意，X Window库在这方面非常出色，只是它们忘记了使用一些#定义：TRUE和FALSE应该是XTRUE和XFALSE，这与Sybase或Oracle产生了命名空间冲突，它们同样使用了TRUE和FALSE，但值不同！（在数据库的情况下为ASCII 0和1！）这样做的一个特殊优点是，它似乎适用于预处理器定义，而C++使用/命名空间系统不处理它们。这样做的一个好处是，它提供了从项目的一部分到最终成为图书馆的有机坡度。在我的一个大型应用程序中，所有的窗口类都以Win为前缀，所有的信号处理模块都以Mod为前缀等等。这些模块中的任何一个都不太可能被重用，因此将每个组放入一个库中没有实际的好处，但几秒钟后就可以看出项目是如何分解为子项目的。

有一个非常简单的答案：这是防御性编程。您知道，使用名称空间std；-可以使std:：size_t、std:：cout等的使用更容易一些我希望您不必相信这样的指令在标题中没有位置！然而，在翻译单元中，您可能会受到诱惑。。。

作为std命名空间一部分的类型、类等随着每次C++修订而增加。如果放松std:：限定符，可能会有太多的歧义。放松std中经常使用的名称的限定符是完全合理的，例如，使用std:：fprintf；，或者更可能的是：使用std:：size_t；-但是，除非这些已经是语言的很好理解的部分（或者特别是C库的std包装），否则只使用限定符。

当您可以使用typedef并结合自动和decltype推理时，从可读性/可维护性的角度来看，实际上没有什么好处。

#include <iostream>

using namespace std;

int main() {
  // There used to be
  // int left, right;
  // But not anymore

  if (left != right)
    std::cout << "Excuse me, WHAT?!\n";
}

那么，为什么？因为它引入了与常用变量名重叠的标识符，并允许编译此代码，将其解释为if（std:：left！=std:：right）。

PVS Studio可以使用V1058诊断程序找到这样的错误：https://godbolt.org/z/YZTwhp（谢谢Andrey Karpov！！）。

Ping cppcheck开发人员：您可能希望标记此项。这是一场灾难。

命名空间是为了避免命名冲突。C++基于C，C在函数和变量名方面有很多问题，因为有时来自不同库的函数会发生冲突。因此，库开发人员开始在其函数前面加上库名，如下所示：

foo/foo.h：

void libfoo_foo_foo_h_open(); // the name can be weird then even this one!

C++引入了名称空间，以一种简单的方式解决了这个问题。

假设您有两个名为file和window的库，分别处理文件和窗口，代码如下：

#include <file.h>
#include <window.h>

using namespace file;
using namespace window;

void open() {
     ...
}

文件.h：

namespace file {
    void open(); // What!
}

window.h：

namespace window {
    void open(); // Oh no!
}

上面的代码肯定无法编译。

如果你不喜欢键入std:：（只有5个字符），你可以一直这样做：（在头文件中不是个好主意）

using s = std;

如果您仍然想使用名称空间std；在您的源文件中，那么您正在引发这个问题，我必须问您“NAMESPACE的目的是什么？”。

为什么使用命名空间标准？

C++有一个标准库，其中包含构建应用程序时使用的常用功能，如容器、算法等。如果这些库使用的名称是公开的，例如，如果它们全局定义了一个队列类，那么您将无法再次使用相同的名称而不发生冲突。因此，他们创建了一个名称空间std来包含此更改。

不使用的原因1：不良行为

使用命名空间std的语句通常被认为是错误的做法。此语句的另一种方法是在每次声明类型时使用作用域运算符（：：）指定标识符所属的命名空间。尽管该语句避免了我们在任何时候希望访问std命名空间中定义的类或类型时键入std:：，但它将整个std命名空间导入到程序的当前命名空间中。

不使用的原因2：编译器变得混乱

在玩具程序中导入整个std库是可以的，但在生产级代码中，这是不好的。使用命名空间std；使命名空间std中声明的每个符号都可以在没有命名空间限定符的情况下访问。

例如：

现在，假设您升级到一个较新版本的C++，并将更多新的std命名空间符号注入到您不知道的程序中。您的程序中可能已经使用了这些符号。现在编译器将很难弄清楚声明的符号是属于您自己的实现，还是来自您在没有任何概念的情况下导入的名称空间。一些编译器会抛出错误。如果运气不好，编译器选择了错误的实现并编译它，这肯定会导致运行时崩溃。

命名空间污染影响：

虽然这种做法对于示例代码来说是可以的，但将整个std命名空间拉入全局命名空间是不好的，因为它会破坏命名空间的目的，并可能导致名称冲突。这种情况称为命名空间污染。

只要在头文件中不使用“using namespace std”，这应该是完全正常的。

如果与say boost有命名冲突，那么在特定的.cpp文件中不使用此语句，但通过在其他文件中的每一行上不重复“std:：”十次，仍然可以保存每个人的眼睛和手指。

不幸的是，现在这是一个纯粹的宗教问题，每个人都更容易/更有效地遵循一遍又一遍重复“std:：”的既定模式。