සී ක්‍රමලේඛන භාෂාවෙන් (aka: K & R), ජොයෙල් ස්ටැක් ඕවර්ෆ්ලෝ පොඩ්කාස්ට් # 34 හි පෙන්වා ඇති පරිදි, සී හි අරා වල මෙම දේපල ගැන සඳහනක් ඇත:a[5] == 5[a]

ජොයෙල් පවසන්නේ එය දර්ශක අංක ගණිතය නිසා නමුත් මට තවමත් තේරෙන්නේ නැති බවයි. ඇයිa[5] == 5[a] ?

සී ප්‍රමිතිය මඟින් []ක්‍රියාකරු පහත පරිදි අර්ථ දක්වයි :

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.

නමුත් මේ අවස්ථාවේ දී අපි විශේෂයෙන් කතා කරන්නේ දර්ශක අංක ගණිතය ගැන ය, එහිදී එක් ඔපෙරන්ඩ් එකක් දර්ශකයක් වන අතර අනෙක පූර්ණ සංඛ්‍යාවක් වේ. (පූර්ණ සංඛ්‍යා + නිඛිලය වෙනස් මෙහෙයුමක් වන අතර, දර්ශකය + දර්ශකය විකාරයකි.)

සී ප්‍රමිතියේ +ක්‍රියාකරු පිළිබඳ විස්තරය ( 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 දිනැති අත්පොත) වෙතින් ලබා ගත් අතර එය බොහෝ විට එය පවා ලබාගෙන ඇත. පෙර භාෂා (සීපීඑල්? ඇල්ගොල්?).

එබැවින් අරාව සුචිගත කිරීම අර්ථ දැක්වෙන්නේ එකතු කිරීම අනුව වන අතර, එම එකතු කිරීම, දර්ශකයක් සහ පූර්ණ සංඛ්‍යාවක් පවා සංක්‍රමණික වේ යන අදහස දශක ගණනාවකට පෙර සී හි මුතුන් මිත්තන්ගේ භාෂාවලට දිව යයි.

එම භාෂාවන් නූතන සී වලට වඩා තදින් ටයිප් කර ඇත. විශේෂයෙන්, දර්ශක සහ නිඛිල අතර වෙනස බොහෝ විට නොසලකා හරින ලදි. (මුල් සී ක්‍රමලේඛකයින් සමහර විට unsignedභාෂාවට මූලික පදය එක් කිරීමට පෙර අත්සන් නොකළ පූර්ණ සංඛ්‍යා ලෙස දර්ශක භාවිතා කළහ.) එබැවින් ඔපෙරන්ඩ්ස් විවිධ වර්ගවල බැවින් එකතු කිරීම සංක්‍රමණ නොවන බවට පත් කිරීමේ අදහස බොහෝ විට එම භාෂාවල නිර්මාණකරුවන්ට සිදු නොවනු ඇත. පරිශීලකයෙකුට "දේවල්" දෙකක් එකතු කිරීමට අවශ්‍ය නම්, එම "දේවල්" පූර්ණ සංඛ්‍යා, දර්ශක හෝ වෙනත් යමක් වේවා, එය වැළැක්වීම භාෂාවට අදාළ නොවේ.

වසර ගණනාවක් පුරා, එම රීතියේ යම් වෙනසක් සිදුවුවහොත් පවත්නා කේතය බිඳී යනු ඇත (1989 ANSI C ප්‍රමිතිය හොඳ අවස්ථාවක් විය හැකි වුවද).

C සහ / හෝ C ++ වෙනස් කිරීම මඟින් දර්ශකය වම් පසින් තැබීම සහ දකුණු පස ඇති නිඛිලය දැනට පවතින කේත කිහිපයක් බිඳ දැමිය හැකි නමුත් සැබෑ ප්‍රකාශන බලය නැති නොවේ.

ඒ නිසා අපට දැන් arr[3]හා 3[arr]හරියටම තේරුම එකම දෙයක්, අග ආකාරයක බාහිර කවදාවත් පෙනී යුතු වුවත් IOCCC .

ඇත්ත වශයෙන්ම

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

මෙයට ප්‍රධාන හේතුව වූයේ 70 දශකයේ දී සී නිර්මාණය කරන විට පරිගණකවලට එතරම් මතකයක් නොතිබීමයි (64KB ගොඩක් විය), එබැවින් සී සම්පාදකයා සින්ටැක්ස් පරීක්ෂාව සිදු නොකළේය. ඒ නිසා " 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ලිපිනයක වන අතර සංකේතය දර්ශකයක් ගබඩා කර ඇති ලිපිනයක ඇති අතර එම මතක ස්ථානයේ ඇති දර්ශකයේ අගය අරාවේ ආරම්භය වේ.

සී හි දර්ශකයන් සඳහා, අපට තිබේ

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&);
};

ටෙඩ් ජෙන්සන් විසින් රචිත A TUTORIAL ON POINTERS AND ARRAYS IN C හි එය ඉතා හොඳ පැහැදිලි කිරීමක් ඇත .

ටෙඩ් ජෙන්සන් එය මෙසේ පැහැදිලි කළේය.

ඇත්ත වශයෙන්ම, මෙය සත්‍යයකි, එනම් යමෙකු ලියන ඕනෑම තැනක a[i]එය *(a + i) කිසිදු ගැටළුවක් නොමැතිව ප්‍රතිස්ථාපනය කළ හැකිය . ඇත්ත වශයෙන්ම, සම්පාදකයා ඕනෑම අවස්ථාවක එකම කේතය නිර්මාණය කරයි. මේ අනුව, දර්ශක අංක ගණිතය අරාව සුචිගත කිරීම හා සමාන බව අපට පෙනේ. එක්කෝ සින්ටැක්ස් එකම ප්‍රති .ලය ලබා දෙයි.

දර්ශකයන් සහ අරා එකම දේ යැයි මෙය නොකියයි, ඒවා එසේ නොවේ. අප කියන්නේ අරාවෙහි දී ඇති මූලද්‍රව්‍යයක් හඳුනා ගැනීම සඳහා අපට සින්ටැක්ස් දෙකක් තෝරා ගත හැකි බවයි, එකක් අරාව සුචිගත කිරීම සහ අනෙක සමාන ප්‍රති .ල ලබා දෙන දර්ශක අංක ගණිතය භාවිතා කිරීම ය.

දැන්, මෙම අන්තිම ප්‍රකාශනය දෙස බලන විට, එහි කොටසක් .. (a + i)යනු + ක්‍රියාකරු සහ සී ප්‍රකාශයේ සරල එකතු කිරීමකි, එවැනි ප්‍රකාශනයක් සංක්‍රමණශීලී බව. එනම් (a + i) සමාන වේ (i + a). මේ අනුව අපට පහසුවෙන් ලිවිය *(i + a)හැකිය *(a + i). ඒත් *(i + a)එන්න තිබුනා i[a]! මේ සියල්ලෙන් කුතුහලය දනවන සත්‍යය නම්:

char a[20];

ලේඛන

a[3] = 'x';

ලිවීමට සමාන වේ

3[a] = 'x';

ප්‍රශ්නයට පිළිතුරු ලැබී ඇති බව මම දනිමි, නමුත් මෙම පැහැදිලි කිරීම බෙදා ගැනීමට මට නොහැකි විය.

මම Compiler නිර්මාණය මූලධර්ම මතක, අපි උපකල්පනය කරමු aයනු intපෙළගැස්මකින් සහ ප්රමාණය int2 බයිට් වන අතර, සහ සඳහා මූලික ලිපිනය a1000 වේ.

ක්‍රියා කරන්නේ කෙසේද 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].

අරා වල negative ණ දර්ශක C හි වැඩ කිරීමට හේතුව මෙම පැහැදිලි කිරීම ද වේ.

එනම් මා ප්‍රවේශ වුවහොත් a[-5]එය මට ලබා දෙනු ඇත

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

එය 990 ස්ථානයේ මට වස්තුව නැවත ලබා දෙනු ඇත.

දී සී පෙලගැස්මක් , arr[3]හා 3[arr]සමාන වේ, හා ඔවුන්ගේ සමාන පහිටුම් දක්වනය අංකන වේ *(arr + 3)කිරීමට *(3 + arr). එහෙත් ඊට ප්රතිවිරුද්ධව [arr]3හෝ [3]arrනිවැරදි නොවන අතර කාරක රීති දෝෂයක් බවට හේතු වනු ඇත, ලෙස (arr + 3)*හා (3 + arr)*වලංගු ප්රකාශන නොවේ. හේතුව, විරූපණ ක්‍රියාකරු ප්‍රකාශනය මඟින් ලබා දෙන ලිපිනයට පෙර තැබිය යුතු අතර ලිපිනයෙන් පසුව නොවේ.

c සම්පාදකයේ

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

අරාවෙහි මූලද්‍රව්‍යයක් යොමු කිරීමට විවිධ ක්‍රම වේ! (සෑම අතින්ම නොවේ)

දැන් ඉතිහාසය ටිකක්. වෙනත් භාෂාවන් අතර, බීසීපීඑල් සී හි මුල් සංවර්ධනයට තරමක් විශාල බලපෑමක් ඇති කළේය. ඔබ BCPL හි අරාව ප්‍රකාශයට පත් කළේ නම්:

let V = vec 10

එය සත්‍ය වශයෙන්ම වචන 11 ක් වෙන් කර ඇත, 10 නොවේ. සාමාන්‍යයෙන් V යනු පළමුවැන්න වන අතර වහාම පහත සඳහන් වචනයේ ලිපිනය අඩංගු වේ. C මෙන් නොව V නම් කිරීම එම ස්ථානයට ගොස් අරාවේ ශුන්‍ය මූලද්‍රව්‍යයේ ලිපිනය ලබා ගත්තේය. එබැවින් BCPL හි අරාව නිර්‍මාණ කිරීම,

let J = V!5

J = !(V + 5)අරාවෙහි මූලික ලිපිනය ලබා ගැනීම සඳහා V ලබා ගැනීම අවශ්‍ය වූ හෙයින් (BCPL සින්ටැක්ස් භාවිතා කරමින්) ඇත්ත වශයෙන්ම කළ යුතුව තිබුණි . මේ අනුව V!5සහ 5!Vසමාන පද විය. පුරාවෘත්ත නිරීක්ෂණයක් ලෙස, ඩබ්ලිව්.ඒ.එෆ්.එල්. මෙය මීට වසර 35 ත් 40 ත් අතර කාලයක සිට පැවත එන බැවින් මගේ මතකය ටිකක් මලකඩ ය. :)

අමතර ගබඩා කිරීමේ වචනය සමඟ බෙදා හැරීමේ නවෝත්පාදනය සහ සම්පාදකයා විසින් අරාව නම් කරන විට එහි මූලික ලිපිනය ඇතුළත් කිරීම පසුව පැමිණියේය. සී ඉතිහාස පත්‍රයට අනුව මෙය සිදු වූයේ ව්‍යුහයන් සී ට එකතු කරන අවස්ථාවේ දී ය.

!BCPL හි ඒකීය උපසර්ග ක්‍රියාකරුවෙකු සහ ද්විමය ඉන්ෆික්ස් ක්‍රියාකරුවෙකු වූ බව සලකන්න . ද්විමය ආකෘතියට ඉන්ඩෙක්ෂන් කිරීමට පෙර ඔපෙරන්ඩ් දෙක එකතු කිරීමක් ඇතුළත් විය. 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) දත්ත වෙත සංයුක්ත දර්ශකය

int const *ptr;

3) සංයුක්ත දත්ත සඳහා const pointer

int const *const ptr;

සහ අරා අපගේ ලැයිස්තුවෙන් (2) වර්ගයකි.
ඔබ වරකට අරාව නිර්වචනය කරන විට එම දර්ශකයේ එක් ලිපිනයක් ආරම්භ වේ
. අපගේ වැඩසටහනේ නියත අගය වෙනස් කිරීමට හෝ වෙනස් කිරීමට අපට නොහැකි බව අප දන්නා හෙයින් එය සම්පාදනය කිරීමේදී දෝෂයක් ඇති කරයි කාලය

මෙම ප්රධාන වෙනස මා සොයාගෙන ඇත ...

අපට දර්ශකය ලිපිනයකින් නැවත ආරම්භ කළ හැකි නමුත් අරාව සමඟ එකම අවස්ථාව නොවේ.

======
සහ ඔබේ ප්‍රශ්නයට ආපසු යන්න ...
a[5]වෙන කිසිවක් නොව අපගේ ලැයිස්තුවේ (2) ආකාරයේ දර්ශකයක් මෙන් ලිපිනය (මිනිසුන් එය මූලික ලිපිනය ලෙස හඳුන්වයි) *(a + 5)
පහසුවෙන් තේරුම් ගත හැකිය - එම ක්‍රියාකරු විය හැකිය දර්ශකය සමඟ ප්‍රතිස්ථාපනය කළ හැකිය.
a
[]*

ඉතින් අවසානයේ ...

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