blocks|key|1255756|text|这并不违反规则，因为您定义了两个不同的变量。它们具有相同的名称，但在不同的作用域中声明，独立的实体也是如此。每个定义都有一个定义。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1255757|函数作用域中的声明被称为隐藏全局命名空间中的声明。在函数中，非限定名a引用局部变量，而限定名::a引用全局变量。|offset|length|style|CODE|1255758|entityMap^0|0|Y|1|1A|3|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]|$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|I|$]]

This doesn't break the rule because you define two different variables. They have the same name, but are declared in different scopes, and so are separate entities. Each has a single definition.

The declaration in the function's scope is said to hide the one in the global namespace. Within the function, the unqualified name <code>a</code> refers to the local variable, while the qualified name <code>::a</code> refers to the global.

blocks|key|1255968|text|它们不违反ODR，因为它们具有不同的范围。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1255969|第一个a具有全局范围。|offset|length|style|CODE|1255970|具有全局作用域(也称为文件范围)的变量在文件的定义点之后在整个文件中都是已知的。
|blockquote|1255971|1255972|第二个a具有局部范围。|1255973|一个具有局部作用域(也称为块作用域)的变量只在定义它的块中已知。
|1255974|1255975|为了更清楚地了解C%2B%2B的ODR，您应该研究的概念是:存储持续时间、范围和链接|1255976|entityMap^0|0|3|1|0|0|0|3|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|Y|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|10|8|@$D|11|E|12|F|G]]|9|@]|A|$]]|$1|N|3|O|5|J|7|13|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|15|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|T|$]]

They do not violate the ODR because they have different scope.

The first <code>a</code> has global scope 

<blockquote>
 A variable that has global scope (also termed file scope) is known
 throughout the file after the point where it is defined
</blockquote>

The second <code>a</code> has local scope

<blockquote>
 A variable that has local scope (also termed block scope) is known
 only within the block in which it is defined
</blockquote>

For understand more clear about ODR of C++ the concepts you should investigate are: Storage Duration, Scope, and Linkage

blocks|key|1255763|text|您没有再次定义a。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1255764|您刚刚定义了一个新变量a。它只在函数中具有作用域，与原始作用域(它具有全局范围)无关，并且在函数中隐藏原始作用域。|1255765|entityMap^0|7|1|0|B|1|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|$]]

You did not define <code>a</code> again. 

You just defined a new variable <code>a</code>. It has the scope only inside the function, and has nothing to do with the original one(which has a global scope), and shadowed the original one inside the function.

blocks|key|323837|text|你能解释一下ODR的实际工作原理吗？
|type|blockquote|depth|inlineStyleRanges|entityRanges|data|323838|unstyled|323839|以下是违反网上解决的一个例子：|323840|/*+file+:+module.cpp+*/
#include+<stdio.h>
inline+int+foo()+{
++++printf("module.foo:+%25p\n",+&foo);
++++return+1;
}++++++++
static+int+bar+=+foo();

/*+file+:+main.cpp+*/
#include+<stdio.h>
inline+int+foo()+{
++++printf("main.foo:+%25p\n",+&foo);
++++return+2;
}
int+main(int+argc,+char+*argv[])+{
++++return+foo();
}|code-block|syntax|javascript|323841|如您所见，函数int+foo()在两个模块中定义不同。现在请注意，它如何根据请求的优化级别(O3+vs+O0)产生不同的行为：|offset|length|style|CODE|BOLD|323842|$+clang%2B%2B+--std=c%2B%2B11+-O0+main.cpp+module.cpp+&&+./a.out+
module.foo:+0x100a4aef0
module.foo:+0x100a4aef0

$+clang%2B%2B+--std=c%2B%2B11+-O3+main.cpp+module.cpp+&&+./a.out+
module.foo:+0x101146ee0
main.foo:+0x101146ee0|323843|输出是不同的，因为对于内联函数，编译器在每个编译模块中生成一个链接器符号。这个符号(在每个编译模块中)被标记为“选取任意一个，它们都是相同的”。在第一种情况下，当禁用所有优化时，链接器将从module.cpp获取定义。在第二种情况下，编译器只是插入两个函数，因此不需要链接器的额外工作。|323844|当违反ODR会产生奇怪的行为时，还有其他的例子。所以，不要这样做:)|323845|P.S.奖金，来自现实生活的案例：|323846|/*+a.cpp+*/
struct+Rect
{
++++int+x,y,w,h;
++++Rect():+x(0),y(0),w(0),h(0)
};
/*+b.cpp+*/
struct+Rect
{
++++double+x,y,w,h;
++++Rect():+x(0),y(0),w(0),h(0)
};|323847|这里的问题与前面的示例相同(因为Rect构造函数是隐式内联的)。取决于moon编译器选择一个或另一个实现的阶段，会产生奇怪的结果(int版本将使doubles的一部分未初始化，double版本将超出int的范围并损坏内存)。防止这种情况的好方法是使用匿名命名空间(C%2B%2B)或将结构声明为static+(C)：|323848|/*+file.cpp+*/
namespace+{
++++struct+Rect+{+...+};
}
/*+file.c+*/
static+struct+Rect+{+...+};|323849|entityMap^0|0|0|0|0|7|9|1A|2|1G|2|0|0|0|0|0|0|1T|3|20|7|2G|6|2R|3|3Z|6|0|0^^$0|@$1|2|3|4|5|6|7|17|8|@]|9|@]|A|$]]|$1|B|3|-4|5|C|7|18|8|@]|9|@]|A|$]]|$1|D|3|E|5|C|7|19|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|1A|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|C|7|1B|8|@$M|1C|N|1D|O|P]|$M|1E|N|1F|O|Q]|$M|1G|N|1H|O|Q]]|9|@]|A|$]]|$1|R|3|S|5|H|7|1I|8|@]|9|@]|A|$I|J]]|$1|T|3|U|5|C|7|1J|8|@]|9|@]|A|$]]|$1|V|3|W|5|C|7|1K|8|@]|9|@]|A|$]]|$1|X|3|Y|5|C|7|1L|8|@]|9|@]|A|$]]|$1|Z|3|10|5|H|7|1M|8|@]|9|@]|A|$I|J]]|$1|11|3|12|5|C|7|1N|8|@$M|1O|N|1P|O|P]|$M|1Q|N|1R|O|P]|$M|1S|N|1T|O|P]|$M|1U|N|1V|O|P]|$M|1W|N|1X|O|P]]|9|@]|A|$]]|$1|13|3|14|5|H|7|1Y|8|@]|9|@]|A|$I|J]]|$1|15|3|-4|5|C|7|1Z|8|@]|9|@]|A|$]]]|16|$]]

<blockquote>
 Can you explain me how ODR does work actually?
</blockquote>

Here is an example of violation of ODR:

<pre><code>/* file : module.cpp */
#include &lt;stdio.h&gt;
inline int foo() {
 printf("module.foo: %p\n", &amp;foo);
 return 1;
} 
static int bar = foo();

/* file : main.cpp */
#include &lt;stdio.h&gt;
inline int foo() {
 printf("main.foo: %p\n", &amp;foo);
 return 2;
}
int main(int argc, char *argv[]) {
 return foo();
}
</code></pre>

As you can see, function <code>int foo()</code> defined differently in two modules. Now observe, how it produces different behavior depending on requested optimization level (O3 vs O0):

<pre><code>$ clang++ --std=c++11 -O0 main.cpp module.cpp &amp;&amp; ./a.out 
module.foo: 0x100a4aef0
module.foo: 0x100a4aef0

$ clang++ --std=c++11 -O3 main.cpp module.cpp &amp;&amp; ./a.out 
module.foo: 0x101146ee0
main.foo: 0x101146ee0
</code></pre>

Output is different, because for inline functions compiler produces a linker symbol in each compilation module. This symbol (in each compilation module) is marked as "pick any, they are all the same". In the first case, when all optimizations are disabled, linker picks up definition from module.cpp. In the second case, compiler just inlines both functions so no additional work from linker is required.

There are other examples when violation of ODR produces weird behavior. So, don't do it :)

P.S. Bonus, case from real life:

<pre><code>/* a.cpp */
struct Rect
{
 int x,y,w,h;
 Rect(): x(0),y(0),w(0),h(0)
};
/* b.cpp */
struct Rect
{
 double x,y,w,h;
 Rect(): x(0),y(0),w(0),h(0)
};
</code></pre>

The problem here is the same as in previous example (because Rect constructors are implicitly inline). Depending on phase of the moon compiler was picking one implementation or another producing strange results (<code>int</code> version will leave part of <code>doubles</code> uninitialized, <code>double</code> version will go outside of <code>int</code>s and corrupt memory there). Good way to protect from that is to use anonymous namespaces (C++) or declare struct as <code>static</code> (C):

<pre><code>/* file.cpp */
namespace {
 struct Rect { ... };
}
/* file.c */
static struct Rect { ... };
</code></pre>

According to the c++ standard:

<blockquote>
 No translation unit shall contain more than one definition of any
 variable, function, class type, enumeration type, or template.
</blockquote>

<pre><code>//--translation_unit.cpp--//
int a;

void foo()
{
 int a; //Second defention of a. ODR fails.
}
</code></pre>

Can you explain me how ODR does work actually?

One definition rule in c++

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

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

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

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

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

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

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

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

根据c++标准：任何转换单元都不得包含任何变量、函数、类类型、枚举类型或模板的多个定义。//--translation_unit.cpp--//int a;void foo(){    int a; //Second defention of a. ODR fails.}你能解释一下ODR的实际工作原理吗？

问c++中的一个定义规则
EN

回答 4

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问c++中的一个定义规则EN

回答 4

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问c++中的一个定义规则
EN