blocks|key|488542|text|它将变量的范围限制在{+}内的块上。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|488543|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

It limits the scope of variables to the block inside the { }.

blocks|key|2021447|text|据我所知，它们只是为了界定范围。它们允许您在父/兄弟关系范围中重用变量名，这有时会很有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2021448|编辑:这个问题实际上已经在另一个堆栈溢出问题上得到了回答。希望这能有所帮助。|offset|length|2021449|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/85282/what-is-the-value-of-an-anonymous-unattached-block-in-c^0|0|D|9|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

As far as I understand, they are simply for scoping. They allow you to reuse variable names in the parent/sibling scopes, which can be useful from time to time.

EDIT: This question has in fact been answered on <a href="https://stackoverflow.com/questions/85282/what-is-the-value-of-an-anonymous-unattached-block-in-c">another Stack Overflow question</a>. Hope that helps.

blocks|key|488597|text|它们经常用于限定变量的范围，因此变量是由大括号定义的任意块的局部变量。在您的示例中，变量i和k在其封闭大括号之外是不可访问的，因此它们不能以任何鬼鬼祟祟的方式被修改，并且这些变量名可以在代码的其他地方重用。使用大括号创建这样的本地作用域的另一个好处是，在具有垃圾收集的语言中，垃圾收集器知道清理范围外的变量是安全的。这在C/C%2B%2B中是不可用的，但我认为它应该在C#中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|488598|一种简单的思考方法是，大括号定义了一个原子代码段，类似于名称空间、函数或方法，但不需要实际创建名称空间、函数或方法。|488599|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|$]]

They're very often used for scoping variables, so that variables are local to an arbitrary block defined by the braces. In your example, the variables i and k aren't accessible outside of their enclosing braces so they can't be modified in any sneaky ways, and that those variable names can be re-used elsewhere in your code. Another benefit to using braces to create local scope like this is that in languages with garbage collection, the garbage collector knows that it's safe to clean up out-of-scope variables. That's not available in C/C++, but I believe that it should be in C#.

One simple way to think about it is that the braces define an atomic piece of code, kind of like a namespace, function or method, but without having to actually create a namespace, function or method.

blocks|key|2021491|text|括号指定范围范围-括号内声明的任何内容在括号之外都是看不见的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2021492|此外，在C%2B%2B中，在堆栈上分配的对象(例如，不使用'new')将在超出作用域时被销毁。|2021493|在某些情况下，它也可以是一种方式，突出某项功能的某一特定部分，作者认为值得关注的人看源。这是否是一个好的用途是值得商榷的，但我已经看到它做到了。|2021494|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Brackets designate an area of scope - anything declared within the brackets is invisible outside of them.

Furthermore, in C++ an object allocated on the stack (e.g. without the use of 'new') will be destructed when it goes out of scope.

In some cases it can also be a way to highlight a particular piece of a function that the author feels is worthy of attention for people looking at the source. Whether this is a good use or not is debatable, but I have seen it done.

blocks|key|488752|text|{+...+}打开了一个新的范围|type|blockquote|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|488753|在C%2B%2B中，您可以这样使用它们：|unstyled|488754|void+function()+{
++++//+...
++++{
++++++++//+lock+some+mutex.
++++++++mutex_locker+lock(m_mutex);
++++++++//+...
++++}
++++//+...
}|code-block|syntax|javascript|488755|一旦控制走出块，互斥锁就被摧毁。在它的析构函数中，它会自动解锁它连接到的互斥体。这很常见，被称为RAII+(资源获取是初始化)和SBRM+(范围绑定资源管理)。另一个常见的应用程序是分配内存，然后在析构函数中释放该内存。|488756|另一个目的是做几件类似的事情：|488757|void+function()+{
++++//+set+up+timer+A
++++{
++++++++int+config+=+get_config(TIMER_A);
++++++++//+...+
++++}+

++++//+set+up+timer+B
++++{
++++++++int+config+=+get_config(TIMER_B);
++++++++//+...
++++}+
}|488758|它将保持事物的分离，这样我们就可以很容易地找到不同的构建块。您可以使用具有相同名称的变量，就像上面的代码所做的那样，因为它们在其作用域之外是不可见的，因此它们之间没有冲突。|488759|entityMap^0|0|7|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|10|8|@]|D|@]|E|$]]|$1|I|3|J|5|K|7|11|8|@]|D|@]|E|$L|M]]|$1|N|3|O|5|H|7|12|8|@]|D|@]|E|$]]|$1|P|3|Q|5|H|7|13|8|@]|D|@]|E|$]]|$1|R|3|S|5|K|7|14|8|@]|D|@]|E|$L|M]]|$1|T|3|U|5|H|7|15|8|@]|D|@]|E|$]]|$1|V|3|-4|5|H|7|16|8|@]|D|@]|E|$]]]|W|$]]

<blockquote>
 <code>{ ... }</code> opens up a new scope
</blockquote>

In C++, you can use them like this:

<pre><code>void function() {
 // ...
 {
 // lock some mutex.
 mutex_locker lock(m_mutex);
 // ...
 }
 // ...
}
</code></pre>

Once control goes out of the block, the mutex locker is destroyed. And in its destructor, it would automatically unlock the mutex that it's connected to. That's very often done, and is called RAII (resource acquisition is initialization) and also SBRM (scope bound resource management). Another common application is to allocate memory, and then in the destructor free that memory again.

Another purpose is to do several similar things:

<pre><code>void function() {
 // set up timer A
 {
 int config = get_config(TIMER_A);
 // ... 
 } 

 // set up timer B
 {
 int config = get_config(TIMER_B);
 // ...
 } 
}
</code></pre>

It will keep things separate so one can easily find out the different building blocks. You may use variables having the same name, like the code does above, because they are not visible outside their scope, thus they do not conflict with each other.

blocks|key|777350|text|你在做两件事。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|777351|您正在强制对该块中的变量进行范围限制。|ordered-list-item|777352|您正在启用同级代码块使用相同的变量名。|777353|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|K|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|L|8|@]|9|@]|A|$]]]|H|$]]

You are doing two things.

<ol>
<li>You are forcing a scope restriction on the variables in that block.</li>
<li>You are enabling sibling code blocks to use the same variable names.</li>
</ol>

blocks|key|777358|text|它是关于范围的，它指的是程序的一个部分和另一个部分中变量和方法的可见性，请考虑下面的示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|777359|int+a=25;
int+b=30;
{+//at+this+point,+a=25,+b=30
+++++a*=2;+//a=50,+b=30
+++++b+/=+2;+//a=50,b=15
+++++int+a+=+b*b;+//a=225,b=15++<---+this+new+a+it's
++++++++++++++++++//+++++++++++++++++declared+on+the+inner+scope
}
//a+=+50,+b+=+15|code-block|syntax|javascript|777360|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

It's about the scope, it refers to the visibility of variables and methods in one part of a program to another part of that program, consider this example:

<pre><code>int a=25;
int b=30;
{ //at this point, a=25, b=30
 a*=2; //a=50, b=30
 b /= 2; //a=50,b=15
 int a = b*b; //a=225,b=15 &lt;--- this new a it's
 // declared on the inner scope
}
//a = 50, b = 15
</code></pre>

blocks|key|2021634|text|它们通常用于雷伊目的，这意味着当对象超出作用域时，给定的资源将被释放。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2021635|void+function()
{
++++{
++++++++std::ofstream+out(+"file.txt"+);
++++++++out+<<+"some+data\n";
++++}
++++//+You+can+be+sure+that+"out"+is+closed+here
}|code-block|syntax|javascript|2021636|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Resource_acquisition_is_initialization^0|6|2|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

They are often useful for <a href="http://en.wikipedia.org/wiki/Resource_acquisition_is_initialization" rel="noreferrer">RAII</a> purposes, which means that a given resource will be released when the object goes out of scope. For example:

<pre><code>void function()
{
 {
 std::ofstream out( "file.txt" );
 out &lt;&lt; "some data\n";
 }
 // You can be sure that "out" is closed here
}
</code></pre>

blocks|key|488822|text|正如前面的海报所提到的，它将变量的使用限制在声明变量的范围内。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|488823|在垃圾收集语言(如C#和Java+)中，它还允许垃圾收集器回收作用域中使用的任何变量所使用的内存(尽管将变量设置为null将产生相同的效果)。|488824|{
++++int[]+myArray+=+new+int[1000];
++++...+//+Do+some+work
}
//+The+garbage+collector+can+now+reclaim+the+memory+used+by+myArray|code-block|syntax|javascript|488825|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|$]]

As the previous posters mentioned, it limits the use of a variable to the scope in which it is declared.

In garbage collected languages such as C# and Java, it also allows the garbage collector to reclaim memory used by any variables used within the scope (although setting the variables to null would have the same effect).

<pre><code>{
 int[] myArray = new int[1000];
 ... // Do some work
}
// The garbage collector can now reclaim the memory used by myArray
</code></pre>

blocks|key|2021674|text|class+ExpensiveObject+{
public:
++++ExpensiveObject()+{
++++++++//+acquire+a+resource
++++}
++++~ExpensiveObject()+{
++++++++//+release+the+resource
++++}
}

int+main()+{
++++//+some+initial+processing
++++{
++++++++ExpensiveObject+obj;
++++++++//+do+some+expensive+stuff+with+the+obj
++++}+//+don't+worry,+the+variable's+scope+ended,+so+the+destructor+was+called,+and+the+resources+were+released
++++//+some+final+processing
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2021675|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>class ExpensiveObject {
public:
 ExpensiveObject() {
 // acquire a resource
 }
 ~ExpensiveObject() {
 // release the resource
 }
}

int main() {
 // some initial processing
 {
 ExpensiveObject obj;
 // do some expensive stuff with the obj
 } // don't worry, the variable's scope ended, so the destructor was called, and the resources were released
 // some final processing
}
</code></pre>

blocks|key|488866|text|如果您仅限于ANSI+C，则可以使用它们来声明更接近使用它们的变量：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|488867|int+main()+{
++++/*+Blah+blah+blah.+*/
++++{
++++++++int+i;
++++++++for+(i+=+0;+i+<+10;+%2B%2Bi)+{
++++++++}
++++}
}|code-block|syntax|javascript|488868|不过，没有必要使用现代的C编译器。|488869|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

If you are limited to ANSI C, then they could be used to declare variables closer to where you use them:

<pre><code>int main() {
 /* Blah blah blah. */
 {
 int i;
 for (i = 0; i &lt; 10; ++i) {
 }
 }
}
</code></pre>

Not neccessary with a modern C compiler though.

blocks|key|777442|text|通过创建新的作用域，它们可以用于定义开关语句中的局部变量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|777443|例如：|777444|switch+(i)
{
++++case+0+:
++++++++int+j+=+0;+++//+error!
++++++++break;|code-block|syntax|javascript|777445|与|777446|switch+(i)
{
++++case+0+:
++++{
++++++++int+j+=+0;+++//+ok!
++++}
++++break;|777447|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

By creating a new scope they can be used to define local variables in a switch statement.

e.g.

<pre><code>switch (i)
{
 case 0 :
 int j = 0; // error!
 break;
</code></pre>

vs.

<pre><code>switch (i)
{
 case 0 :
 {
 int j = 0; // ok!
 }
 break;
</code></pre>

blocks|key|2021761|text|另一种常用的方法是使用OpenGL的glPushMatrix()和glPopMatrix()函数创建与矩阵堆栈相关的逻辑块：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2021762|glPushMatrix();
{
++++glTranslate(...);
++++glPushMatrix();
++++{
++++++++glRotate(...);
++++++++//+draw+some+stuff
++++}
++++glPopMatrix();
++++//+maybe+draw+some+more+stuff
}
glPopMatrix();|code-block|syntax|javascript|2021763|entityMap^0|I|E|X|D|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

Another common use is with OpenGL's <code>glPushMatrix()</code> and <code>glPopMatrix()</code> functions to create logical blocks relating to the matrix stack:

<pre><code>glPushMatrix();
{
 glTranslate(...);
 glPushMatrix();
 {
 glRotate(...);
 // draw some stuff
 }
 glPopMatrix();
 // maybe draw some more stuff
}
glPopMatrix();
</code></pre>

blocks|key|488996|text|我将它用于需要临时变量的代码块。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|488997|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I use it for blocks of code that need temporary variables.

blocks|key|778511|text|定义了C%2B%2B中的关键部分，这是一个有用的用法--cas+ihmo。例如：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|778512|int+MyClass::foo()
{++++
+++//+stuff+uncritical+for+multithreading
+++...
+++{
++++++someKindOfScopeLock+lock(&mutexForThisCriticalResource);
++++++//+stuff+critical+for+multithreading!
+++}
+++//+stuff+uncritical+for+multithreading
+++...++++
}|code-block|syntax|javascript|778513|使用匿名范围，不需要显式调用互斥或信号量的锁/解锁。|778514|entityMap^0|0|6|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

A useful use-cas ihmo is defining critical sections in C++.
e.g.:

<pre><code>int MyClass::foo()
{ 
 // stuff uncritical for multithreading
 ...
 {
 someKindOfScopeLock lock(&amp;mutexForThisCriticalResource);
 // stuff critical for multithreading!
 }
 // stuff uncritical for multithreading
 ... 
}
</code></pre>

using anonymous scope there is no need calling lock/unlock of a mutex or a semaphore explicitly.

blocks|key|489054|text|值得一提的是，范围是一个编译器控制的现象。即使变量超出了作用域(编译器将调用任何析构函数；POD类型将立即优化到代码中)，它们仍然留在堆栈中，并且父作用域中定义的任何新变量都不会覆盖gcc或clang+(即使使用-Ofast编译时)。但是，通过address访问它们是一种未定义的行为，因为这些变量在概念上超出了编译器级别的范围--编译器将通过它们的标识符阻止您访问它们。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|489055|#include+<stdio.h>
int+main(void)+{
++int*+c;
++{
++++int+b+=+5;+
++++c=&b;
++}
++printf("%25d",+*c);+//undefined+behaviour+but+prints+5+for+reasons+stated+above
++printf("%25d",+b);+//compiler+error,+out+of+scope
++return+0;
}|code-block|syntax|javascript|489056|另外，for，if，否则所有的都在匿名块之前。复合语句，根据条件执行一个块或另一个块。|489057|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

One thing to mention is that scope is a compiler controlled phenomenon. Even though the variables go out of scope (and the compiler will call any destructors; POD types are optimised immediately into the code), they are left on the stack and any new variables defined in the parent scope do not overwrite them on gcc or clang (even when compiling with -Ofast). Except it is undefined behaviour to access them via address because the variables have conceptually gone out of scope at the compiler level -- the compiler will stop you accessing them by their identifiers.

<pre><code>#include &lt;stdio.h&gt;
int main(void) {
 int* c;
 {
 int b = 5; 
 c=&amp;b;
 }
 printf("%d", *c); //undefined behaviour but prints 5 for reasons stated above
 printf("%d", b); //compiler error, out of scope
 return 0;
}
</code></pre>

Also, for, if and else all precede anonymous blocks aka. compound statements, which either execute one block or the other block based on a condition.

What is the purpose of anonymous { } blocks in C style languages (C, C++, C#)

Example -

<pre><code>

void function()
{

 {
 int i = 0;
 i = i + 1;
 }

 {
 int k = 0;
 k = k + 1;
 }

}

</code></pre>

Edit - Thanks for all of the excellent answers!

What is the purpose of anonymous { } blocks in C style languages?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

C样式语言(C、C++、C#)中匿名{}块的用途是什么？例子-void function(){  {    int i = 0;    i = i + 1;  }  {    int k = 0;    k = k + 1;  }}编辑-感谢所有优秀的答案！

问C样式语言中匿名{}块的用途是什么？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C样式语言中匿名{}块的用途是什么？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C样式语言中匿名{}块的用途是什么？
EN