O strlen será calculado várias vezes se usado em uma condição de loop?

Não tenho certeza se o código a seguir pode causar cálculos redundantes ou é específico do compilador?

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

Será strlen()calculado sempre que iaumenta?

Sim, strlen()será avaliado em cada iteração. É possível que, em circunstâncias ideais, o otimizador consiga deduzir que o valor não mudará, mas eu pessoalmente não confiaria nisso.

Eu faria algo como

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

ou possivelmente

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

contanto que a string não mude de comprimento durante a iteração. Se for o caso, você precisará ligar a strlen()cada vez ou lidar com isso por meio de uma lógica mais complicada.

Sim, toda vez que você usa o loop. Então, sempre calculará o comprimento da corda. então use-o assim:

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

No código acima, str[i]verifica apenas um caractere específico na string no local icada vez que o loop inicia um ciclo, portanto, ele ocupará menos memória e será mais eficiente.

Veja este link para mais informações.

No código abaixo, toda vez que o loop for executado strlen, o comprimento de toda a string será contado, o que é menos eficiente, leva mais tempo e ocupa mais memória.

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

Um bom compilador pode não calculá-lo sempre, mas não acho que você possa ter certeza de que todo compilador faz isso.

Além disso, o compilador tem que saber, isso strlen(ss)não muda. Isso só é verdadeiro se ssnão for alterado no forloop.

Por exemplo, se você usar uma função somente leitura ssno forloop, mas não declarar o ssparâmetro-como const, o compilador nem poderá saber que ssnão foi alterado no loop e terá que calcular a strlen(ss)cada iteração.

Se ssé do tipo const char *e você não está descartando o constness dentro do loop, o compilador pode chamar apenas strlenuma vez, se as otimizações estiverem ativadas. Mas certamente não é um comportamento com o qual se possa confiar.

Você deve salvar o strlenresultado em uma variável e usar essa variável no loop. Se você não quiser criar uma variável adicional, dependendo do que estiver fazendo, pode ser que você não se importe com a reversão do loop para iterar para trás.

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

Formalmente sim, strlen()espera-se que seja chamado a cada iteração.

De qualquer forma, não quero negar a possibilidade da existência de alguma otimização inteligente do compilador, que otimizará qualquer chamada sucessiva a strlen () após a primeira.

O código do predicado em sua totalidade será executado em cada iteração do forloop. Para memorizar o resultado da strlen(ss)chamada, o compilador precisa saber que pelo menos

1. A função não strlentinha efeitos colaterais
2. A memória apontada por ssnão muda durante o loop

O compilador não sabe nenhuma dessas coisas e, portanto, não pode memorizar com segurança o resultado da primeira chamada

Sim . strlen será calculado sempre que i aumentar.

Se você não alterou ss com no loop , isso não afetará a lógica, caso contrário, afetará.

É mais seguro usar o código a seguir.

int length = strlen(ss);

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

Sim, o strlen(ss)irá calcular o comprimento em cada iteração. Se você estiver aumentando o ssde alguma forma e também aumentando o i; haveria um loop infinito.

Sim, a strlen()função é chamada sempre que o loop é avaliado.

Se você deseja melhorar a eficiência, lembre-se sempre de salvar tudo em variáveis ​​locais ... Isso levará algum tempo, mas é muito útil.

Você pode usar o código abaixo:

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

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

Sim, strlen(ss)será calculado sempre que o código for executado.

Não é comum hoje em dia, mas há 20 anos em plataformas de 16 bits, eu recomendo isso:

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

Mesmo que seu compilador não seja muito inteligente em otimização, o código acima pode resultar em um bom código de montagem ainda.

Sim. O teste não sabe que ss não é alterado dentro do loop. Se você sabe que não vai mudar, eu escreveria:

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

Arrgh, vai, mesmo em circunstâncias ideais, caramba!

A partir de hoje (janeiro de 2018) e gcc 7.3 e clang 5.0, se você compilar:

#include <string.h>

void bar(char c);

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

Então nós temos:

• ss é um ponteiro constante.
• ss é marcado __restrict__
• O corpo do loop não pode de forma alguma tocar a memória apontada por ss(bem, a menos que viole o __restrict__).

e ainda , ambos os compiladores executam strlen() cada iteração desse loop . Surpreendente.

Isso também significa que as alusões / ilusões de @Praetorian e @JaredPar não deram certo.

SIM, em palavras simples. E existe um pequeno não em raras condições em que o compilador deseja, como uma etapa de otimização, se ele descobrir que não há nenhuma alteração feita ss. Mas em condições seguras, você deve pensar que sim. Existem algumas situações como em multithreadedum programa orientado a eventos, ele pode apresentar erros se você considerar um NÃO. Jogue com segurança, pois isso não vai melhorar muito a complexidade do programa.

Sim.

strlen() calculado sempre que i aumenta e não otimiza.

O código abaixo mostra por que o compilador não deve otimizar strlen().

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

Podemos testá-lo facilmente:

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

A condição do loop é avaliada após cada repetição, antes de reiniciar o loop.

Também tome cuidado com o tipo que você usa para lidar com o comprimento das cordas. deve ser o size_tque foi definido como unsigned intem stdio. compará-lo e convertê-lo em intpode causar alguns problemas graves de vulnerabilidade.

bem, percebi que alguém está dizendo que ele é otimizado por padrão por qualquer compilador moderno "inteligente". A propósito, veja os resultados sem otimização. Eu tentei:
Código C mínimo:

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

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

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

Meu compilador: g ++ (Ubuntu / Linaro 4.6.3-1ubuntu5) 4.6.3
Comando para geração de código de montagem: 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
     .....

Elaborando a resposta de Prætorian, recomendo o seguinte:

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

• autoporque você não quer se preocupar com o tipo de retorno de strlen. Um compilador C ++ 11 (por exemplo gcc -std=c++0x, não completamente C ++ 11, mas os tipos automáticos funcionam) fará isso por você.
• i = strlen(s)porque você deseja comparar 0(veja abaixo)
• i > 0 porque a comparação com 0 é (ligeiramente) mais rápida que a comparação com qualquer outro número.

a desvantagem é que você tem que usar i-1para acessar os caracteres da string.