ตามที่โจเอลชี้ในพอดคาสต์ Stack Overflow # 34ในภาษาโปรแกรม C (aka: K & R) มีการกล่าวถึงคุณสมบัติของอาร์เรย์ใน C:a[5] == 5[a]

Joel บอกว่ามันเป็นเพราะเลขคณิตของตัวชี้ แต่ฉันก็ยังไม่เข้าใจ ทำไมa[5] == 5[a] ?

มาตรฐาน C กำหนดตัว[]ดำเนินการดังนี้:

a[b] == *(a + b)

ดังนั้นa[5]จะประเมินเป็น:

*(a + 5)

และ5[a]จะประเมินเป็น:

*(5 + a)

aเป็นตัวชี้ไปยังองค์ประกอบแรกของอาร์เรย์ a[5]เป็นค่าที่ 5 องค์ประกอบเพิ่มเติมจากaซึ่งเป็นเช่นเดียวกับ*(a + 5)และจากคณิตศาสตร์ในโรงเรียนประถมศึกษาที่เรารู้ว่าผู้ที่มีความเท่าเทียมกัน (นอกจากเป็นสับเปลี่ยน )

เพราะการเข้าถึงอาเรย์ถูกกำหนดในแง่ของพอยน์เตอร์ a[i]หมายถึงค่าเฉลี่ย*(a + i)ซึ่งเปลี่ยนเป็น

ฉันคิดว่าคำตอบอื่นกำลังพลาดอยู่

ใช่p[i]คือโดยการนิยามที่เทียบเท่า*(p+i)ซึ่ง (เนื่องจากการบวกคือการสลับ) ที่เทียบเท่ากับ*(i+p)ซึ่ง (อีกครั้งโดยคำจำกัดความของ[]ผู้ประกอบการ) เทียบเท่ากับi[p]เทียบเท่ากับ

(และใน array[i]ชื่ออาร์เรย์จะถูกแปลงเป็นตัวชี้ไปยังองค์ประกอบแรกของอาร์เรย์โดยปริยาย)

แต่การสลับสับเปลี่ยนของการเติมนั้นไม่ใช่ทั้งหมดที่ชัดเจนในกรณีนี้

เมื่อตัวถูกดำเนินการทั้งสองเป็นประเภทเดียวกันหรือแม้กระทั่งประเภทตัวเลขที่แตกต่างกันซึ่งได้รับการส่งเสริมให้เป็นประเภททั่วไป commutativity จึงเหมาะสมอย่างสมบูรณ์: x + y == y + xทำให้รู้สึกดี:

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

คำอธิบายของมาตรฐาน C ของ+ผู้ปฏิบัติงาน ( N1570 6.5.6) พูดว่า:

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

สามารถพูดได้อย่างง่ายดายเพียง:

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

ในกรณีนี้ทั้งสองi + pและi[p]จะผิดกฎหมาย

ในแง่ C ++ เรามี+ตัวดำเนินการโอเวอร์โหลดสองชุดซึ่งสามารถอธิบายได้อย่างหลวม ๆ ดังนี้:

pointer operator+(pointer p, integer i);

และ

pointer operator+(integer i, pointer p);

สิ่งแรกเท่านั้นที่จำเป็นจริงๆ

เหตุใดจึงเป็นเช่นนี้

C ++ สืบทอดคำจำกัดความนี้จาก C ซึ่งได้มาจาก B (ความสับเปลี่ยนของการจัดทำดัชนีอาร์เรย์ถูกกล่าวถึงอย่างชัดเจนในการอ้างอิงผู้ใช้ 1972 ) ถึง B ) ซึ่งได้รับจากBCPL (คู่มือลงวันที่ 1967) ซึ่งอาจได้มาจาก ภาษาก่อนหน้า (CPL? Algol?)

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

ภาษาเหล่านั้นถูกพิมพ์ลงอย่างมากน้อยกว่า C ที่ทันสมัยมาก โดยเฉพาะอย่างยิ่งความแตกต่างระหว่างตัวชี้และจำนวนเต็มมักจะถูกละเว้น (บางครั้งโปรแกรมเมอร์ซีก่อนหน้านี้ใช้พอยน์เตอร์เป็นจำนวนเต็มที่ไม่ได้ลงชื่อก่อนหน้าunsignedเพิ่มคำหลักลงในภาษา) ดังนั้นแนวคิดในการเพิ่มการไม่สลับสับเปลี่ยนเนื่องจากตัวถูกดำเนินการในประเภทต่าง ๆ อาจไม่เกิดขึ้นกับผู้ออกแบบภาษาเหล่านั้น หากผู้ใช้ต้องการเพิ่ม "สิ่ง" สองอย่างไม่ว่าจะเป็น "สิ่ง" เหล่านั้นเป็นจำนวนเต็มพอยน์เตอร์หรืออย่างอื่นก็ไม่ได้ขึ้นอยู่กับภาษาเพื่อป้องกัน

และในช่วงหลายปีที่ผ่านมาการเปลี่ยนแปลงกฎนั้นจะทำให้รหัสที่มีอยู่เสียหาย (แม้ว่ามาตรฐาน ANSI C ปี 1989 อาจเป็นโอกาสที่ดี)

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

ดังนั้นตอนนี้เรามีarr[3]และ3[arr]ความหมายว่าสิ่งเดียวกัน แต่รูปแบบหลังไม่ควรปรากฏนอกIOCCC

และแน่นอนว่า

 ("ABCD"[2] == 2["ABCD"]) && (2["ABCD"] == 'C') && ("ABCD"[2] == 'C')

เหตุผลหลักสำหรับเรื่องนี้คือย้อนกลับไปในยุค 70 เมื่อ C ถูกออกแบบคอมพิวเตอร์ไม่ได้มีหน่วยความจำมาก (64KB มีจำนวนมาก) ดังนั้นคอมไพเลอร์ C จึงไม่ทำการตรวจสอบไวยากรณ์มากนัก ดังนั้น " X[Y]" จึงแปลเป็น " *(X+Y)" ค่อนข้างสุ่มสี่สุ่มห้า

นอกจากนี้ยังอธิบายถึงไวยากรณ์ " +=" และ " ++" ทุกอย่างในแบบฟอร์ม " A = B + C" มีแบบฟอร์มที่รวบรวมไว้เหมือนกัน แต่ถ้า B เป็นวัตถุเดียวกับ A ดังนั้นการเพิ่มประสิทธิภาพระดับแอสเซมบลีก็พร้อมใช้งาน แต่คอมไพเลอร์ไม่สว่างพอที่จะจดจำได้ดังนั้นผู้พัฒนาจึงต้อง ( A += C) ในทำนองเดียวกันถ้าCเคย1มีการเพิ่มประสิทธิภาพระดับแอสเซมบลีที่แตกต่างกันและนักพัฒนาต้องทำให้ชัดเจนเนื่องจากคอมไพเลอร์ไม่รู้จัก (คอมไพเลอร์ล่าสุดทำดังนั้นไวยากรณ์เหล่านั้นส่วนใหญ่ไม่จำเป็นวันนี้)

ดูเหมือนจะไม่มีใครพูดถึงปัญหาของไดน่าด้วยsizeof:

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

เพื่อตอบคำถามอย่างแท้จริง มันไม่เป็นความจริงเสมอไปx == x

double zero = 0.0;
double a[] = { 0,0,0,0,0, zero/zero}; // NaN
cout << (a[5] == 5[a] ? "true" : "false") << endl;

พิมพ์

false

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

int a[] = { 2 , 3 , 3 , 2 , 4 };
int s = sizeof a / sizeof *a;  //  s == 5

for(int i = 0 ; i < s ; ++i) {  

           cout << a[a[a[i]]] << endl;
           // ... is equivalent to ... 
           cout << i[a][a][a] << endl;  // but I prefer this one, it's easier to increase the level of indirection (without loop)

}

แน่นอนฉันค่อนข้างแน่ใจว่าไม่มีกรณีการใช้งานสำหรับรหัสจริง แต่ฉันคิดว่ามันน่าสนใจอยู่ดี :)

คำถาม / คำตอบที่ดี

เพียงแค่ต้องการชี้ให้เห็นว่าตัวชี้และอาร์เรย์ C นั้นไม่เหมือนกันแม้ว่าในกรณีนี้ความแตกต่างนั้นไม่จำเป็น

พิจารณาการประกาศต่อไปนี้:

int a[10];
int* p = a;

ในa.outสัญลักษณ์aอยู่ที่ที่อยู่ซึ่งเป็นจุดเริ่มต้นของอาร์เรย์และสัญลักษณ์pอยู่ที่ที่เก็บตัวชี้และค่าของตัวชี้ที่ตำแหน่งหน่วยความจำนั้นเป็นจุดเริ่มต้นของอาร์เรย์

สำหรับพอยน์เตอร์ใน C เรามี

a[5] == *(a + 5)

และนอกจากนี้ยังมี

5[a] == *(5 + a)

ดังนั้นจึงเป็นเรื่องจริงที่ a[5] == 5[a].

ไม่ใช่คำตอบ แต่เป็นเพียงอาหารสำหรับความคิด หากคลาสนั้นมีตัวดำเนินการ index / subscript มากเกินไปนิพจน์0[x]จะไม่ทำงาน:

class Sub
{
public:
    int operator [](size_t nIndex)
    {
        return 0;
    }   
};

int main()
{
    Sub s;
    s[0];
    0[s]; // ERROR 
}

เนื่องจากเราไม่มีสิทธิ์เข้าถึงคลาสintจึงไม่สามารถทำได้:

class int
{
   int operator[](const Sub&);
};

มันมีคำอธิบายที่ดีมากในการสอนเกี่ยวกับตัวชี้และการจัดเรียงใน C โดย Ted Jensen

Ted Jensen อธิบายว่า:

ในความเป็นจริงนี่คือความจริงคือทุกที่ที่เขียนa[i]มันสามารถถูกแทนที่ด้วย*(a + i) ไม่มีปัญหาใด ๆ ในความเป็นจริงคอมไพเลอร์จะสร้างรหัสเดียวกันทั้งสองกรณี ดังนั้นเราจึงเห็นว่าตัวคำนวณเลขคณิตนั้นเหมือนกับการจัดทำดัชนีอาร์เรย์ ไวยากรณ์อย่างใดอย่างหนึ่งให้ผลลัพธ์เดียวกัน

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

ทีนี้ถ้าดูที่นิพจน์สุดท้ายนี้ส่วนหนึ่งของมัน .. (a + i)เป็นการเพิ่มอย่างง่ายโดยใช้ตัวดำเนินการ + และกฎของสถานะ C ที่นิพจน์ดังกล่าวสลับกัน นั่นคือ (ก + i) (i + a)เป็นเหมือน ดังนั้นเราสามารถเขียนได้อย่างง่ายดายเพียงเป็น*(i + a) *(a + i)แต่*(i + a)อาจมาจากi[a]! จากทั้งหมดนี้ความจริงที่อยากรู้อยากเห็นที่มา:

char a[20];

การเขียน

a[3] = 'x';

เหมือนกับการเขียน

3[a] = 'x';

ฉันรู้ว่าตอบคำถามแล้ว แต่ฉันไม่สามารถต่อต้านการแบ่งปันคำอธิบายนี้

ฉันจำหลักการออกแบบคอมไพเลอร์ได้สมมติว่าaมีintอาร์เรย์และขนาดเท่ากับint2 ไบต์และที่อยู่ฐานสำหรับaคือ 1,000

วิธีa[5]จะทำงาน ->

Base Address of your Array a + (5*size of(data type for array a))
i.e. 1000 + (5*2) = 1010

ดังนั้น,

ในทำนองเดียวกันเมื่อรหัส c แบ่งออกเป็นรหัสที่อยู่ 3 รหัส 5[a]จะกลายเป็น ->

Base Address of your Array a + (size of(data type for array a)*5)
i.e. 1000 + (2*5) = 1010 

ดังนั้นโดยพื้นฐานแล้วข้อความทั้งสองจะชี้ไปที่ตำแหน่งเดียวกันในหน่วยความจำและด้วยเหตุนี้ a[5] = 5[a] .

คำอธิบายนี้ยังเป็นสาเหตุที่ดัชนีเชิงลบในอาร์เรย์ทำงานใน C

เช่นถ้าฉันเข้าถึงa[-5]มันจะให้ฉัน

Base Address of your Array a + (-5 * size of(data type for array a))
i.e. 1000 + (-5*2) = 990

มันจะคืนให้ฉันที่ตำแหน่ง 990

ในอาร์เรย์ C , arr[3]และ3[arr]ที่เหมือนกันและสัญลักษณ์ชี้เทียบเท่าของพวกเขาไป*(arr + 3) *(3 + arr)แต่ในทางตรงกันข้าม[arr]3หรือ[3]arrไม่ถูกต้องและจะส่งผลให้เกิดข้อผิดพลาดทางไวยากรณ์เป็น(arr + 3)*และ(3 + arr)*ไม่ใช่การแสดงออกที่ถูกต้อง เหตุผลคือผู้ดำเนินการปฏิเสธความรับผิดชอบควรวางไว้ก่อนที่อยู่จะให้ผลลัพธ์โดยนิพจน์ไม่ใช่หลังจากที่อยู่

ในคอมไพเลอร์

a[i]
i[a]
*(a+i)

วิธีที่แตกต่างในการอ้างถึงองค์ประกอบในอาร์เรย์! (ไม่แปลกเลย)

ประวัติเล็กน้อยตอนนี้ ในภาษาอื่น ๆ BCPL มีอิทธิพลอย่างมากต่อการพัฒนาของ C ในช่วงแรก หากคุณประกาศอาร์เรย์ใน BCPL ด้วยสิ่งที่ชอบ:

let V = vec 10

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

let J = V!5

จำเป็นต้องทำจริงๆJ = !(V + 5)(ใช้ไวยากรณ์ BCPL) เนื่องจากจำเป็นต้องดึงข้อมูล V เพื่อรับที่อยู่ฐานของอาร์เรย์ ดังนั้นV!5และ5!Vมีความหมายเหมือนกัน จากการสังเกตการณ์เล็ก ๆ น้อย ๆ WAFL (Warwick Functional Language) เขียนใน BCPL และหน่วยความจำที่ดีที่สุดของฉันมักจะใช้ไวยากรณ์หลังมากกว่าที่จะใช้เพื่อเข้าถึงโหนดที่ใช้เป็นที่เก็บข้อมูล ได้รับมาจากที่ไหนสักแห่งระหว่าง 35 และ 40 ปีที่ผ่านมาดังนั้นความทรงจำของฉันเป็นสนิมเล็กน้อย :)

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

โปรดทราบว่า!ใน BCPL นั้นเป็นทั้งตัวดำเนินการนำหน้า unary และตัวดำเนินการแบบไบนารีมัดทั้งสองกรณีทำในทางอ้อม เพียงว่ารูปแบบไบนารีรวมถึงการเพิ่มตัวถูกดำเนินการทั้งสองก่อนที่จะทำการอ้อม ด้วยคำที่เน้นลักษณะของ BCPL (และ B) สิ่งนี้ทำให้รู้สึกได้จริงมาก ข้อ จำกัด ของ "ตัวชี้และจำนวนเต็ม" จำเป็นใน C เมื่อได้รับชนิดข้อมูลและsizeofกลายเป็นเรื่อง

นี่เป็นคุณสมบัติที่เป็นไปได้เพราะการสนับสนุนทางภาษา

คอมไพเลอร์ตีความa[i]เป็น*(a+i)และการแสดงออกประเมิน5[a] *(5+a)นับตั้งแต่การเปลี่ยนเป็นปรากฎว่าทั้งคู่มีค่าเท่ากัน trueดังนั้นประเมินแสดงออกถึงความ

ในซี

 int a[]={10,20,30,40,50};
 int *p=a;
 printf("%d\n",*p++);//output will be 10
 printf("%d\n",*a++);//will give an error

ตัวชี้เป็น "ตัวแปร"

ชื่ออาร์เรย์คือ "ช่วยในการจำ" หรือ "คำพ้อง"

p++;ถูกต้อง แต่a++ไม่ถูกต้อง

a[2] เท่ากับ 2 [a] เพราะการดำเนินการภายในของทั้งสองนี้คือ

"ตัวชี้คณิตศาสตร์" คำนวณภายในเป็น

*(a+3) เท่ากับ *(3+a)

ประเภทตัวชี้

1) ตัวชี้ไปยังข้อมูล

int *ptr;

2) ตัวชี้ const กับข้อมูล

int const *ptr;

3) ตัวชี้ const เพื่อ const ข้อมูล

int const *const ptr;

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

ความแตกต่างที่สำคัญที่ฉันพบคือ ...

เราสามารถเริ่มต้นตัวชี้อีกครั้งโดยที่อยู่ แต่ไม่ใช่กรณีเดียวกันกับอาร์เรย์

======
และกลับไปที่คำถามของคุณ ...
a[5]ไม่มีอะไร แต่*(a + 5)
คุณสามารถเข้าใจได้ง่ายโดย
a - ประกอบด้วยที่อยู่ (ผู้คนเรียกมันว่าเป็นที่อยู่พื้นฐาน) เหมือนกับตัวชี้ประเภท (2) ในรายการของเรา
[]- ผู้ประกอบการนั้นสามารถ *เปลี่ยนได้ด้วยตัวชี้

ดังนั้นในที่สุด ...

a[5] == *(a +5) == *(5 + a) == 5[a]