Wird strlen mehrfach berechnet, wenn es in einer Schleifenbedingung verwendet wird?

Ich bin nicht sicher, ob der folgende Code redundante Berechnungen verursachen kann oder ob er compilerspezifisch ist.

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

Wird strlen()jedes Mal berechnet, wenn ierhöht?

Ja, strlen()wird bei jeder Iteration ausgewertet. Unter idealen Umständen kann der Optimierer möglicherweise ableiten, dass sich der Wert nicht ändert, aber ich persönlich würde mich nicht darauf verlassen.

Ich würde so etwas tun

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

oder möglicherweise

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

Solange sich die Länge der Zeichenfolge während der Iteration nicht ändert. Wenn dies der Fall sein könnte, müssen Sie entweder strlen()jedes Mal aufrufen oder die kompliziertere Logik verwenden.

Ja, jedes Mal, wenn Sie die Schleife verwenden. Dann wird jedes Mal die Länge der Zeichenfolge berechnet. Verwenden Sie es also folgendermaßen:

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

Im obigen Code wird jedes Mal, wenn die Schleife einen Zyklus startet, str[i]nur ein bestimmtes Zeichen in der Zeichenfolge an der Stelle überprüft i, wodurch weniger Speicher benötigt wird und dies effizienter ist.

Weitere Informationen finden Sie unter diesem Link .

Im folgenden Code wird jedes Mal, wenn die Schleife ausgeführt strlenwird, die Länge der gesamten Zeichenfolge gezählt, was weniger effizient ist, mehr Zeit und mehr Speicher benötigt.

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

Ein guter Compiler berechnet es möglicherweise nicht jedes Mal, aber ich glaube nicht, dass Sie sicher sein können, dass jeder Compiler es tut.

Darüber hinaus muss der Compiler wissen, dass sich strlen(ss)dies nicht ändert. Dies gilt nur, wenn ssdie forSchleife nicht geändert wird.

Wenn Sie beispielsweise eine schreibgeschützte Funktion ssin der forSchleife verwenden, aber den ssParameter- nicht als deklarieren const, kann der Compiler nicht einmal wissen, dass ssdies in der Schleife nicht geändert wird, und muss strlen(ss)in jeder Iteration berechnen .

Wenn dies ssvom Typ ist const char *und Sie die constNess innerhalb der Schleife nicht wegwerfen, ruft der Compiler möglicherweise nur strleneinmal auf, wenn Optimierungen aktiviert sind. Dies ist aber sicherlich kein Verhalten, auf das man zählen kann.

Sie sollten das strlenErgebnis in einer Variablen speichern und diese Variable in der Schleife verwenden. Wenn Sie keine zusätzliche Variable erstellen möchten, je nachdem, was Sie tun, müssen Sie möglicherweise die Schleife umkehren, um rückwärts zu iterieren.

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

Formal ja, strlen()wird erwartet, dass für jede Iteration aufgerufen wird.

Auf jeden Fall möchte ich die Möglichkeit einer cleveren Compiler-Optimierung nicht negieren, die jeden aufeinanderfolgenden Aufruf von strlen () nach dem ersten optimiert.

Der gesamte Prädikatcode wird bei jeder Iteration der forSchleife ausgeführt. Um das Ergebnis des strlen(ss)Aufrufs zu speichern, müsste der Compiler dies zumindest wissen

1. Die Funktion strlenwar nebenwirkungsfrei
2. Der Speicher, auf den von sszeigt, ändert sich für die Dauer der Schleife nicht

Der Compiler kennt keines dieser Dinge und kann sich daher das Ergebnis des ersten Aufrufs nicht sicher merken

Ja . strlen wird jedes Mal berechnet, wenn ich mich erhöhe.

Wenn Sie nicht ss änderte sich mit der Schleife Mittel es nicht Logik beeinflussen sonst wird es beeinflussen.

Es ist sicherer, folgenden Code zu verwenden.

int length = strlen(ss);

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

Ja, der strlen(ss)berechnet die Länge bei jeder Iteration. Wenn Sie das ssauf irgendeine Weise erhöhen und auch das erhöhen i; es würde eine Endlosschleife geben.

Ja, die strlen()Funktion wird jedes Mal aufgerufen, wenn die Schleife ausgewertet wird.

Wenn Sie die Effizienz verbessern möchten, denken Sie immer daran, alles in lokalen Variablen zu speichern ... Es wird einige Zeit dauern, aber es ist sehr nützlich.

Sie können den folgenden Code verwenden:

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

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

Ja, strlen(ss)wird jedes Mal berechnet, wenn der Code ausgeführt wird.

Heutzutage nicht üblich, aber vor 20 Jahren auf 16-Bit-Plattformen würde ich Folgendes empfehlen:

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

Selbst wenn Ihr Compiler bei der Optimierung nicht sehr klug ist, kann der obige Code noch zu einem guten Assemblycode führen.

Ja. Der Test weiß nicht, dass ss innerhalb der Schleife nicht geändert wird. Wenn Sie wissen, dass es sich nicht ändern wird, würde ich schreiben:

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

Arrgh, es wird auch unter idealen Umständen verdammt!

Ab heute (Januar 2018) und gcc 7.3 und clang 5.0, wenn Sie kompilieren:

#include <string.h>

void bar(char c);

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

Also haben wir:

• ss ist ein konstanter Zeiger.
• ss ist markiert __restrict__
• Der Schleifenkörper kann den Speicher, auf den er zeigt, in keiner Weise berühren ss(naja, es sei denn, er verletzt den __restrict__).

und dennoch führen beide Compiler strlen() jede einzelne Iteration dieser Schleife aus . Tolle.

Dies bedeutet auch, dass die Anspielungen / Wunschdenken von @Praetorian und @JaredPar nicht auftauchen.

JA, in einfachen Worten. Und es gibt ein kleines Nein in seltenen Fällen, in dem der Compiler dies wünscht, als Optimierungsschritt, wenn er feststellt, dass überhaupt keine Änderungen vorgenommen wurden ss. Aber in sicherem Zustand sollten Sie es als JA betrachten. Es gibt Situationen wie in multithreadedund ereignisgesteuerte Programme, es kann fehlerhaft werden, wenn Sie es als NEIN betrachten. Gehen Sie auf Nummer sicher, da dies die Programmkomplexität nicht zu stark verbessern wird.

Ja.

strlen()wird jedes Mal berechnet, wenn ierhöht und nicht optimiert.

Der folgende Code zeigt, warum der Compiler nicht optimieren sollte strlen().

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

Wir können es leicht testen:

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

Die Schleifenbedingung wird nach jeder Wiederholung ausgewertet, bevor die Schleife neu gestartet wird.

Achten Sie auch auf den Typ, mit dem Sie die Länge der Zeichenfolgen verarbeiten. es sollte das sein, size_twas wie unsigned intin stdio definiert wurde. Das Vergleichen und Casting kann zu intschwerwiegenden Sicherheitslücken führen.

Nun, ich habe bemerkt, dass jemand sagt, dass es standardmäßig von jedem "cleveren" modernen Compiler optimiert wird. Übrigens Ergebnisse ohne Optimierung betrachten. Ich habe versucht:
Minimaler C-Code:

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

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

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

Mein Compiler: g ++ (Ubuntu / Linaro 4.6.3-1ubuntu5) 4.6.3
Befehl zur Generierung von Assembler-Code: 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
     .....

Ich gehe auf Prætorians Antwort ein und empfehle Folgendes:

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

• autoweil Sie sich nicht darum kümmern möchten, welcher Typ strlen zurückgibt. Ein C ++ 11-Compiler (z. B. gcc -std=c++0xnicht vollständig C ++ 11, aber automatische Typen funktionieren) erledigt dies für Sie.
• i = strlen(s)weil Sie mit vergleichen möchten 0(siehe unten)
• i > 0 weil der Vergleich mit 0 (etwas) schneller ist als der Vergleich mit einer anderen Zahl.

Nachteil ist, dass Sie verwenden müssen, i-1um auf die Zeichenfolgen zuzugreifen.