blocks|key|309976|text|形式上是肯定的，strlen()预计会在每次迭代中被调用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|309977|无论如何，我不想否认存在一些巧妙的编译器优化的可能性，这将优化第一个之后对strlen()的任何后续调用。|309978|entityMap^0|8|8|0|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|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

Formally yes, <code>strlen()</code> is expected to be called for every iteration.

Anyway I do not want to negate the possibility of the existance of some clever compiler optimisation, that will optimise away any successive call to strlen() after the first one.

blocks|key|310016|text|是。测试不知道ss在循环中没有改变。如果你知道它不会改变，那么我会写道：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|310017|int+stringLength+=+strlen+(ss);+
for+(+int+i+=+0;+i+<+stringLength;+%2B%2B+i+)+
{
++//+blabla+
}+|code-block|syntax|javascript|310018|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|$]]

Yes. The test doesn't know that ss doesn't get changed inside the loop. If you know that it won't change then I would write:

<pre><code>int stringLength = strlen (ss); 
for ( int i = 0; i &lt; stringLength; ++ i ) 
{
 // blabla 
} 
</code></pre>

blocks|key|310074|text|一个好的编译器可能不会每次都计算它，但我不认为你可以肯定，每个编译器都会计算它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|310075|除此之外，编译器必须知道，strlen(ss)不会改变。只有当for循环中的ss未更改时，才会出现这种情况。|offset|length|style|CODE|310076|例如，如果在for循环中对ss使用只读函数，但没有将ss-parameter声明为const，编译器甚至无法知道ss在循环中没有变化，并且必须在每次迭代中计算strlen(ss)。|310077|entityMap^0|0|D|A|V|3|12|2|0|6|3|D|2|Q|2|15|5|1K|2|27|A|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]|$D|P|E|Q|F|G]|$D|R|E|S|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@$D|U|E|V|F|G]|$D|W|E|X|F|G]|$D|Y|E|Z|F|G]|$D|10|E|11|F|G]|$D|12|E|13|F|G]|$D|14|E|15|F|G]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|K|$]]

A good compiler may not calculate it every time, but I don't think you can be sure, that every compiler does it. 

In addition to that, the compiler has to know, that <code>strlen(ss)</code> does not change. This is only true if <code>ss</code> is not changed in <code>for</code> loop. 

For example, if you use a read-only function on <code>ss</code> in <code>for</code> loop but don't declare the <code>ss</code>-parameter as <code>const</code>, the compiler cannot even know that <code>ss</code> is not changed in the loop and has to calculate <code>strlen(ss)</code> in every iteration.

blocks|key|527090|text|是的，strlen()将在每次迭代中进行评估。在理想情况下，优化器可能能够推断出值不会改变，但我个人不会依赖这一点。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|527091|我会做像这样的事情|527092|for+(int+i+=+0,+n+=+strlen(ss);+i+<+n;+%2B%2Bi)|code-block|syntax|javascript|527093|或者有可能|527094|for+(int+i+=+0;+ss[i];+%2B%2Bi)|527095|只要字符串在迭代过程中不会改变长度。如果可能，那么您需要每次都调用strlen()，或者通过更复杂的逻辑来处理它。|527096|entityMap^0|3|8|0|0|0|0|0|X|8|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|T|$]]

Yes, <code>strlen()</code> will be evaluated on each iteration. It's possible that, under ideal circumstances, the optimiser might be able to deduce that the value won't change, but I personally wouldn't rely on that.

I'd do something like

<pre><code>for (int i = 0, n = strlen(ss); i &lt; n; ++i)
</code></pre>

or possibly

<pre><code>for (int i = 0; ss[i]; ++i)
</code></pre>

as long as the string isn't going to change length during the iteration. If it might, then you'll need to either call <code>strlen()</code> each time, or handle it through more complicated logic.

blocks|key|527160|text|如果ss的类型是const+char+*，并且您没有在循环中丢弃const属性，那么如果开启了优化，编译器可能只会调用strlen一次。但这肯定不是可以指望的行为。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|527161|您应该将strlen结果保存在一个变量中，并在循环中使用此变量。如果您不想创建一个额外的变量，根据您正在做的事情，您可能可以通过反向循环来向后迭代而逃脱。|527162|for(+auto+i+=+strlen(s);+i+>+0;+--i+)+{
++//+do+whatever
++//+remember+value+of+s[strlen(s)]+is+the+terminating+NULL+character
}|code-block|syntax|javascript|527163|entityMap^0|2|2|8|C|W|5|1N|6|0|4|6|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|N|$]]

If <code>ss</code> is of type <code>const char *</code> and you're not casting away the <code>const</code>ness within the loop the compiler might only call <code>strlen</code> once, if optimizations are turned on. But this is certainly not behavior that can be counted upon. 

You should save the <code>strlen</code> result in a variable and use this variable in the loop. If you don't want to create an additional variable, depending on what you're doing, you may be ale to get away with reversing the loop to iterate backwards.

<pre><code>for( auto i = strlen(s); i &gt; 0; --i ) {
 // do whatever
 // remember value of s[strlen(s)] is the terminating NULL character
}
</code></pre>

blocks|key|310273|text|是的，每次你使用循环的时候。然后它每次都会计算字符串的长度。所以像这样使用它：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|310274|char+str[30];
for+(+int+i+=+0;+str[i]+!=+'\0';+i%2B%2B)
{
//Something;
}|code-block|syntax|javascript|310275|在上面的代码中，每次循环开始时，str[i]只在位置i处验证字符串中的一个特定字符，因此它占用的内存更少，效率更高。|offset|length|style|CODE|310276|有关详细信息，请参阅此Link。|310277|在下面的代码中，每次循环运行时，strlen都会计算整个字符串的长度，这会降低效率，耗费更多的时间和内存。|310278|char+str[];
for+(+int+i+=+0;+i+<+strlen(str);+i%2B%2B)
{
//Something;
}|310279|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cprogramming.com/tips/tip/dont-use-strlen-in-a-loop-condition^0|0|0|G|6|Q|1|0|B|4|0|0|G|6|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@$I|13|J|14|K|L]|$I|15|J|16|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|17|8|@]|9|@$I|18|J|19|1|1A]]|A|$]]|$1|O|3|P|5|6|7|1B|8|@$I|1C|J|1D|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1E|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

Yes, every time you use the loop. Then it will every time calculate the length of the string.
so use it like this:

<pre><code>char str[30];
for ( int i = 0; str[i] != '\0'; i++)
{
//Something;
}
</code></pre>

In the above code <code>str[i]</code> only verifies one particular character in the string at location <code>i</code> each time the loop starts a cycle, thus it will take less memory and is more efficient.

See this <a href="http://www.cprogramming.com/tips/tip/dont-use-strlen-in-a-loop-condition">Link</a> for more information.

In the code below every time the loop runs <code>strlen</code> will count the length of the whole string which is less efficient, takes more time and takes more memory.

<pre><code>char str[];
for ( int i = 0; i &lt; strlen(str); i++)
{
//Something;
}
</code></pre>

blocks|key|527252|text|是的，每次代码运行时都会计算strlen(ss)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|527253|entityMap^0|E|A|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Yes, <code>strlen(ss)</code> will be calculated every time the code runs.

blocks|key|527328|text|是的，strlen(ss)会在每次迭代时计算长度。如果你以某种方式增加了ss，同时也增加了i，那么就会出现无限循环。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|527329|entityMap^0|3|A|10|2|19|1|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]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|O|8|@]|D|@]|E|$]]]|G|$]]

Yes, the <code>strlen(ss)</code> will calculate the length at each iteration. If you are increasing the <code>ss</code> by some way and also increasing the <code>i</code>; there would be infinite loop.

blocks|key|527370|text|是的，简单的说。在极少数情况下，编译器希望这样做，如果它发现ss中根本没有做任何更改，那么就会有一个小的no。但在安全的情况下，你应该认为它是肯定的。在multithreaded和事件驱动程序中有一些情况，如果你认为它是不存在的，它可能会出现错误。谨慎行事，因为它不会太多地提高程序的复杂性。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|527371|entityMap^0|U|2|24|D|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|$]]

YES, in simple words.
And there is small no in rare condition in which compiler is wishing to, as an optimization step if it finds that there is no changes made in <code>ss</code> at all. But in safe condition you should think it as YES. There are some situation like in <code>multithreaded</code> and event driven program, it may get buggy if you consider it a NO.
Play safe as it is not going to improve the program complexity too much.

blocks|key|310440|text|是。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|310441|每次i增加且未优化时，计算strlen()。|offset|length|style|CODE|310442|下面的代码显示了为什么编译器不应该优化strlen()。|310443|for+(+int+i+=+0;+i+<+strlen(ss);+%2B%2Bi+)
{
+++//+Change+ss+string.
+++ss[i]+=+'a';+//+Compiler+should+not+optimize+strlen().
}|code-block|syntax|javascript|310444|entityMap^0|0|2|1|D|8|0|J|8|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]|$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|W|8|@$D|X|E|Y|F|G]]|9|@]|A|$]]|$1|J|3|K|5|L|7|Z|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|P|$]]

Yes.

<code>strlen()</code> calculated everytime when <code>i</code> increases and does not optimized.

Below code shows why the compiler should not optimize <code>strlen()</code>.

<pre><code>for ( int i = 0; i &lt; strlen(ss); ++i )
{
 // Change ss string.
 ss[i] = 'a'; // Compiler should not optimize strlen().
}
</code></pre>

blocks|key|310471|text|现在并不常见，但20年前在16位平台上，我建议这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|310472|for+(+char*+p+=+str;+*p;+p%2B%2B+)+{+/*+...+*/+}|code-block|syntax|javascript|310473|即使你的编译器在优化方面不是很聪明，上面的代码仍然可以产生很好的汇编代码。|310474|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|$]]

Not common nowadays but 20 years ago on 16 bit platforms, I'd recommend this:

<pre><code>for ( char* p = str; *p; p++ ) { /* ... */ }
</code></pre>

Even if your compiler isn't very smart in optimization, the above code can result in good assembly code yet.

blocks|key|527518|text|我们可以很容易地测试它：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|527519|char+nums[]+=+"0123456789";
size_t+end;
int+i;
for(+i=0,+end=strlen(nums);+i<strlen(nums);+i%2B%2B+)+{
++++putchar(+nums[i]+);
++++num[--end]+=+0;
}|code-block|syntax|javascript|527520|在重新启动循环之前，在每次重复之后计算循环条件。|527521|还要注意你用来处理字符串长度的类型。应该是在stdio中定义为unsigned+int的size_t。将其与int进行比较和转换可能会导致一些严重的漏洞问题。|offset|length|style|CODE|527522|entityMap^0|0|0|0|V|C|18|6|1I|3|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]|$K|W|L|X|M|N]|$K|Y|L|Z|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|P|$]]

We can easily test it :

<pre><code>char nums[] = "0123456789";
size_t end;
int i;
for( i=0, end=strlen(nums); i&lt;strlen(nums); i++ ) {
 putchar( nums[i] );
 num[--end] = 0;
}
</code></pre>

Loop condition evaluates after each repetition, before restarting the loop . 
Also be careful about the type you use to handle length of strings . it should be <code>size_t</code> which has been defined as <code>unsigned int</code> in stdio. comparing and casting it to <code>int</code> might cause some serious vulnerability issue.

blocks|key|310739|text|嗯，我注意到有人说它被任何“聪明的”现代编译器默认优化。顺便说一句，在没有优化的情况下查看结果。我试过了：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|310740|最小C代码：|310741|#include+<stdio.h>
#include+<string.h>

int+main()
{
+char+*s="aaaa";

+for+(int+i=0;+i<strlen(s);i%2B%2B)
++printf+("a");
+return+0;
}|code-block|syntax|javascript|310742|我的编译器:+g%2B%2B+(Ubuntu/Linaro+4.6.3-1ubuntu5)+4.6.3|310743|汇编代码生成命令:+g%2B%2B+-S+-masm=intel+test.cpp|310744|Gotten+assembly+code+at+the+output:
++++...
++++L3:
mov+DWORD+PTR+[esp],+97
call++++putchar
add+DWORD+PTR+[esp%2B40],+1
++++.L2:
+++++THIS+LOOP+IS+HERE
++++**mov++++ebx,+DWORD+PTR+[esp%2B40]
mov+eax,+DWORD+PTR+[esp%2B44]
mov+DWORD+PTR+[esp%2B28],+-1
mov+edx,+eax
mov+eax,+0
mov+ecx,+DWORD+PTR+[esp%2B28]
mov+edi,+edx
repnz+scasb**
+++++AS+YOU+CAN+SEE+it's+done+every+time
mov+eax,+ecx
not+eax
sub+eax,+1
cmp+ebx,+eax
setb++++al
test++++al,+al
jne+.L3
mov+eax,+0
+++++.....|310745|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|F|7|V|8|@]|9|@]|A|$G|H]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

well, I noticed that someone is saying that it is optimized by default by any "clever" modern compiler. By the way look at results without optimization. I tried: Minimal C code:

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

int main()
{
 char *s="aaaa";

 for (int i=0; i&lt;strlen(s);i++)
 printf ("a");
 return 0;
}
</code></pre>

My compiler: g++ (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3 
Command for generation of assembly code: g++ -S -masm=intel test.cpp 

<pre><code>Gotten assembly code at the output:
 ...
 L3:
mov DWORD PTR [esp], 97
call putchar
add DWORD PTR [esp+40], 1
 .L2:
 THIS LOOP IS HERE
 **&lt;b&gt;mov ebx, DWORD PTR [esp+40]
mov eax, DWORD PTR [esp+44]
mov DWORD PTR [esp+28], -1
mov edx, eax
mov eax, 0
mov ecx, DWORD PTR [esp+28]
mov edi, edx
repnz scasb&lt;/b&gt;**
 AS YOU CAN SEE it's done every time
mov eax, ecx
not eax
sub eax, 1
cmp ebx, eax
setb al
test al, al
jne .L3
mov eax, 0
 .....
</code></pre>

I'm not sure if the following code can cause redundant calculations, or is it compiler-specific?

<pre><code>for (int i = 0; i &lt; strlen(ss); ++i)
{
 // blabla
}
</code></pre>

Will <code>strlen()</code> be calculated every time when <code>i</code> increases?

Will strlen be calculated multiple times if used in a loop condition?

编译器

Ubuntu

我不确定下面的代码是否会导致冗余计算，或者它是特定于编译器的？for (int i = 0; i < strlen(ss); ++i){ // blabla}每次i增加都会计算strlen()吗？

问如果在循环条件下使用，strlen会被计算多次吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如果在循环条件下使用，strlen会被计算多次吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如果在循环条件下使用，strlen会被计算多次吗？
EN