Strlen sẽ được tính nhiều lần nếu được sử dụng trong một điều kiện lặp lại?

Tôi không chắc liệu mã sau có thể gây ra các phép tính dư thừa hay nó dành riêng cho trình biên dịch?

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

Sẽ strlen()được tính toán mỗi khi ităng?

Có, strlen()sẽ được đánh giá trên mỗi lần lặp. Có thể trong những trường hợp lý tưởng, người tối ưu có thể suy ra rằng giá trị sẽ không thay đổi, nhưng cá nhân tôi sẽ không dựa vào điều đó.

Tôi muốn làm một cái gì đó giống như

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

hoặc có thể

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

miễn là chuỗi sẽ không thay đổi độ dài trong quá trình lặp. Nếu nó có thể xảy ra, thì bạn sẽ cần phải gọi strlen()mỗi lần hoặc xử lý nó thông qua logic phức tạp hơn.

Có, mỗi khi bạn sử dụng vòng lặp. Sau đó, nó sẽ mỗi lần tính toán độ dài của chuỗi. vì vậy hãy sử dụng nó như thế này:

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

Trong đoạn mã trên str[i]chỉ xác minh một ký tự cụ thể trong chuỗi tại vị trí imỗi khi vòng lặp bắt đầu một chu kỳ, do đó nó sẽ tốn ít bộ nhớ hơn và hiệu quả hơn.

Xem Liên kết này để biết thêm thông tin.

Trong đoạn mã dưới đây mỗi khi vòng lặp chạy strlensẽ đếm độ dài của cả chuỗi kém hiệu quả hơn, tốn nhiều thời gian hơn và tốn nhiều bộ nhớ hơn.

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

Một trình biên dịch tốt có thể không tính toán nó mọi lúc, nhưng tôi không nghĩ bạn có thể chắc chắn rằng mọi trình biên dịch đều làm được điều đó.

Thêm vào đó, trình biên dịch phải biết, điều strlen(ss)đó không thay đổi. Điều này chỉ đúng nếu sskhông được thay đổi trong forvòng lặp.

Ví dụ: nếu bạn sử dụng một hàm chỉ đọc sstrong forvòng lặp nhưng không khai báo ss-parameter const, trình biên dịch thậm chí không thể biết rằng ssnó không được thay đổi trong vòng lặp và phải tính toán strlen(ss)trong mỗi lần lặp.

Nếu ssthuộc loại const char *và bạn không loại bỏ sự constphức tạp trong vòng lặp, trình biên dịch có thể chỉ gọi strlenmột lần, nếu tính năng tối ưu hóa được bật. Nhưng đây chắc chắn không phải là hành vi có thể được tính đến.

Bạn nên lưu strlenkết quả trong một biến và sử dụng biến này trong vòng lặp. Nếu bạn không muốn tạo một biến bổ sung, tùy thuộc vào những gì bạn đang làm, bạn có thể thoát khỏi việc đảo ngược vòng lặp để lặp lại.

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

Về mặt chính thức là có, strlen()dự kiến ​​sẽ được gọi cho mỗi lần lặp lại.

Dù sao, tôi không muốn phủ nhận khả năng tồn tại của một số tối ưu hóa trình biên dịch thông minh, điều đó sẽ tối ưu hóa bất kỳ lệnh gọi liên tiếp nào đến strlen () sau lệnh đầu tiên.

Toàn bộ mã vị từ sẽ được thực thi trên mỗi lần lặp lại của forvòng lặp. Để ghi nhớ kết quả của strlen(ss)cuộc gọi, trình biên dịch cần biết rằng ít nhất

1. Chức năng không strlencó tác dụng phụ
2. Bộ nhớ được trỏ đến sskhông thay đổi trong suốt thời gian của vòng lặp

Trình biên dịch không biết một trong hai điều này và do đó không thể ghi nhớ một cách an toàn kết quả của lần gọi đầu tiên

Vâng . strlen sẽ được tính toán mọi lúc khi tôi tăng.

Nếu bạn không thay đổi ss bằng trong vòng lặp có nghĩa là nó sẽ không ảnh hưởng đến logic nếu không nó sẽ ảnh hưởng.

Sẽ an toàn hơn khi sử dụng mã sau.

int length = strlen(ss);

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

Có, strlen(ss)sẽ tính toán độ dài ở mỗi lần lặp. Nếu bạn đang tăng sstheo một cách nào đó và cũng đang tăng i; sẽ có vòng lặp vô hạn.

Có, strlen()hàm được gọi mỗi khi vòng lặp được đánh giá.

Nếu bạn muốn nâng cao hiệu quả thì hãy luôn nhớ lưu mọi thứ trong các biến cục bộ ... Sẽ mất thời gian nhưng nó rất hữu ích ..

Bạn có thể sử dụng mã như dưới đây:

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

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

Có, strlen(ss)sẽ được tính toán mỗi khi mã chạy.

Ngày nay không phổ biến nhưng 20 năm trước trên các nền tảng 16 bit, tôi khuyên bạn nên sử dụng điều này:

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

Ngay cả khi trình biên dịch của bạn không quá thông minh trong việc tối ưu hóa, đoạn mã trên có thể dẫn đến mã lắp ráp tốt.

Đúng. Kiểm tra không biết rằng ss không bị thay đổi bên trong vòng lặp. Nếu bạn biết rằng nó sẽ không thay đổi thì tôi sẽ viết:

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

Arrgh, nó sẽ, ngay cả trong những hoàn cảnh lý tưởng, chết tiệt!

Kể từ hôm nay (tháng 1 năm 2018), và gcc 7.3 và clang 5.0, nếu bạn biên dịch:

#include <string.h>

void bar(char c);

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

Vì vậy chúng tôi có:

• ss là một con trỏ hằng.
• ss Chấm điểm __restrict__
• Phần thân vòng lặp không thể chạm vào bộ nhớ được trỏ tới theo bất kỳ cách nào ss(tốt, trừ khi nó vi phạm __restrict__).

và vẫn còn , cả hai trình biên dịch đều thực thi strlen() mọi lần lặp lại của vòng lặp đó . Kinh ngạc.

Điều này cũng có nghĩa là những ám chỉ / mơ tưởng về @Praetorian và @JaredPar không xuất hiện.

CÓ, nói một cách đơn giản. Và hiếm có điều kiện nhỏ nào mà trình biên dịch mong muốn, như một bước tối ưu hóa nếu nó nhận thấy rằng không có thay đổi nào được thực hiện ss. Nhưng trong điều kiện an toàn, bạn nên nghĩ là CÓ. Có một số tình huống như trong multithreadedvà chương trình điều khiển sự kiện, nó có thể bị lỗi nếu bạn coi đó là KHÔNG. Chơi an toàn vì nó sẽ không cải thiện độ phức tạp của chương trình quá nhiều.

Đúng.

strlen()tính toán mọi lúc khi ităng và không được tối ưu hóa.

Đoạn mã dưới đây cho thấy lý do tại sao trình biên dịch không nên tối ưu hóa strlen().

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

Chúng tôi có thể dễ dàng kiểm tra nó:

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

Điều kiện vòng lặp đánh giá sau mỗi lần lặp lại, trước khi bắt đầu lại vòng lặp.

Ngoài ra, hãy cẩn thận về loại bạn sử dụng để xử lý độ dài của chuỗi. nó phải size_tđược định nghĩa như unsigned inttrong stdio. so sánh và truyền nó tới intcó thể gây ra một số vấn đề về lỗ hổng nghiêm trọng.

tốt, tôi nhận thấy rằng ai đó đang nói rằng nó được tối ưu hóa theo mặc định bởi bất kỳ trình biên dịch hiện đại "thông minh" nào. Nhân tiện nhìn vào kết quả mà không cần tối ưu hóa. Tôi đã thử:
Mã C tối thiểu:

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

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

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

Trình biên dịch của tôi: g ++ (Ubuntu / Linaro 4.6.3-1ubuntu5) 4.6.3
Lệnh để tạo mã lắp ráp: 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
     .....

Xây dựng câu trả lời của Prætorian, tôi khuyên bạn nên làm như sau:

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

• autobởi vì bạn không muốn quan tâm đến việc trả về kiểu strlen nào. Trình biên dịch C ++ 11 (ví dụ: gcc -std=c++0xkhông hoàn toàn C ++ 11 nhưng các kiểu tự động hoạt động) sẽ làm điều đó cho bạn.
• i = strlen(s)vì bạn muốn so sánh với 0(xem bên dưới)
• i > 0 bởi vì so sánh với 0 nhanh hơn (một chút) so với bất kỳ số nào khác.

bất lợi là bạn phải sử dụng i-1để truy cập các ký tự chuỗi.