Pointer arithmetic

📖 Theory

જે સવાલ અડધા class ને પાડી દે છે

એક int pointer p, address 5000 રાખે છે. p + 1 શું છે?

દરેક class ના અડધા લોકો 5001 જવાબ આપે છે, અને mark ગુમાવે છે.

Machine નો જવાબ: 5004. કારણ કે p એ int* છે, અને એક int 4 bytes રોકે છે, C એ નક્કી કર્યું કે pointer arithmetic ને આખા boxes માં ગણવું જોઈએ, bytes માં નહીં. એ જ એક design choice આજનો lesson છે, અને એ જ કારણ છે કે pointers અને arrays એક જ topic બનવાના છે.

📖 Theory

ઈંટોના નહીં, ઘરોના આગળ ચાલવું

કોઈ શેરીમાં ચાલતાં, "આગળનું ઘર" નો અર્થ "જમણી બાજુ એક ઈંટ" નથી થતો: એનો અર્થ છે એક આખો plot આગળ, plot નું size જે હોય તે. Pointer arithmetic એ જ રીતે ચાલે છે: p + 1 નો અર્થ p ના type નો આગળનો box છે. Int ના plot 4 bytes પહોળા છે, char ના 1, એટલે એ જ +1 stride અલગ અલગ અંતર કાપે છે. Pointer નો type એ જ ચબરખી પર plot નું size છે.

📖 Theory

Arithmetic, ઔપચારિક રીતે

એક pointer p, જેનો type T* છે, અને sizeof(T) = s:

• p + n → n boxes આગળનો address: સંખ્યામાં p + n×s bytes.
• p - n → n boxes પાછળ.
• p++ / p-- → એક box આગળ/પાછળ પગલું (ચાલવાનું engine).
• q - p (બંને એક જ array માં) → એમની વચ્ચે કેટલા ELEMENTS છે, bytes નહીં.

અર્થહીન અને ગેરકાયદે: p + q (બે addresses ઉમેરવાથી કંઈ જવાબ મળતો નથી), અને pointers ને ગુણવા કે ભાગવા. C બરાબર એ જ operations આપે છે જે boxes ની શેરી પર કોઈ અર્થ રાખે છે.

⌨️ Practical

જુઓ strides કેવી રીતે અલગ છે

#include <stdio.h>

int main() {
    int  marks[3] = {70, 80, 90};
    int  *p = &marks[0];
    char word[] = "abc";
    char *c = &word[0];

    printf("p   = %p\n", (void *)p);
    printf("p+1 = %p\n", (void *)(p + 1));   /* +4 bytes */
    printf("c   = %p\n", (void *)c);
    printf("c+1 = %p\n", (void *)(c + 1));   /* +1 byte  */
    printf("*(p+2) = %d\n", *(p + 2));
    return 0;
}

This example runs in Gri-Learn on the web, where you can edit it and see the output.

🧩 Quiz

એક float pointer pf, address 6000 રાખે છે (floats 4 bytes ના હોય છે). pf + 3 કયો address છે?

1. 6012
2. 6003
3. 6004
4. 6300

💭 Think first

*(p + 2) ને સમજો

ઉપરના code માં, p, {70, 80, 90} ના marks[0] ને point કરે છે. બંને operators ના અર્થ વાપરીને *(p + 2) ને મોટેથી વાંચો, પછી અનુમાન કરો કે એ શું print કરશે.

🧩 Quiz

p, એક જ int array ના marks[1] ને point કરે છે અને q, marks[4] ને. q - p શું છે?

1. 3, એમની વચ્ચે elements ની સંખ્યા
2. 12, એમની વચ્ચે bytes ની સંખ્યા
3. 5, મોટો index
4. ગેરકાયદે: pointers ને બાદ કરી શકાતા નથી

⚠️ Watch out

Marks ક્યાં કપાય છે

Byte ગણવા: int પર p+1, 4 ચાલે છે, 1 નહીં; દરેક જવાબમાં ×sizeof વાળું step લખો. Pointers ઉમેરવા: p + q ગેરકાયદે છે, ફક્ત તફાવત અર્થ રાખે છે. શેરીની બહાર ચાલવું: array ના અંત ના આગળ p++ એ out-of-bounds છે, pointer વાળા લહેકામાં, એ જ છાનેમાને થતી corruption જે marks[n] માં થાય છે. અને (void ) cast સાથે %p, એ address PRINT કરવાની પ્રામાણિક રીત છે, lab work માં વાપરવા લાયક.

📖 Theory

આગળનો ખુલાસો

તમે reveal માં પકડી લીધું: *(p + 2) એ જ marks[2] છે. આગળનો lesson એને official બનાવે છે: array નું NAME એ box zero નો address છે, indexing એ વેશપલટો કરેલી pointer arithmetic છે, અને scanf("%s", name) નો & રહસ્ય કાયમ માટે બંધ થઈ જાય છે. આ unit ના બે સૌથી મોટા idea હાથ મિલાવવાના છે.

✅ Summary

Key takeaways

• Pointer arithmetic boxes માં ગણે છે: p + n, n × sizeof(type) bytes આગળ વધે છે.
• int 5000 પર: p+1 એ 5004; char 1 ચાલે છે; float* 4.
• p++ box-દર-box ચાલે છે, traversal engine.
• q - p (એક જ array) એમની વચ્ચેના ELEMENTS ગણે છે; p + q ગેરકાયદે છે.
• *(p + 2) બે boxes આગળની value ઉપાડે છે, અને marks[2] બરાબર છે.
• યાદ રાખવાની યુક્તિ: આગળનું ઘર, આગળની ઈંટ નહીં.