Bir döngü koşulunda kullanılırsa strlen birden çok kez hesaplanacak mı?

Aşağıdaki kodun gereksiz hesaplamalara neden olup olamayacağından emin değilim, yoksa derleyiciye özel mi?

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

Will strlen()zaman her zaman hesaplanabilir iartar?

Evet, strlen()her yinelemede değerlendirilecektir. İdeal koşullar altında, optimizasyon uzmanının değerin değişmeyeceği sonucuna varması mümkündür, ancak ben şahsen buna güvenmem.

Gibi bir şey yaparım

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

veya muhtemelen

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

iterasyon sırasında dizenin uzunluğu değişmediği sürece. Mümkünse, strlen()her seferinde aramanız veya daha karmaşık mantıkla halledmeniz gerekir.

Evet, döngüyü her kullandığınızda. Daha sonra her seferinde dizginin uzunluğunu hesaplayacaktır. öyleyse şu şekilde kullanın:

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

Yukarıdaki kodda , döngü bir döngüyü her str[i]başlattığında konumdaki dizedeki yalnızca belirli bir karakteri doğrular i, böylece daha az bellek alır ve daha verimlidir.

Daha fazla bilgi için bu Bağlantıya bakın .

Aşağıdaki kodda, döngü her çalıştırıldığında strlen, daha az verimli olan, daha fazla zaman alan ve daha fazla bellek alan tüm dizenin uzunluğunu sayacaktır.

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

İyi bir derleyici bunu her seferinde hesaplamayabilir, ancak her derleyicinin bunu yaptığından emin olabileceğinizi sanmıyorum.

Buna ek olarak, derleyicinin bilmesi gerekir, bu strlen(ss)değişmez. Bu yalnızca döngüde ssdeğiştirilmezse geçerlidir for.

Üzerinde salt okunur işlevini kullanın Örneğin, ssiçinde fordöngü ama beyan yok ss-parametre olarak constbile bilemez derleyici, ssdöngü içinde değişti ve hesaplamak zorundadır değildir strlen(ss)her tekrarında.

Eğer sstiptedir const char *ve uzakta yayın yapmıyor constderleyici yalnızca diyebilirsiniz döngü içinde lık strlenoptimizasyonlar açıksa, bir kere. Ancak bu kesinlikle güvenilebilecek bir davranış değildir.

Sonucu strlenbir değişkene kaydetmeli ve bu değişkeni döngüde kullanmalısınız. Ek bir değişken oluşturmak istemiyorsanız, ne yaptığınıza bağlı olarak, geriye doğru yinelemek için döngüyü tersine çevirmekten kurtulabilirsiniz.

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

Resmen evet, strlen()her yinelemede çağrılması bekleniyor.

Her neyse, ilkinden sonraki strlen () 'e yapılan ardışık çağrıları ortadan kaldıracak bazı akıllı derleyici optimizasyonlarının var olma olasılığını reddetmek istemiyorum.

Yüklem kodu bütünüyle fordöngünün her yinelemesinde çalıştırılacaktır . Çağrının sonucunu ezberlemek için strlen(ss)derleyicinin en azından şunu bilmesi gerekir:

1. Fonksiyon strlenyan etkisizdi
2. İle gösterilen hafıza ssdöngü süresince değişmez

Derleyici bu iki şeyi de bilmiyor ve bu nedenle ilk çağrının sonucunu güvenli bir şekilde hatırlayamıyor.

Evet . strlen her zaman arttığımda hesaplanacak.

Eğer varsa ss değişmedi ile döngü içinde bu yollarla mantığını etkilemez aksi takdirde etkileyecektir.

Aşağıdaki kodu kullanmak daha güvenlidir.

int length = strlen(ss);

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

Evet, strlen(ss)her yinelemede uzunluğu hesaplayacaktır. Bir şekilde artırıyor ssve aynı zamanda artırıyorsanız i; sonsuz döngü olacaktır.

Evet, strlen()işlev denir her zaman döngü değerlendirilir.

Verimliliği artırmak istiyorsanız, her şeyi yerel değişkenlere kaydetmeyi her zaman unutmayın ... Zaman alacaktır ama çok yararlıdır ..

Kodu aşağıdaki gibi kullanabilirsiniz:

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

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

Evet, strlen(ss)kod her çalıştığında hesaplanacaktır.

Bugünlerde yaygın değil ama 20 yıl önce 16 bit platformlarda, şunu tavsiye ederim:

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

Derleyiciniz optimizasyon konusunda çok akıllı olmasa bile, yukarıdaki kod henüz iyi bir montaj koduyla sonuçlanabilir.

Evet. Test, ss'nin döngü içinde değişmediğini bilmiyor. Eğer değişmeyeceğini biliyorsanız, o zaman yazacağım:

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

Arrgh, ideal koşullarda bile kahretsin!

Bugün (Ocak 2018) ve gcc 7.3 ve clang 5.0 itibariyle, derlerseniz:

#include <string.h>

void bar(char c);

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

Böylece sahibiz:

• ss sabit bir göstericidir.
• ss işaretlendi __restrict__
• Döngü gövdesi hiçbir şekilde işaret edilen belleğe dokunamaz ss(iyi, ihlal etmediği sürece __restrict__).

ve yine de , her iki derleyici strlen() bu döngünün her bir yinelemesini yürütür . İnanılmaz.

Bu aynı zamanda @Praetorian ve @JaredPar'ın imaları / temenni düşüncelerinin işe yaramayacağı anlamına gelir.

EVET, basit bir deyişle. Ve derleyicinin içinde hiç değişiklik olmadığını fark ederse bir optimizasyon adımı olarak, nadiren de olsa küçük bir hayır yoktur ss. Ancak güvenli durumda EVET olarak düşünmelisiniz. multithreadedOlay güdümlü program gibi bazı durumlar vardır, bunu bir HAYIR olarak değerlendirirseniz hatalı olabilir. Program karmaşıklığını çok fazla geliştirmeyeceği için güvenli oynayın.

Evet.

strlen()iarttığında ve optimize edilmediğinde her seferinde hesaplanır .

Aşağıdaki kod, derleyicinin neden optimize etmemesi gerektiğini gösterir strlen().

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

Kolayca test edebiliriz:

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

Döngü koşulu, döngüyü yeniden başlatmadan önce her tekrardan sonra değerlendirilir.

Ayrıca, dizelerin uzunluğunu işlemek için kullandığınız tür konusunda dikkatli olun. standart size_tolarak tanımlanmış olması gerekir unsigned int. karşılaştırmak ve dönüştürmek intbazı ciddi güvenlik açığı sorunlarına neden olabilir.

Pekala, birinin varsayılan olarak herhangi bir "akıllı" modern derleyici tarafından optimize edildiğini söylediğini fark ettim. Bu arada, sonuçlara optimizasyon yapmadan bakın. Denedim:
Minimum C kodu:

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

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

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

Derleyicim: g ++ (Ubuntu / Linaro 4.6.3-1ubuntu5) 4.6.3
Derleme kodu oluşturma komutu: 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
     .....

Prætorian'ın cevabını detaylandırırken şunları tavsiye ederim:

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

• autoçünkü strlen'in hangi türden döndüğünü umursamak istemezsiniz. Bir C ++ 11 derleyicisi (örneğin gcc -std=c++0x, tamamen C ++ 11 değil, otomatik türler çalışır) sizin için bunu yapacaktır.
• i = strlen(s)karşılaştırmak istediğiniz için 0(aşağıya bakın)
• i > 0 çünkü 0 ile karşılaştırma, diğer herhangi bir sayıya kıyasla (biraz) daha hızlıdır.

dezavantajı, i-1dize karakterlerine erişmek için kullanmanız gerekmesidir.