Akankah strlen dihitung beberapa kali jika digunakan dalam kondisi loop?

Saya tidak yakin apakah kode berikut dapat menyebabkan kalkulasi yang berlebihan, atau apakah itu khusus kompiler?

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

Akan strlen()dihitung setiap kali ikenaikan?

Ya, strlen()akan dievaluasi pada setiap iterasi. Ada kemungkinan bahwa, dalam keadaan ideal, pengoptimal mungkin dapat menyimpulkan bahwa nilainya tidak akan berubah, tetapi saya pribadi tidak akan bergantung pada itu.

Saya akan melakukan sesuatu seperti

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

atau mungkin

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

selama string tidak akan berubah panjang selama iterasi. Jika mungkin, Anda harus menelepon strlen()setiap kali, atau menanganinya melalui logika yang lebih rumit.

Ya, setiap kali Anda menggunakan loop. Maka itu akan setiap kali menghitung panjang string. jadi gunakan seperti ini:

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

Pada kode di atas str[i]hanya memverifikasi satu karakter tertentu dalam string di lokasi isetiap kali loop memulai siklus, sehingga akan memakan lebih sedikit memori dan lebih efisien.

Lihat Tautan ini untuk informasi lebih lanjut.

Pada kode di bawah ini setiap kali loop berjalan strlenakan menghitung panjang keseluruhan string yang kurang efisien, membutuhkan lebih banyak waktu dan membutuhkan lebih banyak memori.

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

Kompiler yang baik mungkin tidak menghitungnya setiap saat, tetapi menurut saya Anda tidak dapat memastikan, bahwa setiap kompiler melakukannya.

Selain itu, kompilator harus tahu, itu strlen(ss)tidak berubah. Ini hanya benar jika sstidak diubah dalam forloop.

Misalnya, jika Anda menggunakan fungsi hanya-baca di ssdalam forperulangan tetapi tidak mendeklarasikan ss-parameter sebagai const, kompilator bahkan tidak dapat mengetahui bahwa sstidak diubah dalam perulangan dan harus menghitung strlen(ss)di setiap iterasi.

Jika ssadalah tipe const char *dan Anda tidak membuang semua kebutuhan constdalam loop, kompilator mungkin hanya memanggil strlensekali, jika pengoptimalan dihidupkan. Tapi ini jelas bukan perilaku yang bisa diandalkan.

Anda harus menyimpan strlenhasilnya dalam sebuah variabel dan menggunakan variabel ini dalam perulangan. Jika Anda tidak ingin membuat variabel tambahan, tergantung pada apa yang Anda lakukan, Anda mungkin bisa melakukannya dengan membalik loop untuk mengulang ke belakang.

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

Secara formal ya, strlen()diharapkan dipanggil untuk setiap iterasi.

Bagaimanapun saya tidak ingin meniadakan kemungkinan adanya beberapa optimasi kompilator pintar, yang akan mengoptimalkan panggilan berurutan ke strlen () setelah yang pertama.

Kode predikat secara keseluruhan akan dieksekusi pada setiap iterasi forloop. Untuk mengingat hasil strlen(ss)panggilan, kompilator perlu mengetahui hal itu setidaknya

1. Fungsinya strlenbebas efek samping
2. Memori yang ditunjukkan oleh sstidak berubah selama durasi loop

Kompilator tidak mengetahui salah satu dari hal-hal ini dan karenanya tidak dapat dengan aman membuat memo hasil panggilan pertama

Iya . strlen akan dihitung setiap kali saya meningkat.

Jika Anda tidak mengubah ss dengan in loop berarti itu tidak akan mempengaruhi logika jika tidak maka akan mempengaruhi.

Lebih aman menggunakan kode berikut.

int length = strlen(ss);

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

Ya, perusahaan strlen(ss)akan menghitung panjang pada setiap iterasi. Jika Anda meningkatkan ssdengan cara tertentu dan juga meningkatkan i; akan ada putaran tak terbatas.

Ya, strlen()fungsinya dipanggil setiap kali loop dievaluasi.

Jika Anda ingin meningkatkan efisiensi maka selalu ingat untuk menyimpan semuanya di variabel lokal ... Ini akan memakan waktu tetapi sangat berguna ..

Anda dapat menggunakan kode seperti di bawah ini:

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

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

Ya, strlen(ss)akan dihitung setiap kali kode dijalankan.

Tidak umum saat ini tetapi 20 tahun yang lalu pada platform 16 bit, saya merekomendasikan ini:

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

Bahkan jika kompiler Anda tidak terlalu pintar dalam pengoptimalan, kode di atas dapat menghasilkan kode assembly yang bagus.

Iya. Pengujian tidak mengetahui bahwa ss tidak berubah di dalam loop. Jika Anda tahu bahwa itu tidak akan berubah maka saya akan menulis:

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

Ah, itu akan, bahkan dalam keadaan ideal, sialan!

Mulai hari ini (Januari 2018), dan gcc 7.3 dan clang 5.0, jika Anda mengompilasi:

#include <string.h>

void bar(char c);

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

Jadi kita punya:

• ss adalah penunjuk konstan.
• ss ditandai __restrict__
• Badan loop tidak dapat menyentuh memori yang ditunjukkan oleh ss(yah, kecuali jika melanggar __restrict__).

dan tetap saja , kedua kompiler mengeksekusi strlen() setiap iterasi loop tersebut . Luar biasa.

Ini juga berarti kiasan / angan-angan dari @Praetorian dan @JaredPar tidak berjalan dengan baik.

YA, dengan kata sederhana. Dan ada sedikit kata tidak dalam kondisi langka di mana kompilator menginginkannya, sebagai langkah pengoptimalan jika ternyata tidak ada perubahan sssama sekali. Tetapi dalam kondisi aman Anda harus menganggapnya YA. Ada beberapa situasi seperti in multithreadeddan event driven program, ini mungkin bermasalah jika Anda menganggapnya TIDAK. Lakukan dengan aman karena tidak akan terlalu meningkatkan kompleksitas program.

Iya.

strlen()dihitung setiap saat imeningkat dan tidak dioptimalkan.

Kode di bawah ini menunjukkan mengapa kompilator tidak harus dioptimalkan strlen().

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

Kami dapat dengan mudah mengujinya:

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

Kondisi loop mengevaluasi setelah setiap pengulangan, sebelum mengulang loop.

Juga berhati-hatilah dengan jenis yang Anda gunakan untuk menangani panjang string. itu harus size_tyang telah didefinisikan seperti unsigned intdi stdio. membandingkan dan mentransmisikannya intmungkin menyebabkan beberapa masalah kerentanan yang serius.

well, saya perhatikan bahwa seseorang mengatakan bahwa ini dioptimalkan secara default oleh kompiler modern "pintar". Dengan cara melihat hasil tanpa pengoptimalan. Saya mencoba:
Kode C Minimal:

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

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

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

Kompiler saya: g ++ (Ubuntu / Linaro 4.6.3-1ubuntu5) 4.6.3
Perintah untuk pembuatan kode 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
     .....

Menguraikan jawaban Prætorian, saya merekomendasikan yang berikut ini:

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

• autokarena Anda tidak ingin peduli tentang tipe mana yang dikembalikan strlen. Kompiler C ++ 11 (misalnya gcc -std=c++0x, tidak sepenuhnya C ++ 11 tetapi tipe otomatis berfungsi) akan melakukannya untuk Anda.
• i = strlen(s)karena Anda ingin membandingkan 0(lihat di bawah)
• i > 0 karena perbandingan dengan 0 (sedikit) lebih cepat dibandingkan dengan angka lainnya.

kelemahannya adalah Anda harus menggunakan i-1untuk mengakses karakter string.