Будет ли 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цикле in, но не объявляете параметр ss-параметр as 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 будет вычисляться каждый раз, когда i увеличивается.

Если вы не изменили ss с помощью в цикле, это не повлияет на логику, иначе это повлияет.

Безопаснее использовать следующий код.

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 г.) и 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программа, управляемая событиями и событиями, она может работать с ошибками, если вы считаете это НЕТ. Будьте осторожны, так как это не сильно улучшит сложность программы.

Да.

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;
}

Состояние цикла оценивается после каждого повторения перед перезапуском цикла.

Также будьте осторожны с типом, который вы используете для обработки длины строк. это должно быть то, size_tчто было определено как unsigned intв stdio. его сравнение и приведение 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
     .....

Разрабатывая ответ преторианца, я рекомендую следующее:

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для доступа к строковым символам.