strlen จะถูกคำนวณหลายครั้งหากใช้ในเงื่อนไขการวนซ้ำ?

ฉันไม่แน่ใจว่าโค้ดต่อไปนี้อาจทำให้เกิดการคำนวณซ้ำซ้อนหรือเป็นรหัสเฉพาะของคอมไพเลอร์

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

จะstrlen()คำนวณทุกครั้งเมื่อiเพิ่มขึ้น?

ใช่strlen()จะได้รับการประเมินในการทำซ้ำแต่ละครั้ง เป็นไปได้ว่าภายใต้สถานการณ์ที่เหมาะสมเครื่องมือเพิ่มประสิทธิภาพอาจอนุมานได้ว่าค่าจะไม่เปลี่ยนแปลง แต่โดยส่วนตัวแล้วฉันจะไม่พึ่งพาสิ่งนั้น

ฉันจะทำสิ่งที่ชอบ

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

หรืออาจเป็นไปได้

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

ตราบเท่าที่สตริงจะไม่เปลี่ยนความยาวระหว่างการวนซ้ำ หากเป็นไปได้คุณจะต้องโทรstrlen()ทุกครั้งหรือจัดการด้วยตรรกะที่ซับซ้อนมากขึ้น

ใช่ทุกครั้งที่คุณใช้ลูป จากนั้นทุกครั้งจะคำนวณความยาวของสตริง ดังนั้นใช้มันดังนี้:

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

ในโค้ดด้านบนstr[i]จะตรวจสอบเฉพาะอักขระหนึ่งตัวในสตริงที่ตำแหน่งiแต่ละครั้งที่ลูปเริ่มรอบดังนั้นจึงใช้หน่วยความจำน้อยลงและมีประสิทธิภาพมากขึ้น

ดูลิงค์นี้สำหรับข้อมูลเพิ่มเติม

ในโค้ดด้านล่างทุกครั้งที่ลูปทำงานstrlenจะนับความยาวของสตริงทั้งหมดซึ่งมีประสิทธิภาพน้อยกว่าใช้เวลามากขึ้นและใช้หน่วยความจำมากขึ้น

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

คอมไพเลอร์ที่ดีอาจไม่คำนวณทุกครั้ง แต่ฉันไม่คิดว่าคุณจะแน่ใจได้ว่าคอมไพเลอร์ทุกตัวทำอย่างนั้น

นอกเหนือจากนั้นคอมไพเลอร์ต้องรู้ว่าstrlen(ss)ไม่เปลี่ยนแปลง นี่จะเป็นจริงssก็ต่อเมื่อไม่มีการเปลี่ยนforลูป

ตัวอย่างเช่นถ้าคุณใช้ฟังก์ชันแบบอ่านอย่างเดียวssในforลูป แต่ไม่ประกาศss-parameter เป็นconstคอมไพลเลอร์จะไม่รู้ด้วยซ้ำว่าssไม่มีการเปลี่ยนแปลงในลูปและต้องคำนวณstrlen(ss)ในการวนซ้ำทุกครั้ง

หากssเป็นประเภทconst char *และคุณไม่ได้ส่งconstness ออกไปภายในลูปคอมไพลเลอร์อาจเรียกใช้เพียงstrlenครั้งเดียวหากเปิดการเพิ่มประสิทธิภาพไว้ แต่นี่ไม่ใช่พฤติกรรมที่สามารถนับได้อย่างแน่นอน

คุณควรบันทึกstrlenผลลัพธ์ในตัวแปรและใช้ตัวแปรนี้ในลูป หากคุณไม่ต้องการสร้างตัวแปรเพิ่มเติมขึ้นอยู่กับสิ่งที่คุณกำลังทำอยู่คุณอาจต้องหลีกหนีจากการย้อนกลับของลูปเพื่อวนซ้ำไปข้างหลัง

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

ใช่อย่างเป็นทางการstrlen()คาดว่าจะถูกเรียกให้ทำซ้ำทุกครั้ง

อย่างไรก็ตามฉันไม่ต้องการลบล้างความเป็นไปได้ของการมีอยู่ของการเพิ่มประสิทธิภาพคอมไพเลอร์ที่ชาญฉลาดซึ่งจะเพิ่มประสิทธิภาพการเรียกใช้ strlen () ที่ต่อเนื่องกันหลังจากครั้งแรก

รหัสเพรดิเคตทั้งหมดจะถูกเรียกใช้งานทุกครั้งที่forวนซ้ำ เพื่อที่จะจดจำผลลัพธ์ของการstrlen(ss)เรียกคอมไพเลอร์จะต้องรู้อย่างน้อยที่สุด

1. ฟังก์ชั่นstrlenนี้ไม่มีผลข้างเคียง
2. หน่วยความจำที่ชี้โดยssจะไม่เปลี่ยนแปลงตลอดระยะเวลาของการวนซ้ำ

คอมไพเลอร์ไม่ทราบสิ่งเหล่านี้และด้วยเหตุนี้จึงไม่สามารถบันทึกผลลัพธ์ของการโทรครั้งแรกได้อย่างปลอดภัย

ครับ . strlen จะคำนวณทุกครั้งเมื่อฉันเพิ่มขึ้น

หากคุณไม่ได้เปลี่ยน ssด้วยในลูปหมายความว่าจะไม่มีผลต่อตรรกะมิฉะนั้นจะมีผล

การใช้รหัสต่อไปนี้ปลอดภัยกว่า

int length = strlen(ss);

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

ใช่strlen(ss)จะคำนวณความยาวในการวนซ้ำแต่ละครั้ง หากคุณเพิ่มขึ้นssโดยวิธีใดวิธีหนึ่งและยังเพิ่มi; จะมีการวนซ้ำไม่สิ้นสุด

ใช่strlen()ฟังก์ชันจะถูกเรียกทุกครั้งที่มีการประเมินลูป

หากคุณต้องการปรับปรุงประสิทธิภาพอย่าลืมบันทึกทุกอย่างในตัวแปรท้องถิ่น ... จะใช้เวลา แต่มีประโยชน์มาก ..

คุณสามารถใช้รหัสดังต่อไปนี้:

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

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

ใช่strlen(ss)จะคำนวณทุกครั้งที่รหัสทำงาน

ไม่ธรรมดาในปัจจุบัน แต่เมื่อ 20 ปีที่แล้วบนแพลตฟอร์ม 16 บิตฉันขอแนะนำสิ่งนี้:

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

แม้ว่าคอมไพลเลอร์ของคุณจะไม่ฉลาดในการเพิ่มประสิทธิภาพ แต่โค้ดด้านบนอาจส่งผลให้โค้ดแอสเซมบลีที่ดีได้

ใช่. การทดสอบไม่ทราบว่า ss ไม่ได้รับการเปลี่ยนแปลงภายในลูป ถ้าคุณรู้ว่ามันจะไม่เปลี่ยนแปลงฉันจะเขียนว่า:

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

อ๊ะมันจะแม้ภายใต้สถานการณ์ที่ดีเยี่ยม!

ณ วันนี้ (มกราคม 2018) และ gcc 7.3 และ clang 5.0 หากคุณรวบรวม:

#include <string.h>

void bar(char c);

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

ดังนั้นเรามี:

• ss เป็นตัวชี้ค่าคงที่
• ss ถูกทำเครื่องหมาย __restrict__
• เนื้อลูปไม่สามารถสัมผัสกับหน่วยความจำที่ชี้ไปด้วยวิธีใด ๆss(ดีเว้นแต่จะละเมิด__restrict__)

และยังคงมีทั้งคอมไพเลอร์รันทุกย้ำเดียวของวงว่าstrlen() น่าอัศจรรย์.

นอกจากนี้ยังหมายถึงการพาดพิง / ความคิดปรารถนาของ @Praetorian และ @JaredPar ไม่ได้หลุดออกไป

ใช่พูดง่ายๆ และไม่มีขนาดเล็กในสภาพที่ไม่ค่อยพบในคอมไพเลอร์ที่ต้องการเป็นขั้นตอนการปรับให้เหมาะสมหากพบว่าไม่มีการเปลี่ยนแปลงใดssๆ เลย แต่ในสภาพที่ปลอดภัยคุณควรคิดว่าใช่ มีบางสถานการณ์เช่นในmultithreadedและโปรแกรมที่ขับเคลื่อนด้วยเหตุการณ์อาจมีปัญหาหากคุณพิจารณาว่าเป็นไม่ใช่ เล่นอย่างปลอดภัยเนื่องจากจะไม่ปรับปรุงความซับซ้อนของโปรแกรมมากเกินไป

ใช่.

strlen()คำนวณทุกครั้งเมื่อiเพิ่มขึ้นและไม่ได้รับการปรับให้เหมาะสม

strlen()ด้านล่างนี้แสดงให้เห็นว่าทำไมรหัสคอมไพเลอร์ไม่ควรเพิ่มประสิทธิภาพ

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

เราสามารถทดสอบได้อย่างง่ายดาย:

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

เงื่อนไขการวนซ้ำจะประเมินหลังจากการทำซ้ำแต่ละครั้งก่อนที่จะเริ่มการวนซ้ำ

นอกจากนี้โปรดระวังประเภทที่คุณใช้จัดการความยาวของสตริงด้วย ควรเป็นsize_tสิ่งที่กำหนดไว้unsigned intใน stdio การเปรียบเทียบและส่งไปยังintอาจทำให้เกิดปัญหาช่องโหว่ที่ร้ายแรง

ฉันสังเกตเห็นว่ามีคนบอกว่ามันได้รับการปรับให้เหมาะสมโดยค่าเริ่มต้นโดยคอมไพเลอร์สมัยใหม่ที่ "ฉลาด" โดยดูที่ผลลัพธ์โดยไม่ต้องปรับให้เหมาะสม ฉันพยายาม:
รหัส C ขั้นต่ำ:

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

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

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

คอมไพเลอร์ของฉัน: g ++ (Ubuntu / Linaro 4.6.3-1ubuntu5) 4.6.3
คำสั่งสำหรับการสร้างรหัสแอสเซมบลี: 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ฉันขอแนะนำสิ่งต่อไปนี้:

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

• autoเพราะคุณไม่ต้องการสนใจว่า strlen จะส่งคืนแบบไหน คอมไพเลอร์ C ++ 11 (เช่นgcc -std=c++0xC ++ 11 ไม่สมบูรณ์ แต่ประเภทอัตโนมัติทำงานได้) จะทำเช่นนั้นให้คุณ
• i = strlen(s)เพราะคุณต้องการเปรียบเทียบกับ0(ดูด้านล่าง)
• i > 0 เนื่องจากการเปรียบเทียบกับ 0 นั้นเร็วกว่า (เล็กน้อย) เมื่อเปรียบเทียบกับตัวเลขอื่น ๆ

ข้อเสียคือคุณต้องใช้i-1เพื่อเข้าถึงอักขระสตริง