blocks|key|1898122|text|我更喜欢使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1898123|using+std::string;
string+whatever;|code-block|syntax|javascript|1898124|而不是完全引入名称空间。|1898125|在任何情况下，库开发人员都应该避免与标准名称冲突的类型名称，尽管string可能非常常见。|offset|length|style|CODE|1898126|对于非标准的库，我喜欢限定嵌套名称空间是否太长，如果只是类型定义，则将其定义为包含库名称或类似名称的有意义的名称。|1898127|entityMap^0|0|0|0|W|6|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|V|8|@$K|W|L|X|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

I'd prefer using:

<pre><code>using std::string;
string whatever;
</code></pre>

than fully bringing the namespace in.

In any case library developers should avoid type names that conflict with the standard ones although <code>string</code> probably is quite common.

For libraries other than standard I like to qualify if the nesting namespaces is not too long, if it is just typedef it to a meaningful name that includes the library name or something like that.

blocks|key|2066505|text|通常，在处理头文件时，我会完全限定名称空间，而不是主要使用using+namespace+x。源文件可能不希望使用该名称空间，也不应该强制包含头文件的源文件使用该名称空间。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2066506|我同时执行using+namespace+x和完全限定名称空间，这取决于我个人判断我是否会在源文件中多次重用该类型。|2066507|entityMap^0|T|H|0|5|H|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

Generally I will fully qualify namespaces instead of using <code>using namespace x</code> mostly when I deal with header files. Source files may not want to have that namespace assumed and you shouldn't force it on the source files that include your header file.

I do both <code>using namespace x</code> and fully qualify namespaces depending on a personal judgement call about if I will re-use the type multiple times or not in source files.

blocks|key|595387|text|在头文件中完全限定。在.cpp文件中导入名称空间。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|595388|使全局名称空间不会被简单的#include弄乱|595389|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

fully qualify in header files. import the namespace in the .cpp files.

keeps the global namespace from being cluttered by a simple #include

blocks|key|658623|text|引入namespace基本上是为了最小化符号名称(如函数、类和变量)的冲突。只使用string而不使用std::string是可以的，除非您自己的库在自己的空间中有string。我实际上并没有使用像std这样非常常见的名称空间。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|658624|entityMap^0|2|9|15|6|1F|B|2A|6|2R|3|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|G|$]]

<code>namespace</code> is basically introduced to minimize conflicts symbol names such as function, class, and variables. It is okay that you just use <code>string</code> than <code>std::string</code> unless your own library has <code>string</code> in its own space. I'm virtually not using very common namespace like <code>std</code>.

blocks|key|658656|text|完全主观的问题:我认为只使用字符串是可以接受的。IDE/编译器足够聪明，能够理解你的意思。如果您有同名的对象，例如2个字符串类型。然后你就会有一个不同的问题，因为编译器不会知道你的意思，而编码器也不会知道你的意思。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|658657|不使用库名称的另一个原因是因为代码混乱:在C#中，system.xml.xmltextreader只是夸大其词。XmlTextReader足以理解它是什么。它在哪里几乎从来都不是问题|658658|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Totally subjective question:
I would say acceptable to just use string. IDE/compiler are clever enough to find out what you mean. If you have objects with the same name, for example 2 string types. Then you have a different problem because the compiler won't know what you mean AND the coder won't know what you mean.

Other reason to not use library names is because of cluttering the code:
In C# system.xml.xmltextreader is just overkill. XmlTextReader is enough to under stand what it is. Where it's located is almost never the issue

blocks|key|595458|text|我确实倾向于遵守两条规则：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|595459|595460|在头文件中，你希望用完整的命名空间来限定类型名称，并且永远不会想要放入像using+namespace+std;这样的东西，因为这可能/将会导致有趣的问题，因为你将需要在凌晨1点跟踪意外的命名冲突。|unordered-list-item|offset|length|style|CODE|595461|在实现文件中，我确实倾向于使用using+std::string;或类似的方法从其他命名空间中拉入我使用的符号。实际上，我并不是100%25同意这一点，因为我经常不引入std命名空间，但确实引入了项目命名空间，但这是我个人的偏好。但是，永远不要把using+namespace+somethingorother;置于任何#include之上。|595462|595463|entityMap^0|0|0|10|K|0|F|I|3D|X|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|P|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|Q|8|@$F|R|G|S|H|I]]|9|@]|A|$]]|$1|J|3|K|5|E|7|T|8|@$F|U|G|V|H|I]|$F|W|G|X|H|I]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|N|$]]

I do tend to adhere to two rules:

<ul>
<li>In header files, you want to qualify type names with the full namespace and never, ever want to put something like <code>using namespace std;</code> as this can/will cause interesting problems due to unexpected naming conflicts that you will need to track down at 1am.</li>
<li>In implementation files, I do tend to pull in symbols I use from other namespaces using <code>using std::string;</code> or similar. Actually, I'm not a 100% consistent with this as I often don't pull in the std namespace, but do pull in the project namespaces but that's personal preference. Never, ever put <code>using namespace somethingorother;</code> above any #include, though.</li>
</ul>

blocks|key|1898245|text|一般而言，我倾向于(1)使用像using+std::string;+string+hello;这样的指令；(2)我也使用匿名名称空间，随后使用using+namespace指令将所有名称导入到我的匿名名称空间中，如下面的namespace+{+using+namespace+std;+//+or+using+std::string+string+blah_blah_blah;+}|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1898246|entityMap^0|F|W|32|29|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

In general, i'd prefer (1) to using directive like <code>using std::string; string hello;</code> as what Jimenez noted previously; (2) i also use a anonymous namespace, subsequently use the using namespace directive to import all names into my anonymous namespace like this 
<code>namespace {
using namespace std; // or using std::string
string blah_blah_blah;
}</code>

blocks|key|595494|text|就其价值而言，通过使用using指令拉取名称空间可以做一些不能通过限定名称来做的事情。典型的例子可能是编写一个泛型排序函数。如果已经为要排序的类型定义了swap，则希望使用该类型，但如果它没有自己的swap，则需要使用std::swap。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|595495|要实现这一点，您可以编写如下代码：|595496|using+namespace+std;
//+...
template+<class+T>
void+my_sort(std::vector<T>+&x)+{
++++//+...
++++if+(x[j]+<+x[k])
++++++++swap(x[j],+x[k]);|code-block|syntax|javascript|595497|你也可以有更多的选择：|595498|template+<class+T>
void+my_sort(std::vector<T>+&x)+{

++++using+std::swap;

++++if+(x[j]+<+x[k])
++++++++swap(x[j],+x[k]);|595499|无论哪种方式，如果在名称空间中存在正在排序的任何类型的swap，都可以通过参数相关查找找到它。如果没有，则会找到std::swap，因为您已经使用using指令/using声明使其可见。在任何情况下，使用完全限定名称都不会实现通常被认为是最理想的行为。|595500|entityMap^0|24|4|2R|4|31|9|0|0|0|0|0|R|4|1K|9|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|13|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|14|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|T|$]]

Just for what it's worth, there are a few things you can do by pulling a namespace with a using directive that you can't do by qualifying names. The canonical example is probably writing a generic sort function. If a <code>swap</code> has been defined for the type being sorted, you want to use that, but if it doesn't have a <code>swap</code> of its own, you want to use <code>std::swap</code>.

To accomplish this, you can write your code like:

<pre><code>using namespace std;
// ...
template &lt;class T&gt;
void my_sort(std::vector&lt;T&gt; &amp;x) {
 // ...
 if (x[j] &lt; x[k])
 swap(x[j], x[k]);
</code></pre>

You can also be more selective:

<pre><code>template &lt;class T&gt;
void my_sort(std::vector&lt;T&gt; &amp;x) {

 using std::swap;

 if (x[j] &lt; x[k])
 swap(x[j], x[k]);
</code></pre>

Either way, if there's a <code>swap</code> in the namespace of whatever type is being sorted, it'll be found by argument dependent lookup. If there's not, <code>std::swap</code> will be found because you've made it visible with the using directive/using declaration. In any any case, using a fully-qualified name will not accomplish what's generally considered the most desirable behavior.

blocks|key|1898286|text|整个要点应该是避免混淆并生成清晰的代码。在某些情况下，省略命名空间可能会混淆函数或类的来源，但添加总是完整的命名空间可能会变得无法忍受。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1898287|1898288|避免在头文件中使用using+namespace+|unordered-list-item|offset|length|style|CODE|1898289|在源代码中使用using+namespace表示“显而易见的”库(例如std或要在测试程序中测试的库)|1898290|您可以在源代码中为名称空间添加别名，以保持其简短和可读性：<代码>H29<代码>F210|1898291|1898292|示例|1898293|namespace+fs+=+boost::filesystem;
bool+fileExists+=+fs::exists(fs::path(filePath));|code-block|syntax|javascript|1898294|编辑，为了完整性:头文件中的using+namespace以一种不明显的方式污染了带有导入的命名空间的源文件(在这个线程中已经有了对此的解释)。|1898295|entityMap^0|0|0|9|F|0|7|F|Z|3|0|0|0|0|0|E|F|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|11|8|@$F|12|G|13|H|I]]|9|@]|A|$]]|$1|J|3|K|5|E|7|14|8|@$F|15|G|16|H|I]|$F|17|G|18|H|I]]|9|@]|A|$]]|$1|L|3|M|5|E|7|19|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1B|8|@]|9|@]|A|$]]|$1|Q|3|R|5|S|7|1C|8|@]|9|@]|A|$T|U]]|$1|V|3|W|5|6|7|1D|8|@$F|1E|G|1F|H|I]]|9|@]|A|$]]|$1|X|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|Y|$]]

The whole point should be to avoid confusion and generate clear code.
Omitting namespaces can in some cases obfuscate the origin of a function or class, but adding always full namespaces can become unbearable.

<ul>
<li>Avoid <code>using namespace</code> in header files</li>
<li>Use <code>using namespace</code> in source for "obvious" libraries (e.g. <code>std</code>, or the library to test in a test program)</li>
<li>You can alias namespaces in your source to keep it short and readable:</li>
</ul>

Example

<pre><code>namespace fs = boost::filesystem;
bool fileExists = fs::exists(fs::path(filePath));
</code></pre>

EDIT, for completeness:
<code>using namespace</code> in header files pollutes source files with imported namepaces in a non-obvious way ('nuf explanations of this already in this thread).

blocks|key|2066868|text|我总是完全限定在头文件中。我从来不把“使用...”头中的语句。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2066869|我的偏好是在实现文件中也完全限定，但是，如果组织标准是合并“使用...”实现文件中的语句我将这样做，|2066870|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I always fully qualify within headers. I never put "using..." statements in headers.

My preference is to fully qualify in implementation files as well, however if the organization standard is to incorporate "using..." statements within the implementation files I will do so,

blocks|key|2066949|text|如果您不完全符合条件，那么在将内联方法从头文件移动到CPP文件或反之亦然时，您将遇到很大的麻烦，并且您肯定希望在您的项目中使用一种样式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2066950|否则这是没有问题的，尽管存在using语句，但有时我还是符合条件的。在头文件中，这是一个问题，除非它在作用域内：|2066951|//+somefile.h
namespace+VisionMap
{
+++++namespace+X
+++++{
+++++++++using+namespace+Y;+++//+Does+not+impact+the+header's+user,+
++++++++++++++++++++++++++++++//+as+would+if+it+was+in+the+global+scope.
+++++}
}|code-block|syntax|javascript|2066952|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

If you do not fully qualify, you will have great hassle when moving inline methods from headers to CPP files or vice versa, and you definitely want one style across your projects.

Otherwise it's no problem, sometimes I qualify despite existing using statement. In headers it is a problem, Unless it is within scope:

<pre><code>// somefile.h
namespace VisionMap
{
 namespace X
 {
 using namespace Y; // Does not impact the header's user, 
 // as would if it was in the global scope.
 }
}
</code></pre>

What is generally considered good coding style in C++ where you use types from the standard library? For example, if I have a <code>using namespace std;</code> directive would you still expect to see library types fully qualified like so: <code>std::string</code> or is it acceptable to just use <code>string</code> as the type identifier?

If you do fully qualify, can you expain the rationale behind it?

C++ good coding style - always fully qualify library types?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在使用标准库中的类型的C++中，什么是通常被认为是好的编码风格？例如，如果我有一个using namespace std;指令，您是否仍然希望看到库类型完全限定为：std::string，或者只使用string作为类型标识符是否可以接受？如果你真的完全符合条件，你能解释一下背后的理由吗？

问C++良好的编码风格-总是完全限定库类型？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++良好的编码风格-总是完全限定库类型？EN