blocks|key|247409|text|这是优秀的+practice。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|247410|通过在循环内创建变量，可以确保它们的作用域被限制在循环内。不能在循环外部引用或调用它。|247411|这样：|247412|247413|如果变量的名称有点“泛型”(如"i")，那么在稍后的代码中将其与另一个同名变量混合没有风险(也可以使用GCC上的-Wshadow+warning指令缓解)|unordered-list-item|CODE|247414|编译器知道变量的作用域被限制在循环内，因此如果变量被错误地引用为elsewhere.|247415|Last，则会发出正确的错误消息，但同样重要的是，编译器可以更有效地执行一些专用的优化(最重要的是寄存器分配)。因为它知道变量不能在循环之外使用。例如，不需要存储结果以供以后重用。|247416|247417|简而言之，你这样做是正确的。|247418|但是请注意，变量不应该在每个循环之间保留它的值。在这种情况下，您可能每次都需要初始化它。您还可以创建一个包含循环的更大的块，其唯一目的是声明变量，这些变量必须从一个循环到另一个循环保留它们的值。这通常包括循环计数器本身。|247419|{
++++int+i,+retainValue;
++++for+(i=0;+i<N;+i%2B%2B)
++++{
+++++++int+tmpValue;
+++++++/*+tmpValue+is+uninitialized+*/
+++++++/*+retainValue+still+has+its+previous+value+from+previous+loop+*/

+++++++/*+Do+some+stuff+here+*/
++++}
++++/*+Here,+retainValue+is+still+valid;+tmpValue+no+longer+*/
}|code-block|syntax|javascript|247420|对于问题#2:当调用函数时，变量被分配一次。事实上，从分配的角度来看，它(几乎)等同于在函数开始时声明变量。唯一的区别是作用域:变量不能在循环之外使用。甚至有可能变量没有被分配，只是重用了一些空闲的空位(来自其他作用域已经结束的变量)。|247421|有了受限和更精确的作用域，就会有更精确的优化。但更重要的是，它使您的代码更安全，在读取代码的其他部分时，需要担心的状态(即变量)更少。|247422|即使在if(){...}块之外也是如此。通常，不是：|247423|++++int+result;
++++(...)
++++result+=+f1();
++++if+(result)+then+{+(...)+}
++++(...)
++++result+=+f2();
++++if+(result)+then+{+(...)+}|247424|更安全的做法是：|247425|++++(...)
++++{
++++++++int+const+result+=+f1();
++++++++if+(result)+then+{+(...)+}
++++}
++++(...)
++++{
++++++++int+const+result+=+f2();
++++++++if+(result)+then+{+(...)+}
++++}|247426|差异可能看起来很小，特别是在这样一个小的例子中。但在更大的代码库中，它会有所帮助:现在将一些result值从f1()传输到f2()块是没有风险的。每个result都严格限制在它自己的作用域内，这使得它的作用更加准确。从审查者的角度来看，这要好得多，因为他需要担心和跟踪的长范围状态变量更少。|247427|甚至编译器也会提供更好的帮助:假设在将来，在一些错误的代码更改之后，不能用f2()正确地初始化result。第二个版本将简单地拒绝工作，在编译时声明一个明确的错误消息(比运行时好得多)。第一个版本不会发现任何东西，f1()的结果将简单地进行第二次测试，与f2()的结果混淆。|247428|互补信息|247429|开放源码工具CppCheck+(一种针对C/C%2B%2B代码的静态分析工具)提供了一些关于最佳变量范围的极佳提示。|247430|作为对分配的回应:上面的规则在C中是正确的，但可能不适用于某些C%2B%2B类。|247431|对于标准类型和结构，变量的大小在编译时是已知的。在C中没有“构造”这样的东西，所以当调用函数时，变量的空间将被简单地分配到堆栈中(没有任何初始化)。这就是为什么在循环内声明变量时有“零”成本的原因。|247432|然而，对于C%2B%2B类，还有构造函数这件事，我对此知之甚少。我猜分配可能不是问题，因为编译器应该足够聪明，可以重用相同的空间，但初始化可能会在每次循环迭代时发生。|247433|entityMap|0|LINK|mutability|MUTABLE|url|http://cppcheck.sourceforge.net/^0|2|3|0|0|0|0|1K|8|0|0|0|0|0|0|0|0|0|3|9|0|0|0|0|1A|6|1I|4|1P|4|23|6|0|11|4|1B|6|2Z|4|3J|4|0|0|6|8|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|20|8|@$9|21|A|22|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|23|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|24|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|25|8|@]|D|@]|E|$]]|$1|K|3|L|5|M|7|26|8|@$9|27|A|28|B|N]]|D|@]|E|$]]|$1|O|3|P|5|M|7|29|8|@]|D|@]|E|$]]|$1|Q|3|R|5|M|7|2A|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|2B|8|@]|D|@]|E|$]]|$1|T|3|U|5|6|7|2C|8|@]|D|@]|E|$]]|$1|V|3|W|5|6|7|2D|8|@]|D|@]|E|$]]|$1|X|3|Y|5|Z|7|2E|8|@]|D|@]|E|$10|11]]|$1|12|3|13|5|6|7|2F|8|@]|D|@]|E|$]]|$1|14|3|15|5|6|7|2G|8|@]|D|@]|E|$]]|$1|16|3|17|5|6|7|2H|8|@$9|2I|A|2J|B|N]]|D|@]|E|$]]|$1|18|3|19|5|Z|7|2K|8|@]|D|@]|E|$10|11]]|$1|1A|3|1B|5|6|7|2L|8|@]|D|@]|E|$]]|$1|1C|3|1D|5|Z|7|2M|8|@]|D|@]|E|$10|11]]|$1|1E|3|1F|5|6|7|2N|8|@$9|2O|A|2P|B|N]|$9|2Q|A|2R|B|N]|$9|2S|A|2T|B|N]|$9|2U|A|2V|B|N]]|D|@]|E|$]]|$1|1G|3|1H|5|6|7|2W|8|@$9|2X|A|2Y|B|N]|$9|2Z|A|30|B|N]|$9|31|A|32|B|N]|$9|33|A|34|B|N]]|D|@]|E|$]]|$1|1I|3|1J|5|6|7|35|8|@]|D|@]|E|$]]|$1|1K|3|1L|5|6|7|36|8|@]|D|@$9|37|A|38|1|39]]|E|$]]|$1|1M|3|1N|5|6|7|3A|8|@]|D|@]|E|$]]|$1|1O|3|1P|5|6|7|3B|8|@]|D|@]|E|$]]|$1|1Q|3|1R|5|6|7|3C|8|@]|D|@]|E|$]]|$1|1S|3|-4|5|6|7|3D|8|@]|D|@]|E|$]]]|1T|$1U|$5|1V|1W|1X|E|$1Y|1Z]]]]

This is excellent practice.

By creating variables inside loops, you ensure their scope is restricted to inside the loop. It cannot be referenced nor called outside of the loop.

This way:

<ul>
<li>If the name of the variable is a bit "generic" (like "i"), there is no risk to mix it with another variable of same name somewhere later in your code (can also be mitigated using the <code>-Wshadow</code> warning instruction on GCC)</li>
<li>The compiler knows that the variable scope is limited to inside the loop, and therefore will issue a proper error message if the variable is by mistake referenced elsewhere.</li>
<li>Last but not least, some dedicated optimization can be performed more efficiently by the compiler (most importantly register allocation), since it knows that the variable cannot be used outside of the loop. For example, no need to store the result for later re-use.</li>
</ul>

In short, you are right to do it.

Note however that the variable is not supposed to retain its value between each loop. In such case, you may need to initialize it every time. You can also create a larger block, encompassing the loop, whose sole purpose is to declare variables which must retain their value from one loop to another. This typically includes the loop counter itself.

<pre><code>{
 int i, retainValue;
 for (i=0; i&lt;N; i++)
 {
 int tmpValue;
 /* tmpValue is uninitialized */
 /* retainValue still has its previous value from previous loop */

 /* Do some stuff here */
 }
 /* Here, retainValue is still valid; tmpValue no longer */
}
</code></pre>

For question #2:
The variable is allocated once, when the function is called. In fact, from an allocation perspective, it is (nearly) the same as declaring the variable at the beginning of the function. The only difference is the scope: the variable cannot be used outside of the loop. It may even be possible that the variable is not allocated, just re-using some free slot (from other variable whose scope has ended).

With restricted and more precise scope come more accurate optimizations. But more importantly, it makes your code safer, with less states (i.e. variables) to worry about when reading other parts of the code.

This is true even outside of an <code>if(){...}</code> block. Typically, instead of :

<pre><code> int result;
 (...)
 result = f1();
 if (result) then { (...) }
 (...)
 result = f2();
 if (result) then { (...) }
</code></pre>

it's safer to write :

<pre><code> (...)
 {
 int const result = f1();
 if (result) then { (...) }
 }
 (...)
 {
 int const result = f2();
 if (result) then { (...) }
 }
</code></pre>

The difference may seem minor, especially on such a small example.
But on a larger code base, it will help : now there is no risk to transport some <code>result</code> value from <code>f1()</code> to <code>f2()</code> block. Each <code>result</code> is strictly limited to its own scope, making its role more accurate. From a reviewer perspective, it's much nicer, since he has less long range state variables to worry about and track.

Even the compiler will help better : assuming that, in the future, after some erroneous change of code, <code>result</code> is not properly initialized with <code>f2()</code>. The second version will simply refuse to work, stating a clear error message at compile time (way better than run time). The first version will not spot anything, the result of <code>f1()</code> will simply be tested a second time, being confused for the result of <code>f2()</code>.

<h3>Complementary information</h3>

The open-source tool <a href="http://cppcheck.sourceforge.net/" rel="noreferrer">CppCheck</a> (a static analysis tool for C/C++ code) provides some excellent hints regarding optimal scope of variables.

In response to comment on allocation:
The above rule is true in C, but might not be for some C++ classes.

For standard types and structures, the size of variable is known at compilation time. There is no such thing as "construction" in C, so the space for the variable will simply be allocated into the stack (without any initialization), when the function is called. That's why there is a "zero" cost when declaring the variable inside a loop.

However, for C++ classes, there is this constructor thing which I know much less about. I guess allocation is probably not going to be the issue, since the compiler shall be clever enough to reuse the same space, but the initialization is likely to take place at each loop iteration.

blocks|key|2928178|text|一般来说，这是一个非常好的做法，使它非常接近。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2928179|在某些情况下，会有诸如性能之类的考虑因素，以证明将变量从循环中拉出是合理的。|2928180|在您的示例中，程序每次都会创建和销毁字符串。一些库使用小字符串优化(SSO)，因此在某些情况下可以避免动态分配。|2928181|假设你想避免那些多余的创建/分配，你可以这样写：|2928182|for+(int+counter+=+0;+counter+<=+10;+counter%2B%2B)+{
+++//+compiler+can+pull+this+out
+++const+char+testing[]+=+"testing";
+++cout+<<+testing;
}|code-block|syntax|javascript|2928183|或者，您可以将常量提取出来：|2928184|const+std::string+testing+=+"testing";
for+(int+counter+=+0;+counter+<=+10;+counter%2B%2B)+{
+++cout+<<+testing;
}|2928185|2928186|大多数编译器是否意识到变量已经声明并跳过了这一部分，还是每次都会在内存中为它创建一个点？|blockquote|2928187|2928188|2928189|它可以重用变量消耗的空间，并且可以将不变量从循环中提取出来。在const+char数组的情况下(如上)-该数组可以被拉出。但是，对于对象(例如std::string)，构造函数和析构函数必须在每次迭代中执行。在std::string的情况下，“空格”包括一个指针，该指针包含表示字符的动态分配。所以这就是：|offset|length|style|CODE|2928190|for+(int+counter+=+0;+counter+<=+10;+counter%2B%2B)+{
+++string+testing+=+"testing";
+++cout+<<+testing;
}|2928191|在每种情况下都需要冗余的复制，如果变量超过SSO字符数的阈值，则需要动态分配和释放(并且SSO是由您的std库实现的)。|2928192|执行此操作：|2928193|string+testing;
for+(int+counter+=+0;+counter+<=+10;+counter%2B%2B)+{
+++testing+=+"testing";
+++cout+<<+testing;
}|2928194|在每次迭代时仍然需要字符的物理副本，但是表单可能会导致一个动态分配，因为您分配了字符串，并且实现应该看到没有必要调整字符串的后备分配的大小。当然，在本例中您不会这样做(因为已经演示了多个更好的替代方案)，但是当字符串或向量的内容发生变化时，您可以考虑这样做。|2928195|那么，您如何处理所有这些选项(以及更多)？将其作为默认值保持非常接近--直到您很好地理解了成本并知道何时应该偏离。|2928196|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|1Z|B|2X|B|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1H|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1I|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1J|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|1K|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1L|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|1M|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]|$1|R|3|S|5|T|7|1O|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1R|8|@$Y|1S|Z|1T|10|11]|$Y|1U|Z|1V|10|11]]|9|@]|A|$]]|$1|12|3|13|5|J|7|1W|8|@]|9|@]|A|$K|L]]|$1|14|3|15|5|6|7|1X|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|18|3|19|5|J|7|1Z|8|@]|9|@]|A|$K|L]]|$1|1A|3|1B|5|6|7|20|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|21|8|@]|9|@]|A|$]]|$1|1E|3|-4|5|6|7|22|8|@]|9|@]|A|$]]]|1F|$]]

Generally, it's a very good practice to keep it very close.

In some cases, there will be a consideration such as performance which justifies pulling the variable out of the loop.

In your example, the program creates and destroys the string each time. Some libraries use a small string optimization (SSO), so the dynamic allocation could be avoided in some cases.

Suppose you wanted to avoid those redundant creations/allocations, you would write it as:

<pre><code>for (int counter = 0; counter &lt;= 10; counter++) {
 // compiler can pull this out
 const char testing[] = "testing";
 cout &lt;&lt; testing;
}
</code></pre>

or you can pull the constant out:

<pre><code>const std::string testing = "testing";
for (int counter = 0; counter &lt;= 10; counter++) {
 cout &lt;&lt; testing;
}
</code></pre>

<blockquote>
 Do most compilers realize that the variable has already been declared and just skip that portion, or does it actually create a spot for it in memory each time?
</blockquote>

It can reuse the space the variable consumes, and it can pull invariants out of your loop. In the case of the const char array (above) - that array could be pulled out. However, the constructor and destructor must be executed at each iteration in the case of an object (such as <code>std::string</code>). In the case of the <code>std::string</code>, that 'space' includes a pointer which contains the dynamic allocation representing the characters. So this:

<pre><code>for (int counter = 0; counter &lt;= 10; counter++) {
 string testing = "testing";
 cout &lt;&lt; testing;
}
</code></pre>

would require redundant copying in each case, and dynamic allocation and free if the variable sits above the threshold for SSO character count (and SSO is implemented by your std library).

Doing this:

<pre><code>string testing;
for (int counter = 0; counter &lt;= 10; counter++) {
 testing = "testing";
 cout &lt;&lt; testing;
}
</code></pre>

would still require a physical copy of the characters at each iteration, but the form could result in one dynamic allocation because you assign the string and the implementation should see there is no need to resize the string's backing allocation. Of course, you wouldn't do that in this example (because multiple superior alternatives have already been demonstrated), but you might consider it when the string or vector's content varies.

So what do you do with all those options (and more)? Keep it very close as a default -- until you understand the costs well and know when you should deviate.

blocks|key|2928223|text|我发帖并不是为了回答JeremyRR的问题(因为他们已经被回答了)；相反，我发帖只是为了给出一个建议。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2928224|对于JeremyRR，您可以这样做：|2928225|{
++string+someString+=+"testing";+++

++for(int+counter+=+0;+counter+<=+10;+counter%2B%2B)
++{
++++cout+<<+someString;
++}

++//+The+variable+is+in+scope.
}

//+The+variable+is+no+longer+in+scope.|code-block|syntax|javascript|2928226|我不知道你是否意识到(我刚开始编程时没有意识到)，括号(只要它们是成对的)可以放在代码中的任何地方，而不仅仅是在"+if+"，"for"，"while“等之后。|2928227|我的代码是在Microsoft+Visual+C%2B%2B+2010Express中编译的，所以我知道它可以工作；另外，我试图在定义变量的括号之外使用它，但收到了一个错误，所以我知道该变量被“销毁”了。|2928228|我不知道使用这种方法是不是一种糟糕的做法，因为许多未标记的括号可能会很快使代码变得不可读，但也许一些注释可以澄清问题。|2928229|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I didn't post to answer JeremyRR's questions (as they have already been answered); instead, I posted merely to give a suggestion.

To JeremyRR, you could do this:

<pre><code>{
 string someString = "testing"; 

 for(int counter = 0; counter &lt;= 10; counter++)
 {
 cout &lt;&lt; someString;
 }

 // The variable is in scope.
}

// The variable is no longer in scope.
</code></pre>

I don't know if you realize (I didn't when I first started programming), that brackets (as long they are in pairs) can be placed anywhere within the code, not just after "if", "for", "while", etc.

My code compiled in Microsoft Visual C++ 2010 Express, so I know it works; also, I have tried to to use the variable outside of the brackets that it was defined in and I received an error, so I know that the variable was "destroyed".

I don't know if it is bad practice to use this method, as a lot of unlabeled brackets could quickly make the code unreadable, but maybe some comments could clear things up.

blocks|key|252420|text|对于C%2B%2B来说，这取决于你在做什么。好吧，这是一段愚蠢的代码，但是想象一下|type|unstyled|depth|inlineStyleRanges|entityRanges|data|252421|252422|类myTimeEatingClass|blockquote|252423|252424|252425|{
+public:
+//constructor
++++++myTimeEatingClass()
++++++{
++++++++++sleep(2000);
++++++++++ms_usedTime%2B=2;
++++++}
++++++~myTimeEatingClass()
++++++{
++++++++++sleep(3000);
++++++++++ms_usedTime%2B=3;
++++++}
++++++const+unsigned+int+getTime()+const
++++++{
++++++++++return++ms_usedTime;
++++++}
++++++static+unsigned+int+ms_usedTime;
};

myTimeEatingClass::ms_CreationTime=0;+
myFunc()
{
++++for+(int+counter+=+0;+counter+<=+10;+counter%2B%2B)+{

++++++++myTimeEatingClass+timeEater();
++++++++//do+something
++++}
++++cout+<<+"Creating+class+took+"+<<+timeEater.getTime()+<<+"seconds+at+all"+<<+endl;

}
myOtherFunc()
{
++++myTimeEatingClass+timeEater();
++++for+(int+counter+=+0;+counter+<=+10;+counter%2B%2B)+{
++++++++//do+something
++++}
++++cout+<<+"Creating+class+took+"+<<+timeEater.getTime()+<<+"seconds+at+all"+<<+endl;

}|code-block|syntax|javascript|252426|您将等待55秒，直到得到myFunc的输出。只是因为每个循环构造函数和析构函数一起需要5秒才能完成。|252427|您需要5秒钟才能得到myOtherFunc的输出。|252428|当然，这是一个疯狂的例子。|252429|但它表明，当构造函数和/或析构函数需要一些时间时，当每个循环都完成相同的构造时，这可能会成为性能问题。|252430|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|X|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|Y|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|11|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|12|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|13|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|14|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|15|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|V|$]]

For C++ it depends on what you are doing.
OK, it is stupid code but imagine
<blockquote>
<pre><code>class myTimeEatingClass
</code></pre>
</blockquote>
<pre><code>{
 public:
 //constructor
 myTimeEatingClass()
 {
 sleep(2000);
 ms_usedTime+=2;
 }
 ~myTimeEatingClass()
 {
 sleep(3000);
 ms_usedTime+=3;
 }
 const unsigned int getTime() const
 {
 return ms_usedTime;
 }
 static unsigned int ms_usedTime;
};

myTimeEatingClass::ms_CreationTime=0; 
myFunc()
{
 for (int counter = 0; counter &lt;= 10; counter++) {

 myTimeEatingClass timeEater();
 //do something
 }
 cout &lt;&lt; &quot;Creating class took &quot; &lt;&lt; timeEater.getTime() &lt;&lt; &quot;seconds at all&quot; &lt;&lt; endl;

}
myOtherFunc()
{
 myTimeEatingClass timeEater();
 for (int counter = 0; counter &lt;= 10; counter++) {
 //do something
 }
 cout &lt;&lt; &quot;Creating class took &quot; &lt;&lt; timeEater.getTime() &lt;&lt; &quot;seconds at all&quot; &lt;&lt; endl;

}
</code></pre>
You will wait 55 seconds until you get the output of myFunc.
Just because each loop constructor and destructor together need 5 seconds to finish.
You will need 5 seconds until you get the output of myOtherFunc.
Of course, this is a crazy example.
But it illustrates that it might become a performance issue when each loop the same construction is done when the constructor and / or destructor needs some time.

blocks|key|2928302|text|这是一个非常好的实践，因为上面所有的答案都提供了非常好的理论方面的问题，让我看一下代码，我试图解决DFS+over+GEEKSFORGEEKS，我遇到了优化问题……如果你试图解决代码，在循环之外声明整数将会给你带来优化错误。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2928303|stack<int>+st;
st.push(s);
cout<<s<<"+";
vis[s]=1;
int+flag=0;
int+top=0;
while(!st.empty()){
++++top+=+st.top();
++++for(int+i=0;i<g[top].size();i%2B%2B){
++++++++if(vis[g[top][i]]+!=+1){
++++++++++++st.push(g[top][i]);
++++++++++++cout<<g[top][i]<<"+";
++++++++++++vis[g[top][i]]=1;
++++++++++++flag=1;
++++++++++++break;
++++++++}
++++}
++++if(!flag){
++++++++st.pop();
++++}
}|code-block|syntax|javascript|2928304|现在将整数放入循环中，这将给你正确的答案。|2928305|stack<int>+st;
st.push(s);
cout<<s<<"+";
vis[s]=1;
//+int+flag=0;
//+int+top=0;
while(!st.empty()){
++++int+top+=+st.top();
++++int+flag+=+0;
++++for(int+i=0;i<g[top].size();i%2B%2B){
++++++++if(vis[g[top][i]]+!=+1){
++++++++++++st.push(g[top][i]);
++++++++++++cout<<g[top][i]<<"+";
++++++++++++vis[g[top][i]]=1;
++++++++++++flag=1;
++++++++++++break;
++++++++}
++++}
++++if(!flag){
++++++++st.pop();
++++}
}|2928306|这完全反映了先生@justin在第二条评论中所说的话。在这里试试，https://practice.geeksforgeeks.org/problems/depth-first-traversal-for-a-graph/1。试一试……您将获得it.Hope的此帮助。|offset|length|2928307|entityMap|0|LINK|mutability|MUTABLE|url|https://practice.geeksforgeeks.org/problems/depth-first-traversal-for-a-graph/1^0|0|0|0|0|X|27|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@$M|11|N|12|1|13]]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

It's a very good practice, as all above answer provide very good theoretical aspect of the question let me give a glimpse of code, i was trying to solve DFS over GEEKSFORGEEKS, i encounter the optimization problem......
If you try to solve the code declaring the integer outside the loop will give you Optimization Error..

<pre><code>stack&lt;int&gt; st;
st.push(s);
cout&lt;&lt;s&lt;&lt;" ";
vis[s]=1;
int flag=0;
int top=0;
while(!st.empty()){
 top = st.top();
 for(int i=0;i&lt;g[top].size();i++){
 if(vis[g[top][i]] != 1){
 st.push(g[top][i]);
 cout&lt;&lt;g[top][i]&lt;&lt;" ";
 vis[g[top][i]]=1;
 flag=1;
 break;
 }
 }
 if(!flag){
 st.pop();
 }
}
</code></pre>

Now put integers inside the loop this will give you correct answer... 

<pre><code>stack&lt;int&gt; st;
st.push(s);
cout&lt;&lt;s&lt;&lt;" ";
vis[s]=1;
// int flag=0;
// int top=0;
while(!st.empty()){
 int top = st.top();
 int flag = 0;
 for(int i=0;i&lt;g[top].size();i++){
 if(vis[g[top][i]] != 1){
 st.push(g[top][i]);
 cout&lt;&lt;g[top][i]&lt;&lt;" ";
 vis[g[top][i]]=1;
 flag=1;
 break;
 }
 }
 if(!flag){
 st.pop();
 }
}
</code></pre>

this completely reflect what sir @justin was saying in 2nd comment....
try this here 
<a href="https://practice.geeksforgeeks.org/problems/depth-first-traversal-for-a-graph/1" rel="nofollow noreferrer">https://practice.geeksforgeeks.org/problems/depth-first-traversal-for-a-graph/1</a>. just give it a shot.... you will get it.Hope this help.

blocks|key|3142828|text|第4.8章K&R的C编程语言2版中的块结构。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3142829|3142830|是一个在块中声明和初始化的自动变量，在每次进入该块时都会被初始化。|blockquote|3142831|3142832|3142833|我可能没有在书中看到相关的描述，比如：|3142834|3142835|是一个在块中声明和初始化的自动变量，在进入该块之前只分配一次。|3142836|3142837|3142838|但一个简单的测试就可以证明这个假设成立：|3142839|+#include+<stdio.h>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

+int+main(int+argc,+char+*argv[])+{++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++for+(int+i+=+0;+i+<+2;+i%2B%2B)+{+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++for+(int+j+=+0;+j+<+2;+j%2B%2B)+{+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++int+k;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++printf("%25p\n",+&k);+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++}+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++}+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++return+0;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+}+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++|code-block|syntax|javascript|3142840|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|Z|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|11|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|13|8|@]|9|@]|A|$]]|$1|K|3|L|5|E|7|14|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|16|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|17|8|@]|9|@]|A|$]]|$1|Q|3|R|5|S|7|18|8|@]|9|@]|A|$T|U]]|$1|V|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|W|$]]

Chapter 4.8 Block Structure in K&amp;R's The C Programming Language 2.Ed.:

<blockquote>
 An automatic variable declared and initialized in a
 block is initialized each time the block is entered.
</blockquote>

I might have missed seeing the relevant description in the book like:

<blockquote>
 An automatic variable declared and initialized in a
 block is allocated only one time before the block is entered.
</blockquote>

But a simple test can prove the assumption held:

<pre><code> #include &lt;stdio.h&gt; 

 int main(int argc, char *argv[]) { 
 for (int i = 0; i &lt; 2; i++) { 
 for (int j = 0; j &lt; 2; j++) { 
 int k; 
 printf("%p\n", &amp;k); 
 } 
 } 
 return 0; 
 } 
</code></pre>

blocks|key|3142875|text|因为你的第二个问题更具体，所以我将首先解决它，然后用第二个问题给出的上下文来回答你的第一个问题。我想给出一个比这里已经有的更基于证据的答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3142876|3142877|+问题#2：大多数编译器是否意识到变量已经声明并跳过了这一部分，还是每次都会在内存中为它创建一个点？|blockquote|offset|length|style|BOLD|3142878|3142879|3142880|您可以通过在汇编器运行之前停止编译器并查看asm来回答这个问题。(如果您的编译器有一个gcc风格的接口，请使用-S标志，如果您想要我在这里使用的语法风格，请使用-masm=intel。)|CODE|3142881|在任何情况下，对于x86-64的现代编译器(gcc+10.2，clang11.0)，如果您禁用优化，则它们仅在每次循环通过时重新加载变量。考虑下面的C%2B%2B程序-为了直观地映射到asm，我主要使用C风格，并使用整数而不是字符串，尽管相同的原则适用于字符串的情况：|3142882|#include+<iostream>

static+constexpr+std::size_t+LEN+=+10;

void+fill_arr(int+a[LEN])
{
++++/*+***+*/
++++for+(std::size_t+i+=+0;+i+<+LEN;+%2B%2Bi)+{
++++++++const+int+t+=+8;

++++++++a[i]+=+t;
++++}
++++/*+***+*/
}

int+main(void)
{
++++int+a[LEN];

++++fill_arr(a);

++++for+(std::size_t+i+=+0;+i+<+LEN;+%2B%2Bi)+{
++++++++std::cout+<<+a[i]+<<+"+";
++++}

++++std::cout+<<+"\n";

++++return+0;
}|code-block|syntax|javascript|3142883|我们可以将其与具有以下差异的版本进行比较：|3142884|++++/*+***+*/
++++const+int+t+=+8;

++++for+(std::size_t+i+=+0;+i+<+LEN;+%2B%2Bi)+{
++++++++a[i]+=+t;
++++}
++++/*+***+*/|3142885|在禁用优化的情况下，对于循环中声明版本，gcc+10.2在每次循环传递时都会将8放入堆栈：|3142886|++++mov+QWORD+PTR+-8[rbp],+0
.L3:
++++cmp+QWORD+PTR+-8[rbp],+9
++++ja++.L4
++++mov+DWORD+PTR+-12[rbp],+8+;✷|3142887|而对于循环外版本，它只执行一次：|3142888|++++mov+DWORD+PTR+-12[rbp],+8+;✷
++++mov+QWORD+PTR+-8[rbp],+0
.L3:
++++cmp+QWORD+PTR+-8[rbp],+9
++++ja++.L4|3142889|这会对性能产生影响吗？我在我的CPU+(Intel+i7-7700K)上看不到它们在运行时间上的明显差异，直到我将迭代次数推到数十亿次，即使到那时平均差异也不到0.01秒。毕竟，这只是循环中的一个额外操作。(对于字符串，循环内操作的差异显然更大，但不是很明显。)|3142890|更重要的是，这个问题在很大程度上是学术性质的，因为在优化级别为-O1或更高的情况下，gcc会为两个源文件输出相同的asm，就像clang一样。因此，至少对于像这样的简单情况，这两种方式都不太可能对性能产生任何影响。当然，在实际的程序中，您应该始终进行概要分析，而不是进行假设。|3142891|3142892|+问题#1：在循环内声明变量是好做法还是坏做法？|3142893|3142894|3142895|就像几乎每一个这样的问题一样，这取决于。如果声明在一个非常紧凑的循环中，并且您在没有优化的情况下进行编译，比如出于调试目的，那么理论上将其移出循环可以提高性能，从而在调试过程中非常方便。如果是这样的话，这可能是明智的，至少在你调试的时候是这样。尽管我认为这在优化的构建中不太可能有任何不同，但如果你确实观察到了一个，你/你的搭档/你的团队可以判断它是否值得。|3142896|同时，你不仅要考虑编译器如何读取你的代码，还要考虑它对人类的影响，包括你自己。我想您会同意，在尽可能小的作用域中声明的变量更容易跟踪。如果它在循环之外，就意味着在循环之外需要它，如果实际情况并非如此，这是令人困惑的。在大型代码库中，像这样的小混乱会随着时间的推移而积累起来，在几个小时的工作后变得疲惫，并可能导致愚蠢的错误。这可能比您从轻微的性能改进中获得的成本要高得多，具体取决于用例。|3142897|entityMap^0|0|0|1|4|0|0|0|1J|2|28|B|0|0|0|0|0|0|0|0|0|0|V|3|0|0|1|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1M|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|1O|8|@$F|1P|G|1Q|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|1R|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1T|8|@$F|1U|G|1V|H|N]|$F|1W|G|1X|H|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|Q|3|R|5|S|7|1Z|8|@]|9|@]|A|$T|U]]|$1|V|3|W|5|6|7|20|8|@]|9|@]|A|$]]|$1|X|3|Y|5|S|7|21|8|@]|9|@]|A|$T|U]]|$1|Z|3|10|5|6|7|22|8|@]|9|@]|A|$]]|$1|11|3|12|5|S|7|23|8|@]|9|@]|A|$T|U]]|$1|13|3|14|5|6|7|24|8|@]|9|@]|A|$]]|$1|15|3|16|5|S|7|25|8|@]|9|@]|A|$T|U]]|$1|17|3|18|5|6|7|26|8|@]|9|@]|A|$]]|$1|19|3|1A|5|6|7|27|8|@$F|28|G|29|H|N]]|9|@]|A|$]]|$1|1B|3|-4|5|6|7|2A|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|E|7|2B|8|@$F|2C|G|2D|H|I]]|9|@]|A|$]]|$1|1E|3|-4|5|6|7|2E|8|@]|9|@]|A|$]]|$1|1F|3|-4|5|6|7|2F|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|6|7|2G|8|@]|9|@]|A|$]]|$1|1I|3|1J|5|6|7|2H|8|@]|9|@]|A|$]]|$1|1K|3|-4|5|6|7|2I|8|@]|9|@]|A|$]]]|1L|$]]

Since your second question is more concrete, I'm going to address it first, and then take up your first question with the context given by the second. I wanted to give a more evidence-based answer than what's here already.
<blockquote>
Question #2: Do most compilers realize that the variable has already
been declared and just skip that portion, or does it actually create a
spot for it in memory each time?
</blockquote>
You can answer this question for yourself by stopping your compiler before the assembler is run and looking at the asm. (Use the <code>-S</code> flag if your compiler has a gcc-style interface, and <code>-masm=intel</code> if you want the syntax style I'm using here.)
In any case, with modern compilers (gcc 10.2, clang 11.0) for x86-64, they only reload the variable on each loop pass if you disable optimizations. Consider the following C++ program—for intuitive mapping to asm, I'm keeping things mostly C-style and using an integer instead of a string, although the same principles apply in the string case:
<pre><code>#include &lt;iostream&gt;

static constexpr std::size_t LEN = 10;

void fill_arr(int a[LEN])
{
 /* *** */
 for (std::size_t i = 0; i &lt; LEN; ++i) {
 const int t = 8;

 a[i] = t;
 }
 /* *** */
}

int main(void)
{
 int a[LEN];

 fill_arr(a);

 for (std::size_t i = 0; i &lt; LEN; ++i) {
 std::cout &lt;&lt; a[i] &lt;&lt; &quot; &quot;;
 }

 std::cout &lt;&lt; &quot;\n&quot;;

 return 0;
}
</code></pre>
We can compare this to a version with the following difference:
<pre><code> /* *** */
 const int t = 8;

 for (std::size_t i = 0; i &lt; LEN; ++i) {
 a[i] = t;
 }
 /* *** */
</code></pre>
With optimization disabled, gcc 10.2 puts 8 on the stack on every pass of the loop for the declaration-in-loop version:
<pre><code> mov QWORD PTR -8[rbp], 0
.L3:
 cmp QWORD PTR -8[rbp], 9
 ja .L4
 mov DWORD PTR -12[rbp], 8 ;✷
</code></pre>
whereas it only does it once for the out-of-loop version:
<pre><code> mov DWORD PTR -12[rbp], 8 ;✷
 mov QWORD PTR -8[rbp], 0
.L3:
 cmp QWORD PTR -8[rbp], 9
 ja .L4
</code></pre>
Does this make a performance impact? I didn't see an appreciable difference in runtime between them with my CPU (Intel i7-7700K) until I pushed the number of iterations into the billions, and even then the average difference was less than 0.01s. It's only a single extra operation in the loop, after all. (For a string, the difference in in-loop operations is obviously a bit greater, but not dramatically so.)
What's more, the question is largely academic, because with an optimization level of <code>-O1</code> or higher gcc outputs identical asm for both source files, as does clang. So, at least for simple cases like this, it's unlikely to make any performance impact either way. Of course, in a real-world program, you should always profile rather than make assumptions.
<blockquote>
Question #1: Is declaring a variable inside a loop a good practice or
bad practice?
</blockquote>
As with practically every question like this, it depends. If the declaration is inside a very tight loop and you're compiling without optimizations, say for debugging purposes, it's theoretically possible that moving it outside the loop would improve performance enough to be handy during your debugging efforts. If so, it might be sensible, at least while you're debugging. And although I don't think it's likely to make any difference in an optimized build, if you do observe one, you/your pair/your team can make a judgement call as to whether it's worth it.
At the same time, you have to consider not only how the compiler reads your code, but also how it comes off to humans, yourself included. I think you'll agree that a variable declared in the smallest scope possible is easier to keep track of. If it's outside the loop, it implies that it's needed outside the loop, which is confusing if that's not actually the case. In a big codebase, little confusions like this add up over time and become fatiguing after hours of work, and can lead to silly bugs. That can be much more costly than what you reap from a slight performance improvement, depending on the use case.

blocks|key|3142940|text|在循环内或循环外声明变量，这是JVM规范的结果，但在最佳编码实践的名称中，建议在尽可能小的范围内声明变量(在本例中，它在循环内，因为这是使用变量的唯一位置)。在最小范围内声明对象可以提高可读性。局部变量的作用域应该总是尽可能小。在您的示例中，我假定str不在while循环外部使用，否则您不会问这个问题，因为不能在while循环内声明它，因为它不会被编译。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3142941|如果我在内部或外部声明变量会有区别吗?如果在Java中在循环内部或外部声明变量会有区别吗？这是否适用于(+int+i=+0；i<+1000；i%2B%2B)+{int在单个变量级别上没有显著的效率差异，但如果您有一个具有1000个循环和1000个变量的函数(别管暗示的糟糕风格)，可能会有系统差异，因为所有变量的生命周期都是相同的，而不是重叠的。|3142942|在for循环中声明循环控制变量时，当您在for循环中声明变量时，有一个要点需要记住:当for语句结束时，该变量的作用域将结束。(即，该变量的作用域仅限于for循环。)这个Java示例展示了如何在Java+For循环中使用声明块声明多个变量。|3142943|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|$]]

Declaring variables inside or outside of a loop, It's the result of JVM specifications But in the name of best coding practice it is recommended to declare the variable in the smallest possible scope (in this example it is inside the loop, as this is the only place where the variable is used). Declaring objects in the smallest scope improve readability. The scope of local variables should always be the smallest possible. In your example I presume str is not used outside of the while loop, otherwise you would not be asking the question, because declaring it inside the while loop would not be an option, since it would not compile.
Does it make a difference if I declare variables inside or outside a , Does it make a difference if I declare variables inside or outside a loop in Java? Is this for(int i = 0; i &lt; 1000; i++) { int At the level of the individual variable there is no significant difference in effeciency, but if you had a function with 1000 loops and 1000 variables (never mind the bad style implied) there could be systemic differences because all the lives of all the variables would be the same instead of overlapped.
Declaring Loop Control Variables Inside the for Loop, When you declare a variable inside a for loop, there is one important point to remember: the scope of that variable ends when the for statement does. (That is, the scope of the variable is limited to the for loop.) This Java Example shows how to declare multiple variables in Java For loop using declaration block.

blocks|key|3143059|text|曾几何时(在C%2B%2B98之前)；下面的代码会中断：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3143060|{
++++for+(int+i=0;+i<.;+%2B%2Bi)+{std::string+foo;}
++++for+(int+i=0;+i<.;+%2B%2Bi)+{std::string+foo;}
}|code-block|syntax|javascript|3143061|警告说我已经被声明了(foo很好，因为它的作用域在{}中)。这可能就是为什么人们首先会说它不好的原因。然而，这在很久以前就不再是真的了。|3143062|如果你仍然必须支持这样一个旧的编译器(有些人在Borland)，那么答案是肯定的，可以提出一个案例，把i放在循环之外，因为不这样做会让人们“更难”用同一个变量放入多个循环，尽管老实说，编译器仍然会失败，如果有问题，这就是你想要的。|3143063|如果你不再需要支持这样一个旧的编译器，变量应该保持在你能得到的最小范围内，这样你不仅可以最大限度地减少内存使用，而且还可以更容易地理解项目。这有点像在问为什么不让所有的变量都是全局的。同样的论据也适用，但作用域只有一点变化。|3143064|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Once upon a time (pre C++98); the following would break:
<pre><code>{
 for (int i=0; i&lt;.; ++i) {std::string foo;}
 for (int i=0; i&lt;.; ++i) {std::string foo;}
}
</code></pre>
with the warning that i was already declared (foo was fine as that's scoped within the {}). This is likely the WHY people would first argue it's bad. It stopped being true a long time ago though.
If you STILL have to support such an old compiler (some people are on Borland) then the answer is yes, a case could be made to put the i out the loop, because not doing so makes it makes it &quot;harder&quot; for people to put multiple loops in with the same variable, though honestly the compiler will still fail, which is all you want if there's going to be a problem.
If you no longer have to support such an old compiler, variables should be kept to the smallest scope you can get them so that you not only minimise the memory usage; but also make understanding the project easier. It's a bit like asking why don't you have all your variables global. Same argument applies, but the scopes just change a bit.

Question #1: Is declaring a variable inside a loop a good practice or bad practice?

I've read the other threads about whether or not there is a performance issue (most said no), and that you should always declare variables as close to where they are going to be used. What I'm wondering is whether or not this should be avoided or if it's actually preferred.

Example:

<pre><code>for(int counter = 0; counter &lt;= 10; counter++)
{
 string someString = "testing";

 cout &lt;&lt; someString;
}
</code></pre>

Question #2: Do most compilers realize that the variable has already been declared and just skip that portion, or does it actually create a spot for it in memory each time?

Declaring variables inside loops, good practice or bad practice?

问题#1:在循环中声明变量是好做法还是坏做法？我已经阅读了其他关于是否有性能问题的帖子(大多数人说没有)，并且你应该总是在接近使用它们的地方声明变量。我想知道的是，这是应该避免的，还是实际上是首选的。示例：for(int counter = 0; counter <= 10; counter++){ string ...

问在循环中声明变量，是好做法还是坏做法？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在循环中声明变量，是好做法还是坏做法？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在循环中声明变量，是好做法还是坏做法？
EN