Strlen verrà calcolato più volte se utilizzato in una condizione di loop?

Non sono sicuro che il codice seguente possa causare calcoli ridondanti o è specifico del compilatore?

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

Verrà strlen()calcolato ogni volta che iaumenta?

Sì, strlen()verrà valutato ad ogni iterazione. È possibile che, in circostanze ideali, l'ottimizzatore sia in grado di dedurre che il valore non cambierà, ma personalmente non ci farei affidamento.

Farei qualcosa di simile

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

o forse

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

fintanto che la stringa non cambierà lunghezza durante l'iterazione. Se è possibile, dovrai chiamare strlen()ogni volta o gestirlo attraverso una logica più complicata.

Sì, ogni volta che usi il loop. Quindi ogni volta calcolerà la lunghezza della stringa. quindi usalo in questo modo:

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

Nel codice precedente str[i]verifica solo un carattere particolare nella stringa nella posizione iogni volta che il ciclo avvia un ciclo, quindi richiederà meno memoria ed è più efficiente.

Vedere questo collegamento per ulteriori informazioni.

Nel codice seguente ogni volta che il ciclo viene eseguito strlenconterà la lunghezza dell'intera stringa che è meno efficiente, richiede più tempo e richiede più memoria.

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

Un buon compilatore potrebbe non calcolarlo ogni volta, ma non credo che tu possa essere sicuro che lo faccia ogni compilatore.

Inoltre, il compilatore deve sapere che strlen(ss)non cambia. Questo è vero solo se ssnon viene modificato in forloop.

Ad esempio, se si utilizza una funzione di sola lettura ssin un forciclo ma non si dichiara il ssparametro -parametro come const, il compilatore non può nemmeno sapere che ssnon viene modificato nel ciclo e deve calcolare strlen(ss)in ogni iterazione.

Se ssè di tipo const char *e non stai eliminando la constness all'interno del ciclo, il compilatore potrebbe chiamare solo strlenuna volta, se le ottimizzazioni sono attivate. Ma questo non è certamente un comportamento su cui si può contare.

È necessario salvare il strlenrisultato in una variabile e utilizzare questa variabile nel ciclo. Se non vuoi creare una variabile aggiuntiva, a seconda di quello che stai facendo, potresti farla franca invertendo il ciclo per iterare all'indietro.

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

Formalmente sì, strlen()dovrebbe essere chiamato per ogni iterazione.

Comunque non voglio negare la possibilità che esista qualche intelligente ottimizzazione del compilatore, che ottimizzerà ogni successiva chiamata a strlen () dopo la prima.

Il codice del predicato nella sua interezza verrà eseguito a ogni iterazione del forciclo. Per memorizzare il risultato della strlen(ss)chiamata, il compilatore dovrebbe almeno saperlo

1. La funzione strlenera priva di effetti collaterali
2. La memoria puntata da ssnon cambia per la durata del ciclo

Il compilatore non conosce nessuna di queste cose e quindi non può memorizzare in modo sicuro il risultato della prima chiamata

Sì . strlen verrà calcolato ogni volta che aumenta i.

Se non hai cambiato ss con nel ciclo significa che non influenzerà la logica altrimenti influirà.

È più sicuro utilizzare il codice seguente.

int length = strlen(ss);

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

Sì, strlen(ss)calcolerà la lunghezza ad ogni iterazione. Se stai aumentando il ssin qualche modo e anche aumentando il i; ci sarebbe un ciclo infinito.

Sì, la strlen()funzione viene chiamata ogni volta che viene valutato il ciclo.

Se vuoi migliorare l'efficienza ricordati sempre di salvare tutto nelle variabili locali ... Ci vorrà tempo ma è molto utile ..

Puoi usare il codice come di seguito:

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

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

Sì, strlen(ss)verrà calcolato ogni volta che viene eseguito il codice.

Non comune al giorno d'oggi ma 20 anni fa su piattaforme a 16 bit, consiglierei questo:

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

Anche se il tuo compilatore non è molto intelligente nell'ottimizzazione, il codice sopra può risultare ancora in un buon codice assembly.

Sì. Il test non sa che ss non viene modificato all'interno del ciclo. Se sai che non cambierà, scriverei:

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

Arrgh, lo farà, anche in circostanze ideali, dannazione!

Ad oggi (gennaio 2018), e gcc 7.3 e clang 5.0, se compili:

#include <string.h>

void bar(char c);

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

Quindi, abbiamo:

• ss è un puntatore costante.
• ss è contrassegnato __restrict__
• Il corpo del loop non può in alcun modo toccare la memoria puntata da ss(beh, a meno che non violi il __restrict__).

e ancora , entrambi i compilatori eseguono strlen() ogni singola iterazione di quel ciclo . Sorprendente.

Ciò significa anche che le allusioni / i pio desiderio di @Praetorian e @JaredPar non hanno effetto.

SÌ, in parole semplici. E c'è un piccolo no in rare condizioni in cui il compilatore desidera, come passaggio di ottimizzazione se rileva che non sono state apportate modifiche ss. Ma in condizioni di sicurezza dovresti pensarlo come SÌ. Ci sono alcune situazioni come il programma in multithreadede event driven, potrebbe diventare difettoso se lo consideri un NO. Gioca sul sicuro perché non migliorerà troppo la complessità del programma.

Sì.

strlen()calcolato ogni volta che iaumenta e non si ottimizza.

Il codice seguente mostra perché il compilatore non dovrebbe ottimizzare strlen().

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

Possiamo facilmente testarlo:

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

La condizione del loop viene valutata dopo ogni ripetizione, prima di riavviare il loop.

Fai anche attenzione al tipo che usi per gestire la lunghezza delle stringhe. dovrebbe essere size_tche è stato definito come unsigned intin stdio. confrontarlo e trasmetterlo a intpotrebbe causare seri problemi di vulnerabilità.

beh, ho notato che qualcuno sta dicendo che è ottimizzato di default da qualsiasi compilatore moderno "intelligente". A proposito, guarda i risultati senza ottimizzazione. Ho provato:
codice C minimo:

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

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

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

Il mio compilatore: g ++ (Ubuntu / Linaro 4.6.3-1ubuntu5) 4.6.3
Comando per la generazione del codice assembly: 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 la risposta di Prætorian, consiglio quanto segue:

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

• autoperché non vuoi preoccuparti del tipo restituito da strlen. Un compilatore C ++ 11 (ad esempio gcc -std=c++0x, non completamente C ++ 11 ma i tipi auto funzionano) lo farà per te.
• i = strlen(s)perché vuoi confrontare con 0(vedi sotto)
• i > 0 perché il confronto con 0 è (leggermente) più veloce del confronto con qualsiasi altro numero.

lo svantaggio è che devi usare i-1per accedere ai caratteri della stringa.