如果在循环条件下使用，strlen是否会被多次计算？

我不确定以下代码是否会导致冗余计算，或者它是否特定于编译器？

for (int i = 0; i < strlen(ss); ++i)
{
    // blabla
}

strlen()每次i增加时都会计算？

是， strlen()将在每次迭代中进行评估。在理想情况下，优化器有可能推断出价值不会改变，但我个人不会依靠这一点。

我会做类似的事情

for (int i = 0, n = strlen(ss); i < n; ++i)

或可能

for (int i = 0; ss[i]; ++i)

只要字符串在迭代过程中不会改变长度。如果可能，那么您将需要strlen()每次调用，或者通过更复杂的逻辑进行处理。

是的，每次使用循环时。然后它将每次计算字符串的长度。所以像这样使用它：

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

在上面的代码中，str[i]仅验证位置字符串中的一个特定字符i每次循环开始一个循环时，，因此它将占用较少的内存并且效率更高。

有关更多信息，请参见此链接。

在下面的代码中，每次循环运行strlen都将计算整个字符串的长度，这将降低效率，花费更多时间并占用更多内存。

char str[];
for ( int i = 0; i < strlen(str); i++)
{
//Something;
}

一个好的编译器可能不会每次都计算它，但我认为您不能确定每个编译器都可以计算它。

除此之外，编译器必须知道，这strlen(ss)不会改变。仅当ss未for循环更改时才如此。

例如，如果ss在for循环中使用只读函数，但未将ss-parameter 声明为const，则编译器甚至无法知道ss循环中未更改该参数，因此必须strlen(ss)在每次迭代中进行计算。

如果ss是类型，const char *并且您没有放弃const循环内的本质，则编译器可能只会调用strlen，那么如果打开了优化功能，一次。但这当然不是可以指望的行为。

您应该将strlen结果保存在变量中，然后在循环中使用此变量。如果您不想创建其他变量，具体取决于您正在执行的操作，则可能不希望通过反转循环来向后迭代。

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

正式是 strlen()预计将在每次迭代中调用。

无论如何，我不想否定一些聪明的编译器优化的可能性，该优化将消除在第一个调用之后对strlen（）的任何后续调用。

整个谓词代码将在for循环的每次迭代中执行。为了strlen(ss)记住调用结果，编译器至少需要知道

1. 功能 strlen无副作用
2. 指向的内存ss在循环期间不会更改

编译器不知道这些事情，因此无法安全地记住第一次调用的结果

是的。我增加时都会计算strlen。

如果您没有在循环中更改ss with ，则它不会影响逻辑，否则会影响逻辑。

使用以下代码更安全。

int length = strlen(ss);

for ( int i = 0; i < length ; ++ i )
{
 // blabla
}

是的，strlen(ss)它将在每次迭代时计算长度。如果您ss通过某种方式增加，同时也增加i；会有无限循环。

是的，每次评估循环时strlen()都会调用该函数。

如果您想提高效率，那么请务必记住将所有内容保存在局部变量中……这会花费一些时间，但是非常有用。

您可以使用如下代码：

String str="ss";
int l = strlen(str);

for ( int i = 0; i < l ; i++ )
{
    // blablabla
}

是的，strlen(ss)将在每次代码运行时进行计算。

现在不常见，但是20年前在16位平台上，我建议这样做：

for ( char* p = str; *p; p++ ) { /* ... */ }

即使您的编译器在优化方面不是很聪明，上面的代码也可以产生良好的汇编代码。

是。测试不知道ss不会在循环内更改。如果您知道它不会改变，那么我会写：

int stringLength = strlen (ss); 
for ( int i = 0; i < stringLength; ++ i ) 
{
  // blabla 
} 

哎呀，即使在理想情况下，也该死！

截至今天（2018年1月）以及gcc 7.3和clang 5.0，如果您进行以下编译：

#include <string.h>

void bar(char c);

void foo(const char* __restrict__ ss) 
{
    for (int i = 0; i < strlen(ss); ++i) 
    {
        bar(*ss);
    }
}    

因此，我们有：

• ss 是一个常量指针。
• ss 被标记 __restrict__
• 循环体无法以任何方式接触所指向的内存ss（嗯，除非违反__restrict__）。

并且还，两种编译器执行strlen() 该循环的每一个迭代。惊人。

这也意味着@Praetorian和@JaredPar的典故/如意算盘不会成功。

是的，简单来说。而且，在很少见的情况下，编译器希望发现编译器根本不做任何更改，这是优化步骤ss。但是在安全条件下，您应该认为是。在某些情况下，例如multithreaded事件驱动程序中的in ，如果您将其视为“否”，则可能会出现错误。请放心，因为它不会过多地提高程序复杂性。

是。

strlen() 每次计算 i增加且未优化。

下面的代码显示了为什么编译器不应该优化strlen()。

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

我们可以轻松地对其进行测试：

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

循环条件在每次重复之后评估，然后重新启动循环。

另外，请注意用于处理字符串长度的类型。应该是在stdio中size_t定义的unsigned int。比较并强制转换int可能会导致一些严重的漏洞问题。

好吧，我注意到有人说默认情况下，任何“聪明”的现代编译器都会对其进行优化。顺便看看没有优化的结果。我试过：
最小的C代码：

#include <stdio.h>
#include <string.h>

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

 for (int i=0; i<strlen(s);i++)
  printf ("a");
 return 0;
}

我的编译器：g ++（Ubuntu / Linaro 4.6.3-1ubuntu5）4.6.3
生成汇编代码的命令：g ++ -S -masm = intel test.cpp

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
    **<b>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</b>**
     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
     .....

详细阐述Prætorian的答案，我建议以下内容：

for( auto i = strlen(s)-1; i > 0; --i ) {foo(s[i-1];}

• auto因为您不想关心strlen返回的类型。一个C ++ 11编译器（例如gcc -std=c++0x，不是完全C ++ 11，而是自动类型起作用）将为您完成此任务。
• i = strlen(s)因为您要比较0（见下文）
• i > 0 因为与0的比较比与任何其他数字的比较（略）快。

缺点是您必须使用i-1才能访问字符串字符。