ไม่เข้าใจวิธีคำนวณกำลังสองของตัวเลขนี้

ฉันพบฟังก์ชันที่คำนวณกำลังสองของตัวเลข:

int p(int n) {
    int a[n]; //works on C99 and above
    return (&a)[n] - a;
}

ก็จะส่งกลับค่า n 2 คำถามคือมันทำได้อย่างไร? หลังจากการทดสอบเล็ก ๆ น้อย ๆ ผมพบว่าระหว่าง(&a)[k]และ(&a)[k+1]เป็น/sizeof(a) sizeof(int)ทำไมถึงเป็นเช่นนั้น?

เห็นได้ชัดว่าเป็นการแฮ็ก ... แต่เป็นวิธีการยกกำลังสองจำนวนโดยไม่ใช้ตัว*ดำเนินการ (นี่เป็นข้อกำหนดในการแข่งขันการเข้ารหัส)

(&a)[n] 

เทียบเท่ากับตัวชี้ไปintที่ตำแหน่ง

(a + sizeof(a[n])*n)

ดังนั้นนิพจน์ทั้งหมดคือ

  (&a)[n] -a 

= (a + sizeof(a[n])*n -a) /sizeof(int)

= sizeof(a[n])*n / sizeof(int)
= sizeof(int) * n * n / sizeof(int)
= n * n

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

เมื่อตัวชี้ตัวหนึ่งถูกลบออกจากอีกตัวหนึ่งผลลัพธ์คือระยะทาง (วัดในองค์ประกอบอาร์เรย์) ระหว่างตัวชี้ ดังนั้นถ้าpจุดไปa[i]และqจุดที่จะต้องa[j]แล้วจะมีค่าเท่ากับ p - qi - j

C11: 6.5.6 ตัวดำเนินการเพิ่มเติม (p9):

เมื่อมีการลบพอยน์เตอร์สองตัวทั้งสองจะชี้ไปที่องค์ประกอบของอ็อบเจ็กต์อาร์เรย์เดียวกันหรืออย่างใดอย่างหนึ่งผ่านองค์ประกอบสุดท้ายของอ็อบเจ็กต์อาร์เรย์ ผลที่ได้คือความแตกต่างของตัวห้อยของทั้งสององค์ประกอบอาร์เรย์ [... ].
ในคำอื่น ๆ ถ้าการแสดงออกPและQชี้ไปตามลำดับi-th และjองค์ประกอบ -th ของวัตถุอาร์เรย์แสดงออก(P)-(Q)ได้ค่าi−jptrdiff_tบริการที่มีให้พอดีกับค่าในวัตถุของการพิมพ์

ตอนนี้ผมหวังว่าคุณมีความตระหนักของการแปลงชื่ออาร์เรย์ชี้แปรรูปชี้ไปยังองค์ประกอบแรกของอาร์เรย์a เป็นที่อยู่ของบล็อกหน่วยความจำทั้งหมดคือมันเป็นอยู่ของอาร์เรย์ รูปด้านล่างจะช่วยให้คุณเข้าใจ ( _{อ่านคำตอบนี้สำหรับคำอธิบายโดยละเอียด} ): a&aa

นี้จะช่วยให้คุณเข้าใจว่าทำไมaและ&aมีที่อยู่เดียวกันและวิธีการที่(&a)[i]เป็นที่อยู่ของฉัน^THอาร์เรย์ (ที่มีขนาดเดียวกันกับที่a)

ดังนั้นคำสั่ง

return (&a)[n] - a; 

เทียบเท่ากับ

return (&a)[n] - (&a)[0];  

และความแตกต่างนี้จะให้จำนวนองค์ประกอบระหว่างพอยน์เตอร์(&a)[n]และ(&a)[0]ซึ่งคือnอาร์เรย์แต่ละn intองค์ประกอบ ดังนั้นองค์ประกอบมากมายรวมn*n= 2 n

บันทึก:

C11: 6.5.6 ตัวดำเนินการเพิ่มเติม (p9):

เมื่อทั้งสองตัวชี้จะถูกหัก, ทั้งสองจะชี้ไปที่องค์ประกอบของวัตถุอาร์เรย์เดียวกันหรือหนึ่งในอดีตที่ผ่านมาองค์ประกอบสุดท้ายของวัตถุอาร์เรย์ ; ผลลัพธ์คือความแตกต่างของตัวห้อยขององค์ประกอบอาร์เรย์ทั้งสอง ขนาดของผลลัพธ์ถูกกำหนดโดยการนำไปใช้งานและประเภทของผลลัพธ์ (ชนิดจำนวนเต็มที่ลงนาม) ถูกptrdiff_tกำหนดไว้ใน<stddef.h>ส่วนหัว หากไม่สามารถแสดงผลลัพธ์ในออบเจ็กต์ประเภทนั้นได้แสดงว่าพฤติกรรมนั้นไม่ได้กำหนดไว้

ตั้งแต่(&a)[n]จุดองค์ประกอบของวัตถุอาร์เรย์เดียวกันมิได้หนึ่งที่ผ่านมาองค์ประกอบสุดท้ายของวัตถุอาร์เรย์ไม่และ(&a)[n] - aจะเรียกไม่ได้กำหนดพฤติกรรม

นอกจากนี้ทราบว่าดีกว่าที่จะเปลี่ยนประเภทการกลับมาของฟังก์ชั่นการ pptrdiff_t

aคืออาร์เรย์ (ตัวแปร) ของn int.

&aเป็นตัวชี้ไปยังอาร์เรย์ (ตัวแปร) ของn int.

(&a)[1]เป็นตัวชี้ของintหนึ่งในintอดีตที่ผ่านมาองค์ประกอบอาร์เรย์ที่ผ่านมา ชี้นี่คือองค์ประกอบหลังจากn int&a[0]

(&a)[2]เป็นตัวชี้ของintหนึ่งในintอดีตที่ผ่านมาองค์ประกอบแถวสุดท้ายของสองอาร์เรย์ ชี้นี่คือองค์ประกอบหลังจาก2 * n int&a[0]

(&a)[n]เป็นตัวชี้ของintหนึ่งในintอดีตที่ผ่านมาองค์ประกอบแถวสุดท้ายของnอาร์เรย์ ชี้นี่คือองค์ประกอบหลังจากn * n int &a[0]เพียงแค่ลบ&a[0]หรือและคุณมีan

แน่นอนว่านี่เป็นพฤติกรรมที่ไม่ได้กำหนดไว้ในทางเทคนิคแม้ว่ามันจะทำงานบนเครื่องของคุณโดยที่(&a)[n]ไม่ได้ชี้เข้าไปในอาร์เรย์หรืออย่างใดอย่างหนึ่งเลยองค์ประกอบอาร์เรย์สุดท้าย (ตามที่กำหนดโดยกฎ C ของเลขคณิตตัวชี้)

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

int a[10];

int *p1 = &a[1];
int *p2 = &a[3];

printf( "%d\n", p2 - p1 ); 

ตอนนี้ให้พิจารณาการแสดงออก

(&a)[n] - a;

ในนิพจน์นี้aมีประเภทint *และชี้ไปที่องค์ประกอบแรก

นิพจน์&aมีประเภทint ( * )[n]และชี้ไปที่แถวแรกของอาร์เรย์สองมิติที่สร้างภาพ ค่าตรงกับค่าaแม้ว่าประเภทจะแตกต่างกัน

( &a )[n]

เป็นองค์ประกอบที่ n ของอาร์เรย์สองมิติที่สร้างภาพนี้และมีชนิดint[n]นั่นคือมันเป็นแถวที่ n ของอาร์เรย์ภาพ ในการแสดงออกที่(&a)[n] - aจะถูกแปลงเป็นอยู่ขององค์ประกอบแรกของตนและมีประเภท `int *

ระหว่าง (&a)[n]และaมี n แถวของ n องค์ประกอบ n * nดังนั้นความแตกต่างจะเท่ากับ

Expression     | Value                | Explanation
a              | a                    | point to array of int elements
a[n]           | a + n*sizeof(int)    | refer to n-th element in array of int elements
-------------------------------------------------------------------------------------------------
&a             | a                    | point to array of (n int elements array)
(&a)[n]        | a + n*sizeof(int[n]) | refer to n-th element in array of (n int elements array)
-------------------------------------------------------------------------------------------------
sizeof(int[n]) | n * sizeof(int)      | int[n] is a type of n-int-element array

ด้วยประการฉะนี้

1. ประเภท(&a)[n]คือint[n]ตัวชี้
2. ประเภทaคือintตัวชี้

ตอนนี้นิพจน์(&a)[n]-aทำการย่อยตัวชี้:

  (&a)[n]-a
= ((a + n*sizeof(int[n])) - a) / sizeof(int)
= (n * sizeof(int[n])) / sizeof(int)
= (n * n * sizeof(int)) / sizeof(int)
= n * n