Có chi phí nào để khai báo một biến trong vòng lặp không? (C ++)

Tôi chỉ tự hỏi liệu có mất tốc độ hoặc hiệu quả không nếu bạn làm điều gì đó như sau:

int i = 0;
while(i < 100)
{
    int var = 4;
    i++;
}

mà tuyên bố int varmột trăm lần. Đối với tôi dường như sẽ có, nhưng tôi không chắc. thay vào đó sẽ thực tế hơn / nhanh hơn:

int i = 0;
int var;
while(i < 100)
{
    var = 4;
    i++;
}

hay chúng giống nhau, cùng tốc độ và hiệu quả?

Không gian ngăn xếp cho các biến cục bộ thường được cấp phát trong phạm vi hàm. Vì vậy, không có điều chỉnh con trỏ ngăn xếp nào xảy ra bên trong vòng lặp, chỉ cần gán 4 cho var. Do đó hai đoạn mã này có cùng chi phí.

Đối với các kiểu nguyên thủy và kiểu POD, nó không có gì khác biệt. Trình biên dịch sẽ cấp phát không gian ngăn xếp cho biến ở đầu hàm và phân bổ nó khi hàm trả về trong cả hai trường hợp.

Đối với các loại lớp không phải POD có các hàm tạo không tầm thường, nó SẼ tạo ra sự khác biệt - trong trường hợp đó, việc đặt biến bên ngoài vòng lặp sẽ chỉ gọi hàm tạo và hàm hủy một lần và toán tử gán mỗi lần lặp, trong khi đặt nó vào bên trong vòng lặp sẽ gọi hàm tạo và hàm hủy cho mỗi lần lặp lại của vòng lặp. Tùy thuộc vào hàm tạo, hàm hủy và toán tử gán của lớp làm gì, điều này có thể mong muốn hoặc không.

Cả hai đều giống nhau và đây là cách bạn có thể tìm hiểu, bằng cách xem trình biên dịch làm gì (ngay cả khi không đặt tối ưu hóa thành cao):

Hãy xem trình biên dịch (gcc 4.0) làm gì với các ví dụ đơn giản của bạn:

1.c:

main(){ int var; while(int i < 100) { var = 4; } }

gcc -S 1.c

1.s:

_main:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $24, %esp
    movl    $0, -16(%ebp)
    jmp L2
L3:
    movl    $4, -12(%ebp)
L2:
    cmpl    $99, -16(%ebp)
    jle L3
    leave
    ret

2.c

main() { while(int i < 100) { int var = 4; } }

gcc -S 2.c

2.s:

_main:
        pushl   %ebp
        movl    %esp, %ebp
        subl    $24, %esp
        movl    $0, -16(%ebp)
        jmp     L2
L3:
        movl    $4, -12(%ebp)
L2:
        cmpl    $99, -16(%ebp)
        jle     L3
        leave
        ret

Từ những điều này, bạn có thể thấy hai điều: thứ nhất, mã giống nhau ở cả hai.

Thứ hai, bộ nhớ cho var được cấp phát bên ngoài vòng lặp:

         subl    $24, %esp

Và cuối cùng, điều duy nhất trong vòng lặp là việc gán và kiểm tra điều kiện:

L3:
        movl    $4, -12(%ebp)
L2:
        cmpl    $99, -16(%ebp)
        jle     L3

Điều này hiệu quả nhất có thể mà không cần loại bỏ hoàn toàn vòng lặp.

Ngày nay, tốt hơn là khai báo nó bên trong vòng lặp trừ khi nó là một hằng số vì trình biên dịch sẽ có thể tối ưu hóa mã tốt hơn (giảm phạm vi biến).

CHỈNH SỬA: Câu trả lời này hầu hết đã lỗi thời bây giờ. Với sự gia tăng của các trình biên dịch hậu cổ điển, các trường hợp mà trình biên dịch không thể tìm ra nó ngày càng hiếm. Tôi vẫn có thể xây dựng chúng nhưng hầu hết mọi người sẽ phân loại cấu trúc là mã xấu.

Hầu hết các trình biên dịch hiện đại sẽ tối ưu hóa điều này cho bạn. Điều đó đã được nói rằng tôi sẽ sử dụng ví dụ đầu tiên của bạn vì tôi thấy nó dễ đọc hơn.

Đối với kiểu tích hợp có thể sẽ không có sự khác biệt giữa 2 kiểu (có thể là ngay từ mã được tạo).

Tuy nhiên, nếu biến là một lớp có hàm tạo / hủy không tầm thường thì có thể có sự khác biệt lớn về chi phí thời gian chạy. Nói chung, tôi sẽ định phạm vi biến vào bên trong vòng lặp (để giữ phạm vi càng nhỏ càng tốt), nhưng nếu điều đó hóa ra có tác động hoàn hảo, tôi sẽ tìm cách di chuyển biến lớp ra ngoài phạm vi của vòng lặp. Tuy nhiên, làm điều đó cần một số phân tích bổ sung vì ngữ nghĩa của đường dẫn ode có thể thay đổi, do đó, điều này chỉ có thể được thực hiện nếu các đoạn văn cho phép.

Một lớp RAII có thể cần hành vi này. Ví dụ, một lớp quản lý thời gian truy cập tệp có thể cần phải được tạo và hủy trên mỗi lần lặp vòng lặp để quản lý quyền truy cập tệp đúng cách.

Giả sử bạn có một LockMgrlớp có được một phần quan trọng khi nó được xây dựng và giải phóng nó khi bị phá hủy:

while (i< 100) {
    LockMgr lock( myCriticalSection); // acquires a critical section at start of
                                      //    each loop iteration

    // do stuff...

}   // critical section is released at end of each loop iteration

khá khác với:

LockMgr lock( myCriticalSection);
while (i< 100) {

    // do stuff...

}

Cả hai vòng lặp đều có cùng hiệu suất. Cả hai đều sẽ mất một khoảng thời gian vô hạn :) Có thể là một ý tưởng hay để tăng i bên trong các vòng lặp.

Tôi đã từng chạy một số bài kiểm tra hiệu suất, và thật ngạc nhiên, tôi thấy rằng trường hợp 1 thực sự nhanh hơn! Tôi cho rằng điều này có thể là do việc khai báo biến bên trong vòng lặp làm giảm phạm vi của nó, vì vậy nó được giải phóng sớm hơn. Tuy nhiên, đó là một thời gian dài trước đây, trên một trình biên dịch rất cũ. Tôi chắc chắn rằng các trình biên dịch hiện đại làm tốt hơn công việc tối ưu hóa loại bỏ các tùy chọn, nhưng vẫn không có hại gì nếu giữ phạm vi biến của bạn càng ngắn càng tốt.

#include <stdio.h>
int main()
{
    for(int i = 0; i < 10; i++)
    {
        int test;
        if(i == 0)
            test = 100;
        printf("%d\n", test);
    }
}

Mã trên luôn in 100 10 lần, có nghĩa là biến cục bộ bên trong vòng lặp chỉ được cấp phát một lần cho mỗi lần gọi hàm.

Cách duy nhất để chắc chắn là tính thời gian cho chúng. Nhưng sự khác biệt, nếu có, sẽ rất nhỏ, vì vậy bạn sẽ cần một vòng lặp thời gian lớn.

Thêm vào đó, cái đầu tiên là kiểu tốt hơn vì nó khởi tạo biến var, trong khi cái còn lại để nó chưa được khởi tạo. Điều này và hướng dẫn mà người ta nên xác định các biến càng gần điểm sử dụng của chúng càng tốt, có nghĩa là dạng đầu tiên thường được ưu tiên hơn.

Chỉ với hai biến, trình biên dịch có thể sẽ được gán một thanh ghi cho cả hai. Dù sao thì các thanh ghi này cũng ở đó nên việc này không mất thời gian. Có 2 lệnh ghi thanh ghi và một lệnh đọc thanh ghi trong cả hai trường hợp.

Tôi nghĩ rằng hầu hết các câu trả lời đều thiếu một điểm chính cần xem xét, đó là: "Nó có rõ ràng không" và rõ ràng trong tất cả các cuộc thảo luận, sự thật là; không có nó không phải là. Tôi muốn đề xuất trong hầu hết các mã vòng lặp, hiệu quả là khá nhiều không phải là vấn đề (trừ khi bạn tính toán cho một tàu đổ bộ sao hỏa), vì vậy thực sự câu hỏi duy nhất là cái gì trông hợp lý hơn, dễ đọc và có thể bảo trì - trong trường hợp này, tôi khuyên bạn nên khai báo biến lên phía trước và bên ngoài vòng lặp - điều này chỉ đơn giản làm cho nó rõ ràng hơn. Sau đó, những người như bạn và tôi thậm chí sẽ không buồn mất thời gian kiểm tra trực tuyến để xem nó có hợp lệ hay không.

điều đó không đúng có chi phí đầu tư tuy nhiên chi phí bỏ qua của nó có thể chi phí.

Mặc dù có thể chúng sẽ kết thúc ở cùng một vị trí trên ngăn xếp Nó vẫn chỉ định nó. Nó sẽ gán vị trí bộ nhớ trên ngăn xếp cho int đó và sau đó giải phóng nó ở cuối}. Không phải theo nghĩa tự do heap theo nghĩa nó sẽ di chuyển sp (con trỏ ngăn xếp) bằng 1. Và trong trường hợp của bạn nếu xét nó chỉ có một biến cục bộ, nó sẽ chỉ đơn giản là tương đương fp (con trỏ khung) và sp

Câu trả lời ngắn gọn sẽ là: KHÔNG CHĂM SÓC CÁCH NÀO LÀM VIỆC NHƯ THẾ NÀO.

Nhưng hãy thử đọc thêm về cách tổ chức ngăn xếp. Trường đại học của tôi có những bài giảng khá hay về vấn đề đó Nếu bạn muốn đọc thêm, hãy xem tại đây http://www.cs.utk.edu/~plank/plank/classes/cs360/360/notes/Assembler1/lecture.html