การเพิ่มประสิทธิภาพคอมไพเลอร์จะขจัดสตริงและอาร์เรย์ที่ซ้ำกัน

ภาพบุคคล2018facebook.jpg

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

พิจารณารหัส C สองบรรทัดต่อไปนี้:

 printf ( " สวัสดีครับ ศาสตราจารย์โจนส์ " ) ;   
printf ( " อรุณสวัสดิ์ ศาสตราจารย์เจน " ) ;   

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

 printf ( " สวัสดีครับอาจารย์ " ) ;       printf ( " โจนส์ " ) ;          printf ( " สวัสดีครับอาจารย์ " ) ;       printf ( " เจน " ) ;   

คอมไพเลอร์ส่วนใหญ่จะรู้จักสตริงคงที่และเก็บไว้ในโปรแกรมครั้งเดียว ใช้งานได้แม้ว่าสตริงคงที่ “Good day Professor” จะปรากฏในฟังก์ชันต่างๆ

ดังนั้นฟังก์ชันต่อไปนี้อาจคืนค่าเป็นจริง:

 const char * str1 = " เพื่อนรัก " ;       const char * str2 = " เพื่อนรัก " ;       กลับ str1 = = str2 ;   

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

เคล็ดลับเดียวกันนี้ล้มเหลวด้วยสตริงที่ขยาย:

 const char * str1 = " เพื่อนรัก " ;       const char * str2 = " เพื่อนรัก \0 f " ;       กลับ str1 = = str2 ;   

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

 ถ่าน get1 ( int k ) {       const char * str = " เพื่อนรัก " ;       กลับ str [ k ] ;   }      ถ่าน get2 ( int k ) {       const char * str = " เพื่อนรัก \0 f " ;       กลับ str [ k ] ;   }   

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

 int f ( int k ) {       int array [ ] = { 1 , 2 , 3 , 4 , 5 , 34432 , 321323 , 321321 , 1 ,       2 , 3 , 4 , 5 , 34432 , 321323 , 321321 } ;       กลับ อาร์เรย์ [ k ] ;   }         int g ( int k ) {       int array [ ] = { 1 , 2 , 3 , 4 , 5 , 34432 , 321323 , 321321 , 1 ,       2 , 3 , 4 , 5 , 34432 , 321323 , 321321 } ;       กลับ อาร์เรย์ [ k + 1 ] ;   }   

อาจยังคงใช้งานได้หากอาร์เรย์หนึ่งเป็นอาร์เรย์ย่อยที่แน่นอนของอาร์เรย์อื่นที่มี GCC ดังในตัวอย่างนี้:

 int f ( int k ) {       int array [ ] = { 1 , 2 , 3 , 4 , 5 , 34432 , 321323 , 321321 , 1 ,       2 , 3 , 4 , 5 , 34432 , 321323 , 321321 } ;       กลับ อาร์เรย์ [ k ] ;   }         int g ( int k ) {       int array [ ] = { 1 , 2 , 3 , 4 , 5 , 34432 , 321323 , 321321 , 1 ,       2 , 3 , 4 , 5 , 34432 , 321323 , 321321 , 1 , 4 } ;       กลับ อาร์เรย์ [ k + 1 ] ;   }   

มันยังใช้งานได้กับอาร์เรย์ของพอยน์เตอร์ เช่นในกรณีต่อไปนี้:

 อักขระ const * get1 ( int k ) {       const char * str [ ] = { " เพื่อนรัก " , " พี่สาวที่รัก " , " พี่ชายที่รัก " } ;       กลับ str [ k ] ;   }      อักขระ const * get2 ( int k ) {       const char * str [ ] = { " เพื่อนรัก " , " พี่สาวที่รัก " , " พี่ชายที่รัก " } ;       คืนค่า str [ k + 1 ] ;   }   

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

ใส่ความเห็น

อีเมลของคุณจะไม่แสดงให้คนอื่นเห็น