Чи буде струн обчислюватися в кілька разів, якщо його використовувати в умовах циклу?

Я не впевнений, чи може наступний код викликати надмірні обчислення, чи це специфічний для компілятора?

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як 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 буде обчислюватися щоразу, коли я збільшується.

Якщо ви не змінювали сс з в петльових засобах це не впливатиме на логіку в іншому випадку це буде впливати.

Безпечніше використовувати наступний код.

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