มีค่าใช้จ่ายในการประกาศตัวแปรภายในลูปหรือไม่? (C ++)

ฉันแค่สงสัยว่าจะมีการสูญเสียความเร็วหรือประสิทธิภาพหรือไม่หากคุณทำสิ่งนี้:

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

ซึ่งประกาศint varหนึ่งร้อยครั้ง สำหรับฉันดูเหมือนว่าจะมี แต่ฉันไม่แน่ใจ การทำสิ่งนี้แทนจะทำได้จริงหรือเร็วกว่านี้หรือไม่:

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

หรือเหมือนกันอย่างรวดเร็วและมีประสิทธิภาพ?

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

สำหรับประเภทดั้งเดิมและประเภท POD จะไม่แตกต่างกัน คอมไพเลอร์จะจัดสรรพื้นที่สแต็กสำหรับตัวแปรที่จุดเริ่มต้นของฟังก์ชันและยกเลิกการจัดสรรเมื่อฟังก์ชันส่งคืนในทั้งสองกรณี

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

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

ดูว่าคอมไพเลอร์ (gcc 4.0) ทำอะไรกับตัวอย่างง่ายๆของคุณ:

1.c:

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

gcc -S 1.c

1. วินาที:

_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. ค

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

gcc -S 2.c

2. วินาที:

_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

จากสิ่งเหล่านี้คุณจะเห็นสองสิ่ง: ประการแรกรหัสเหมือนกันทั้งสองอย่าง

ประการที่สองพื้นที่เก็บข้อมูลสำหรับ var ถูกจัดสรรนอกลูป:

         subl    $24, %esp

และในที่สุดสิ่งเดียวในลูปคือการมอบหมายและการตรวจสอบเงื่อนไข:

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

ซึ่งมีประสิทธิภาพมากที่สุดเท่าที่คุณจะทำได้โดยไม่ต้องถอดลูปออกทั้งหมด

วันนี้จะเป็นการดีกว่าที่จะประกาศภายในลูปเว้นแต่จะเป็นค่าคงที่เนื่องจากคอมไพเลอร์จะสามารถปรับโค้ดให้เหมาะสมได้ดีขึ้น (ลดขอบเขตตัวแปร)

แก้ไข: คำตอบนี้ส่วนใหญ่ล้าสมัยแล้ว ด้วยการเพิ่มขึ้นของคอมไพเลอร์โพสต์คลาสสิกกรณีที่คอมไพเลอร์ไม่สามารถเข้าใจได้นั้นหายาก ฉันยังสามารถสร้างได้ แต่คนส่วนใหญ่จะจัดประเภทการก่อสร้างเป็นรหัสที่ไม่ถูกต้อง

คอมไพเลอร์สมัยใหม่ส่วนใหญ่จะปรับให้เหมาะกับคุณ อย่างที่บอกว่าฉันจะใช้ตัวอย่างแรกของคุณเพราะฉันคิดว่ามันอ่านง่ายขึ้น

สำหรับประเภทในตัวอาจจะไม่มีความแตกต่างระหว่าง 2 สไตล์ (อาจจะลงไปถึงโค้ดที่สร้างขึ้น)

อย่างไรก็ตามหากตัวแปรเป็นคลาสที่มีตัวสร้าง / ตัวทำลายที่ไม่สำคัญอาจมีความแตกต่างที่สำคัญในต้นทุนรันไทม์ โดยทั่วไปฉันจะกำหนดขอบเขตตัวแปรให้อยู่ในลูป (เพื่อให้ขอบเขตเล็กที่สุดเท่าที่จะเป็นไปได้) แต่ถ้าปรากฎว่ามีผลกระทบอย่างสมบูรณ์แบบฉันจะย้ายตัวแปรคลาสออกนอกขอบเขตของลูป อย่างไรก็ตามการทำเช่นนั้นจำเป็นต้องมีการวิเคราะห์เพิ่มเติมเนื่องจากความหมายของเส้นทางบทกวีอาจเปลี่ยนไปดังนั้นจึงสามารถทำได้ก็ต่อเมื่อ sematics อนุญาตเท่านั้น

คลาส RAII อาจต้องการพฤติกรรมนี้ ตัวอย่างเช่นคลาสที่จัดการอายุการเข้าถึงไฟล์อาจต้องสร้างและทำลายในการวนซ้ำแต่ละครั้งเพื่อจัดการการเข้าถึงไฟล์อย่างถูกต้อง

สมมติว่าคุณมีLockMgrคลาสที่ได้รับส่วนสำคัญเมื่อสร้างและเผยแพร่เมื่อถูกทำลาย:

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

ค่อนข้างแตกต่างจาก:

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

    // do stuff...

}

ลูปทั้งสองมีประสิทธิภาพเท่ากัน พวกเขาทั้งสองจะใช้เวลาไม่สิ้นสุด :) อาจเป็นความคิดที่ดีที่จะเพิ่ม i ภายในลูป

ครั้งหนึ่งฉันเคยทดสอบสมรรถภาพและประหลาดใจที่พบว่ากรณีที่ 1 เร็วกว่าจริง ๆ ! ฉันคิดว่านี่อาจเป็นเพราะการประกาศตัวแปรภายในลูปลดขอบเขตดังนั้นจึงเป็นอิสระก่อนหน้านี้ อย่างไรก็ตามนั่นเป็นเวลานานมาแล้วในคอมไพเลอร์เก่ามาก ฉันแน่ใจว่าคอมไพเลอร์สมัยใหม่ทำงานได้ดีกว่าในการเพิ่มประสิทธิภาพความแตกต่าง แต่ก็ยังไม่เจ็บที่จะรักษาขอบเขตตัวแปรของคุณให้สั้นที่สุด

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

โค้ดด้านบนจะพิมพ์ 100 10 ครั้งเสมอซึ่งหมายความว่าตัวแปรภายในลูปจะถูกจัดสรรเพียงครั้งเดียวต่อการเรียกใช้ฟังก์ชันแต่ละครั้ง

วิธีเดียวที่จะมั่นใจได้คือเวลาพวกเขา แต่ความแตกต่างถ้ามีจะเป็นกล้องจุลทรรศน์ดังนั้นคุณจะต้องมีวงเวลาขนาดใหญ่ที่ยิ่งใหญ่

ประเด็นแรกคือรูปแบบที่ดีกว่าเพราะมันเริ่มต้นตัวแปร var ในขณะที่อีกตัวปล่อยไว้โดยไม่ได้เริ่มต้น นี่และแนวทางที่เราควรกำหนดตัวแปรให้ใกล้กับจุดที่ใช้งานมากที่สุดหมายความว่าควรเลือกรูปแบบแรก

คอมไพเลอร์มีแนวโน้มที่จะกำหนดรีจิสเตอร์สำหรับทั้งสองตัวแปร การลงทะเบียนเหล่านี้ยังคงมีอยู่ดังนั้นจึงไม่ต้องใช้เวลา มี 2 ​​register write และ one register read instruction ในทั้งสองกรณี

ฉันคิดว่าคำตอบส่วนใหญ่ขาดประเด็นสำคัญที่ต้องพิจารณาซึ่งก็คือ "มันชัดเจน" และเห็นได้ชัดจากการอภิปรายทั้งหมดข้อเท็จจริงคือ; ไม่มันไม่ใช่. ฉันขอแนะนำในรหัสลูปส่วนใหญ่ประสิทธิภาพนั้นค่อนข้างไม่เป็นปัญหา (เว้นแต่คุณจะคำนวณสำหรับผู้ลงจอดบนดาวอังคาร) ดังนั้นคำถามเดียวคือสิ่งที่ดูสมเหตุสมผลและอ่านได้และบำรุงรักษาได้มากกว่า - ในกรณีนี้ฉันขอแนะนำให้ประกาศ ตัวแปรขึ้นหน้า & นอกลูป - สิ่งนี้ทำให้ชัดเจนขึ้น แล้วคนอย่างคุณ & ฉันก็ไม่ต้องกังวลกับการเสียเวลาตรวจสอบออนไลน์เพื่อดูว่าถูกต้องหรือไม่

นั่นไม่เป็นความจริงมีค่าใช้จ่ายอย่างไรก็ตามการละเลยสามารถอยู่เหนือศีรษะได้

แม้ว่าอาจจะจบลงที่ตำแหน่งเดียวกันในสแต็ก แต่ก็ยังกำหนดให้ มันจะกำหนดตำแหน่งหน่วยความจำบนสแต็กสำหรับ int นั้นจากนั้นจึงว่างเมื่อสิ้นสุด} ไม่ได้อยู่ในความรู้สึกที่ไม่มีฮีปมันจะย้าย sp (ตัวชี้สแต็ก) ทีละ 1 และในกรณีของคุณเมื่อพิจารณาว่ามันมีตัวแปรท้องถิ่นเพียงตัวเดียวมันก็จะเท่ากับ fp (ตัวชี้เฟรม) และ sp

คำตอบสั้น ๆ คือ: อย่าดูแลอย่างใดอย่างหนึ่งวิธีการทำงานเกือบเหมือนกัน

แต่ลองอ่านเพิ่มเติมเกี่ยวกับการจัดเรียงสแต็ก โรงเรียนระดับปริญญาตรีของฉันมีการบรรยายที่ดีเกี่ยวกับเรื่องนั้นหากคุณต้องการอ่านเพิ่มเติมโปรดดูที่นี่ http://www.cs.utk.edu/~plank/plank/classes/cs360/360/notes/Assembler1/lecture.html