Như Joel chỉ ra trong podcast Stack Overflow # 34 , trong Ngôn ngữ lập trình C (còn gọi là: K & R), có đề cập đến thuộc tính này của mảng trong C:a[5] == 5[a]

Joel nói rằng đó là do số học con trỏ nhưng tôi vẫn không hiểu. Tại sao khônga[5] == 5[a] ?

Tiêu chuẩn C định nghĩa []toán tử như sau:

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

Do đó a[5]sẽ đánh giá để:

*(a + 5)

và 5[a]sẽ đánh giá để:

*(5 + a)

alà một con trỏ đến phần tử đầu tiên của mảng. a[5]là giá trị mà 5 yếu tố khác a, tương tự *(a + 5), và từ toán tiểu học, chúng ta biết chúng là những yếu tố bằng nhau (bổ sung là giao hoán ).

Bởi vì truy cập mảng được định nghĩa theo các con trỏ. a[i]được định nghĩa là có nghĩa *(a + i)là giao hoán.

Tôi nghĩ rằng một cái gì đó đang bị bỏ lỡ bởi các câu trả lời khác.

Có, p[i]theo định nghĩa tương đương với *(p+i), mà (vì bổ sung là giao hoán) tương đương với *(i+p), mà (một lần nữa, theo định nghĩa của []toán tử) là tương đương với i[p].

(Và trong array[i], tên mảng được chuyển đổi hoàn toàn thành một con trỏ thành phần tử đầu tiên của mảng.)

Nhưng tính giao hoán của bổ sung không phải là tất cả rõ ràng trong trường hợp này.

Khi cả hai toán hạng đều cùng loại hoặc thậm chí là các loại số khác nhau được thăng cấp thành một loại phổ biến, giao hoán có ý nghĩa hoàn hảo : x + y == y + x.

Nhưng trong trường hợp này, chúng ta đang nói cụ thể về số học con trỏ, trong đó một toán hạng là một con trỏ và cái còn lại là một số nguyên. (Số nguyên + số nguyên là một hoạt động khác nhau và con trỏ + con trỏ là vô nghĩa.)

Mô tả của tiêu chuẩn C về +toán tử ( N1570 6.5.6) cho biết:

Ngoài ra, cả hai toán hạng sẽ có kiểu số học hoặc một toán hạng sẽ là một con trỏ tới một loại đối tượng hoàn chỉnh và một toán hạng khác sẽ có kiểu số nguyên.

Nó có thể dễ dàng như đã nói:

Ngoài ra, cả hai toán hạng sẽ có kiểu số học hoặc toán hạng bên trái sẽ là một con trỏ tới một loại đối tượng hoàn chỉnh và toán hạng bên phải sẽ có kiểu số nguyên.

trong trường hợp cả hai i + pvà i[p]sẽ là bất hợp pháp.

Theo thuật ngữ C ++, chúng tôi thực sự có hai bộ +toán tử quá tải , có thể được mô tả một cách lỏng lẻo là:

pointer operator+(pointer p, integer i);

và

pointer operator+(integer i, pointer p);

trong đó chỉ có đầu tiên là thực sự cần thiết.

Vậy tại sao nó lại theo cách này?

C ++ đã kế thừa định nghĩa này từ C, lấy từ B (tính giao hoán của việc lập chỉ mục mảng được đề cập rõ ràng trong Tài liệu tham khảo của người dùng năm 1972 đến B ), lấy từ BCPL (hướng dẫn sử dụng ngày 1967) ngôn ngữ trước đó (CPL? Algol?).

Vì vậy, ý tưởng rằng lập chỉ mục mảng được xác định theo thuật ngữ cộng, và phép cộng đó, thậm chí cả con trỏ và số nguyên, có tính giao hoán, quay trở lại nhiều thập kỷ, theo ngôn ngữ tổ tiên của C.

Những ngôn ngữ đó được gõ ít mạnh hơn nhiều so với C hiện đại. Cụ thể, sự khác biệt giữa con trỏ và số nguyên thường bị bỏ qua. (Lập trình viên C sớm đôi khi được dùng con trỏ như số nguyên unsigned, trước khi unsignedtừ khóa đã được thêm vào ngôn ngữ.) Vì vậy, ý tưởng thực hiện Ngoài ra phi giao hoán vì các toán hạng là các loại khác nhau có lẽ sẽ không xảy ra cho các nhà thiết kế trong những ngôn ngữ. Nếu người dùng muốn thêm hai "thứ", cho dù những "thứ đó" là số nguyên, con trỏ hay thứ gì khác, thì đó không phải là ngôn ngữ để ngăn chặn nó.

Và trong nhiều năm qua, bất kỳ thay đổi nào đối với quy tắc đó sẽ phá vỡ mã hiện có (mặc dù tiêu chuẩn ANSI C năm 1989 có thể là một cơ hội tốt).

Thay đổi C và / hoặc C ++ để yêu cầu đặt con trỏ ở bên trái và số nguyên ở bên phải có thể phá vỡ một số mã hiện có, nhưng sẽ không mất sức mạnh biểu cảm thực sự.

Vì vậy, bây giờ chúng ta có arr[3]và 3[arr]có nghĩa chính xác điều tương tự, mặc dù hình thức sau không bao giờ xuất hiện bên ngoài IOCCC .

Và dĩ nhiên

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

Lý do chính cho điều này là vào những năm 70 khi C được thiết kế, máy tính không có nhiều bộ nhớ (64KB là rất nhiều), vì vậy trình biên dịch C không thực hiện nhiều kiểm tra cú pháp. Do đó " X[Y]" được dịch một cách mù quáng thành " *(X+Y)"

Điều này cũng giải thích các cú pháp " +=" và " ++". Mọi thứ ở dạng " A = B + C" đều có dạng được biên dịch giống nhau. Nhưng, nếu B là cùng một đối tượng với A, thì tối ưu hóa mức lắp ráp đã có sẵn. Nhưng trình biên dịch không đủ sáng để nhận ra nó, vì vậy nhà phát triển phải ( A += C). Tương tự, nếu Ccó 1, một tối ưu hóa mức lắp ráp khác nhau đã có sẵn, và một lần nữa nhà phát triển phải làm cho nó rõ ràng, bởi vì trình biên dịch đã không nhận ra nó. (Gần đây trình biên dịch thực hiện, vì vậy những cú pháp này phần lớn không cần thiết trong những ngày này)

Một điều dường như không ai đã đề cập về vấn đề của Dinah với sizeof:

Bạn chỉ có thể thêm một số nguyên vào một con trỏ, bạn không thể thêm hai con trỏ lại với nhau. Theo cách đó, khi thêm một con trỏ vào một số nguyên hoặc một số nguyên cho một con trỏ, trình biên dịch luôn biết bit nào có kích thước cần được tính đến.

Để trả lời câu hỏi theo nghĩa đen. Không phải lúc nào cũng đúngx == x

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

in

false

Tôi chỉ tìm ra cú pháp xấu xí này có thể là "hữu ích", hoặc ít nhất là rất thú vị để chơi khi bạn muốn xử lý một mảng các chỉ mục tham chiếu đến các vị trí trong cùng một mảng. Nó có thể thay thế dấu ngoặc vuông lồng nhau và làm cho mã dễ đọc hơn!

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)

}

Tất nhiên, tôi khá chắc chắn rằng không có trường hợp sử dụng nào cho mã thực đó, nhưng dù sao tôi cũng thấy nó thú vị :)

Câu hỏi / câu trả lời hay.

Chỉ muốn chỉ ra rằng các con trỏ và mảng C không giống nhau , mặc dù trong trường hợp này, sự khác biệt là không cần thiết.

Hãy xem xét các tuyên bố sau:

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

Trong đó a.out, ký hiệu anằm ở một địa chỉ là điểm bắt đầu của mảng và ký hiệu pnằm ở địa chỉ nơi con trỏ được lưu trữ và giá trị của con trỏ tại vị trí bộ nhớ đó là điểm bắt đầu của mảng.

Đối với con trỏ trong C, chúng ta có

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

và cũng

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

Do đó đúng là a[5] == 5[a].

Không phải là một câu trả lời, nhưng chỉ là một số thực phẩm cho suy nghĩ. Nếu lớp đang có toán tử chỉ mục / chỉ mục bị quá tải, biểu thức 0[x]sẽ không hoạt động:

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

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

Vì chúng tôi không có quyền truy cập vào lớp int , điều này không thể được thực hiện:

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

Nó có lời giải thích rất hay trong MỘT HƯỚNG DẪN VỀ ĐIỂM VÀ ARRAYS TẠI C của Ted Jensen.

Ted Jensen giải thích nó như sau:

Trong thực tế, điều này là đúng, tức là bất cứ nơi nào người ta viết a[i]nó có thể được thay thế *(a + i) mà không có bất kỳ vấn đề. Trong thực tế, trình biên dịch sẽ tạo cùng một mã trong cả hai trường hợp. Do đó, chúng ta thấy rằng số học con trỏ giống như lập chỉ mục mảng. Hoặc là cú pháp tạo ra kết quả tương tự.

Điều này KHÔNG nói rằng con trỏ và mảng là như nhau, chúng không giống nhau. Chúng tôi chỉ nói rằng để xác định một phần tử nhất định của một mảng, chúng tôi có hai lựa chọn hai cú pháp, một sử dụng lập chỉ mục mảng và một sử dụng số học con trỏ, mang lại kết quả giống hệt nhau.

Bây giờ, nhìn vào biểu thức cuối cùng này, một phần của nó .. (a + i), là một bổ sung đơn giản bằng cách sử dụng toán tử + và các quy tắc của trạng thái C rằng biểu thức đó là giao hoán. Đó là (a + i) giống hệt (i + a). Vì vậy, chúng tôi có thể viết *(i + a)dễ dàng như *(a + i). Nhưng *(i + a)có thể đã đến từ i[a]! Từ tất cả những điều này xuất hiện sự thật tò mò rằng nếu:

char a[20];

viết

a[3] = 'x';

giống như viết

3[a] = 'x';

Tôi biết câu hỏi đã được trả lời, nhưng tôi không thể cưỡng lại việc chia sẻ lời giải thích này.

Tôi nhớ Nguyên tắc thiết kế Trình biên dịch, Giả sử alà một intmảng và kích thước intlà 2 byte, và địa chỉ cơ sở alà 1000.

Làm thế nào a[5]sẽ làm việc ->

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

Vì thế,

Tương tự khi mã c được chia thành mã 3 địa chỉ, 5[a]sẽ trở thành ->

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

Vì vậy, về cơ bản cả hai câu lệnh đều trỏ đến cùng một vị trí trong bộ nhớ và do đó , a[5] = 5[a].

Giải thích này cũng là lý do tại sao các chỉ mục tiêu cực trong mảng hoạt động trong C.

tức là nếu tôi truy cập a[-5]nó sẽ cho tôi

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

Nó sẽ trả lại cho tôi đối tượng tại vị trí 990.

Trong mảng C , arr[3]và 3[arr]đều giống nhau, và ký hiệu con trỏ tương đương của họ là *(arr + 3)để *(3 + arr). Nhưng ngược lại [arr]3hoặc [3]arrkhông chính xác và sẽ dẫn đến lỗi cú pháp, vì (arr + 3)*và (3 + arr)*không phải là biểu thức hợp lệ. Lý do là toán tử dereference nên được đặt trước địa chỉ mang lại bởi biểu thức, không phải sau địa chỉ.

trong trình biên dịch c

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

là những cách khác nhau để chỉ một phần tử trong một mảng! (KHÔNG Ở TẤT CẢ TUẦN)

Một chút lịch sử bây giờ. Trong số các ngôn ngữ khác, BCPL có ảnh hưởng khá lớn đến sự phát triển ban đầu của C. Nếu bạn đã khai báo một mảng trong BCPL với một cái gì đó như:

let V = vec 10

mà thực sự phân bổ 11 từ bộ nhớ, không phải 10. Thông thường V là từ đầu tiên và chứa địa chỉ của từ ngay sau đó. Vì vậy, không giống như C, việc đặt tên V đã đi đến vị trí đó và chọn địa chỉ của phần tử zeroeth của mảng. Do đó, việc xác định mảng trong BCPL, được biểu thị bằng

let J = V!5

thực sự phải làm J = !(V + 5)(sử dụng cú pháp BCPL) vì cần phải tìm nạp V để lấy địa chỉ cơ sở của mảng. Như vậy V!5và 5!Vđã đồng nghĩa. Là một quan sát tổng quát, WAFL (Ngôn ngữ chức năng của Warwick) được viết bằng BCPL và theo trí nhớ tốt nhất của tôi có xu hướng sử dụng cú pháp sau thay vì truy cập các nút được sử dụng làm lưu trữ dữ liệu. Cấp điều này là từ một nơi nào đó giữa 35 và 40 năm trước, vì vậy trí nhớ của tôi là một chút gỉ. :)

Sự đổi mới của việc phân phối với thêm từ lưu trữ và có trình biên dịch chèn địa chỉ cơ sở của mảng khi nó được đặt tên đến sau. Theo tài liệu lịch sử C, điều này đã xảy ra vào khoảng thời gian các cấu trúc được thêm vào C.

Lưu ý rằng !trong BCPL vừa là toán tử tiền tố đơn nguyên vừa là toán tử infix nhị phân, trong cả hai trường hợp thực hiện gián tiếp. chỉ là dạng nhị phân bao gồm một phép cộng của hai toán hạng trước khi thực hiện phép nối. Với tính chất định hướng từ của BCPL (và B), điều này thực sự có ý nghĩa rất lớn. Việc hạn chế "con trỏ và số nguyên" được thực hiện cần thiết trong C khi nó thu được các kiểu dữ liệu và sizeoftrở thành một thứ.

Vâng, đây là một tính năng chỉ có thể vì hỗ trợ ngôn ngữ.

Trình biên dịch diễn giải a[i]như *(a+i)và biểu thức 5[a]ước lượng thành *(5+a). Vì phép cộng là giao hoán nên hóa ra cả hai đều bằng nhau. Do đó biểu thức ước lượng true.

Trong C

 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

Con trỏ là một "biến"

tên mảng là "mnemonic" hoặc "synonymous"

p++;hợp lệ nhưng a++không hợp lệ

a[2] bằng 2 [a] vì hoạt động bên trong của cả hai điều này là

"Số học con trỏ" được tính toán bên trong như

*(a+3) bằng *(3+a)

các loại con trỏ

1) con trỏ tới dữ liệu

int *ptr;

2) const con trỏ tới dữ liệu

int const *ptr;

3) const con trỏ tới dữ liệu const

int const *const ptr;

và các mảng là loại (2) từ danh sách của chúng tôi
Khi bạn xác định một mảng tại một thời điểm, một địa chỉ được khởi tạo trong con trỏ đó
Như chúng ta biết rằng chúng ta không thể thay đổi hoặc sửa đổi giá trị const trong chương trình của mình vì nó ném LRI khi biên dịch thời gian

Sự khác biệt chính mà tôi tìm thấy là ...

Chúng ta có thể khởi tạo lại con trỏ theo một địa chỉ nhưng không phải là trường hợp tương tự với một mảng.

======
và quay lại câu hỏi của bạn ...
a[5]không có gì nhưng *(a + 5)
bạn có thể hiểu dễ dàng bằng cách
a - chứa địa chỉ (mọi người gọi nó là địa chỉ cơ sở) giống như một loại con trỏ (2) trong danh sách của chúng tôi
[]- toán tử đó có thể là thay thế bằng con trỏ *.

cuối cùng thì...

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