ความถูกต้องของ const สามารถปรับปรุงประสิทธิภาพได้หรือไม่?

ฉันได้อ่านหลายครั้งแล้วว่าการบังคับใช้ความถูกต้องของ const ในรหัส C หรือ C ++ ของคุณไม่เพียง แต่เป็นแนวทางปฏิบัติที่ดีเกี่ยวกับความสามารถในการบำรุงรักษาเท่านั้น แต่ยังอาจทำให้คอมไพเลอร์ของคุณดำเนินการปรับให้เหมาะสมได้ด้วย อย่างไรก็ตามฉันได้อ่านสิ่งที่ตรงกันข้ามอย่างสมบูรณ์เช่นกัน - ว่ามันไม่มีผลต่อประสิทธิภาพเลย

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

constความถูกต้องไม่สามารถปรับปรุงประสิทธิภาพได้เนื่องจากconst_castและmutableเป็นภาษาและอนุญาตให้โค้ดละเมิดกฎได้ สิ่งนี้จะแย่ลงใน C ++ 11 โดยที่constข้อมูลของคุณอาจเป็นตัวชี้ไปยัง a std::atomicซึ่งหมายความว่าคอมไพเลอร์ต้องเคารพการเปลี่ยนแปลงที่เกิดขึ้นโดยเธรดอื่น

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

ที่กล่าวมาทั้งหมดconstความถูกต้องเป็นสิ่งที่ดีสำหรับการบำรุงรักษา มิฉะนั้นลูกค้าในชั้นเรียนของคุณอาจทำลายสมาชิกภายในของชั้นเรียนนั้นได้ ตัวอย่างเช่นพิจารณามาตรฐานstd::string::c_str()- หากไม่สามารถคืนค่า const ได้คุณจะสามารถใช้บัฟเฟอร์ภายในของสตริงได้!

อย่าใช้constเพื่อเหตุผลด้านประสิทธิภาพ ใช้เพื่อเหตุผลด้านการบำรุงรักษา

ใช่มันทำได้

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

ตัวอย่างเช่นการเข้าถึงตัวแปรส่วนกลางที่กำหนดด้วยconstประเภทสามารถอินไลน์ได้ในขณะที่ไม่สามารถอินไลน์อินไลน์ที่ไม่มีconstประเภทได้เนื่องจากอาจมีการเปลี่ยนแปลงเมื่อรันไทม์

https://godbolt.org/g/UEX4NB

C ++:

int foo1 = 1;
const int foo2 = 2;

int get_foo1() {
    return foo1;
}

int get_foo2() {
    return foo2;
}

asm:

foo1:
        .long   1
foo2:
        .long   2
get_foo1():
        push    rbp
        mov     rbp, rsp
        mov     eax, DWORD PTR foo1[rip] ; foo1 must be accessed by address
        pop     rbp
        ret
get_foo2():
        push    rbp
        mov     rbp, rsp
        mov     eax, 2 ; foo2 has been replaced with an immediate 2
        pop     rbp
        ret

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

Steve Jessop ยกตัวอย่างอื่นในความคิดเห็นของเขาเกี่ยวกับคำถามเดิมซึ่งนำมาซึ่งสิ่งที่ควรค่าแก่การกล่าวถึง ในขอบเขตบล็อกเป็นไปได้ที่คอมไพลเลอร์จะอนุมานได้ว่าตัวแปรจะถูกกลายพันธุ์และปรับให้เหมาะสมหรือไม่โดยไม่คำนึงถึงconstเนื่องจากคอมไพเลอร์สามารถเห็นการใช้ตัวแปรทั้งหมด ในทางตรงกันข้ามในตัวอย่างข้างต้นไม่สามารถคาดเดาได้ว่าfoo1จะกลายพันธุ์หรือไม่เนื่องจากสามารถแก้ไขในหน่วยการแปลอื่นได้ ฉันคิดว่าคอมไพเลอร์อัลตร้าคอมไพเลอร์สมมุติสามารถวิเคราะห์โปรแกรมทั้งหมดและตรวจสอบว่าสามารถเข้าถึงแบบอินไลน์ได้หรือไม่foo1... แต่คอมไพเลอร์จริงทำไม่ได้

จากประสบการณ์ของฉันไม่

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

สำหรับตัวชี้อาร์เรย์ความถูกต้องของ const ไม่สามารถรับประกันได้ว่าค่าจะคงที่จริง ๆ เมื่อมีปัญหานามแฝงที่อาจเกิดขึ้น ดังนั้นคอมไพเลอร์ไม่สามารถใช้ตัวปรับแต่ง const เพียงอย่างเดียวเพื่อทำการปรับให้เหมาะสม

หากคุณกำลังมองหาการเพิ่มประสิทธิภาพคุณควรพิจารณา__restrict__หรือตัวปรับแต่งฟังก์ชันพิเศษ / แอตทริบิวต์: http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html

เก่าไปหน่อย แต่ยังใช้ได้: http://www.gotw.ca/gotw/081.htm และอื่น ๆ อีกมากมาย: http://cpp-next.com/archive/2009/08/want-speed-pass-by - มูลค่า /