Joel がCプログラミング言語（別名：K＆R）のStack Overflowポッドキャスト＃34で指摘しているように、Cでは配列のこのプロパティについて言及されています。a[5] == 5[a]

ジョエルは、それはポインター演算のせいだと言いますが、私はまだ理解していません。なぜ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]は、配列名は暗黙的に配列の最初の要素へのポインターに変換されます。）

しかし、この場合、加算の交換可能性はそれほど明白ではありません。

両方のオペランドが同じ型の場合、または共通の型に昇格された異なる数値型の場合でも、可換性は完全に理にかなっていますx + y == y + x。

ただし、この場合は、1つのオペランドがポインターで、もう1つのオペランドが整数であるポインター演算について具体的に説明します。（整数+整数は別の操作であり、ポインター+ポインターは無意味です。）

+オペレーターに関するC標準の説明（N1570 6.5.6）は次のように述べています。

さらに、両方のオペランドが算術型であるか、一方のオペランドが完全なオブジェクト型へのポインタであり、もう一方が整数型である必要があります。

それは同じくらい簡単に言ったでしょう：

さらに、両方のオペランドが算術型であるか、左の オペランドが完全なオブジェクト型へのポインタであり、右のオペランド が整数型である必要があります。

その場合、i + pとの両方i[p]が違法になります。

C ++の用語では、実際には2つのオーバーロードされた+演算子のセットがあり、大まかに次のように説明できます。

pointer operator+(pointer p, integer i);

そして

pointer operator+(integer i, pointer p);

最初のものだけが本当に必要です。

では、なぜこのようになるのでしょうか。

C ++はこの定義をCから継承し、Bから取得しました（配列のインデックス付けの可換性は、1972年のユーザーズリファレンスのBで明示的に言及されています）。BCPLから取得しました。以前の言語（CPL？Algol？）。

したがって、配列のインデックス付けは加算の観点から定義されており、その加算はポインタと整数であっても交換可能であり、Cの祖先言語に何十年も遡ります。

これらの言語は、現代のC言語よりも強く型付けされていません。特に、ポインタと整数の違いはしばしば無視されました。（初期のCプログラマは、unsignedキーワードが言語に追加される前に、ポインタを符号なし整数として使用することがありました。）したがって、オペランドが異なる型であるため、加算を非可換にするという考えは、おそらくそれらの言語の設計者には思い浮かばなかったでしょう。ユーザーが2つの「もの」を追加したい場合、それらの「もの」が整数、ポインター、またはその他のものであるかどうかにかかわらず、それを防ぐのは言語の責任ではありませんでした。

そして、何年にもわたって、そのルールに変更を加えると既存のコードが壊れてしまいます（1989年のANSI C規格が好機だったかもしれませんが）。

ポインターを左側に配置し、整数を右側に配置する必要があるようにCまたはC ++を変更すると、既存のコードが壊れることがありますが、実際の表現力は失われません。

つまり、後者の形式はIOCCCの外部に表示されるべきではありませんが、まったく同じことarr[3]を3[arr]意味します。

そしてもちろん

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

これの主な理由は、Cが設計された70年代には、コンピューターに十分なメモリがなかった（64KBが多かった）ため、Cコンパイラは構文チェックをあまり行わなかったためです。したがって、「X[Y]」はやや盲目的に「*(X+Y)」に 翻訳されました

「+=」と「++」の構文についても説明します。「A = B + C」という形式のすべてが同じコンパイル済み形式でした。ただし、BがAと同じオブジェクトである場合、アセンブリレベルの最適化が利用可能でした。しかし、コンパイラはそれを認識するほど明るくなかったので、開発者は（A += C）をしなければなりませんでした。同様に、もしCいた1、別のアセンブリレベルの最適化が利用可能であった、と再び開発者は、コンパイラがそれを認識していなかったので、それを明示しなければなりませんでした。（最近ではコンパイラーが実行するため、これらの構文は最近ほとんど不要です）

誰もダイナの問題について言及していないように見えることの1つsizeof：

ポインタに整数を追加できるだけで、2つのポインタを同時に追加することはできません。このようにして、整数へのポインター、またはポインターへの整数を追加するとき、コンパイラーは、どのビットが考慮に入れられる必要があるサイズを持っているかを常に知っています。

文字通り質問に答えること。常にそうであるとは限らない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].

答えではありませんが、考えるための食べ物です。クラスにオーバーロードされたインデックス/添え字演算子がある場合、式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&);
};

Ted JensenによるCのポインタと配列に関するチュートリアルで非常に良い説明があります。

テッドジェンセンは次のように説明しています。

実際、これは真実です。つまり、どこに書いa[i]て*(a + i) も問題なく置き換えることができます。実際、コンパイラはどちらの場合でも同じコードを作成します。したがって、ポインタ演算は配列のインデックス付けと同じものであることがわかります。どちらの構文でも同じ結果になります。

これは、ポインタと配列が同じものであると言っているのではなく、同じではありません。配列の特定の要素を識別するには、配列のインデックスを使用する構文とポインタ演算を使用する構文の2つの構文を選択できることだけを述べています。

さて、この最後の式、その一部を見ると(a + i)、.. は、+演算子を使用した単純な追加であり、Cの規則は、そのような式は可換であると述べています。つまり、（a + i）はと同じです(i + a)。したがって、と*(i + a)同じくらい簡単に書くことができました*(a + i)。しかし*(i + a)、から来たかもしれないi[a]！これらすべてから、次のような奇妙な真実が生まれます。

char a[20];

書き込み

a[3] = 'x';

書くことと同じです

3[a] = 'x';

質問への回答はわかっていますが、この説明を共有することに抵抗がありませんでした。

コンパイラ設計の原則を覚えています。aがint配列で、サイズintが2バイトで、ベースアドレスがaが1000であるとします。

どのよう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)*有効な式ではありません。その理由は、逆参照演算子は、アドレスの後にではなく、式によって生成されたアドレスの前に配置する必要があるためです。

Cコンパイラ

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

配列の要素を参照するさまざまな方法があります！（まったくではない）

少し歴史があります。他の言語の中でも、BCPLはCの初期の開発にかなり大きな影響を与えました。BCPLで次のような配列を宣言した場合：

let V = vec 10

実際には、10ではなく11ワードのメモリが割り当てられました。通常、Vが最初で、直後のワードのアドレスが含まれていました。したがって、Cとは異なり、Vの名前はその場所に移動し、配列の0番目の要素のアドレスを取得しました。したがって、次のように表されるBCPLの配列間接指定

let J = V!5

J = !(V + 5)配列のベースアドレスを取得するためにVをフェッチする必要があったため、実際に（BCPL構文を使用して）実行する必要がありました。したがってV!5、5!V同義でした。事例観察として、WAFL（ワーウィック関数型言語）はBCPLで記述されており、私の記憶の限りでは、データストレージとして使用されるノードへのアクセスには、前者ではなく後者の構文を使用する傾向がありました。これは35年から40年前のどこかからのものであるため、私の記憶は少し錆びています。:)

ストレージの余分なワードを省き、名前が付けられたときにコンパイラーに配列のベースアドレスを挿入させるという革新は後に登場しました。Cの歴史の論文によると、これは構造がCに追加された頃に起こりました。

!BCPLでは、単項前置演算子と二項中置演算子の両方があり、どちらの場合も間接指定を行うことに注意してください。バイナリ形式には、間接指定を行う前に2つのオペランドが追加されているだけです。BCPL（およびB）の単語指向の性質を考えると、これは実際には非常に理にかなっています。Cではデータ型を取得する際に「ポインタと整数」の制限が必要にsizeofなり、モノになりました。

まあ、これは言語サポートのためにのみ可能な機能です。

コンパイラはa[i]として解釈し*(a+i)、式はに5[a]評価され*(5+a)ます。加算は可換であるため、両方が等しいことがわかります。したがって、式はに評価されtrueます。

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

ポインタは「変数」です

配列名は「ニーモニック」または「同義語」

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の値を変更したり、修正することができないことを知っているようにERRORをコンパイル時に時間

主な違い私が見つけたのです...

ポインターをアドレスで再初期化できますが、配列の場合とは異なります。

======
そしてあなたの質問に戻って...それ
a[5]は何でも*(a + 5)
簡単に理解できます
a -私たちのリストの（2）タイプのポインタのようにアドレス（人々はそれをベースアドレスと呼ぶ）を含む
[]-その演算子はポインタと交換可能*。

最後に...

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