Memory আর ঠিকানা: প্রতিটা বাক্সের একটা নম্বর আছে

আট module ধরে Maria scanf("%d", &n) লিখে আসছে, তবু Module 3 যে প্রশ্নটা খোলা রেখে গিয়েছিল, সেটা ওর মাথা থেকে যায়নি। printf-এর তো কখনো ampersand লাগে না, তাহলে scanf-এর লাগে কেন? Module 3 বলেছিল, এটা একটা ঠিকানা হাতে দেয়, কিন্তু ঠিকানা দেখতে কেমন, কেউ ওকে দেখায়নি। এই lesson Playground-এর দুইটা run থেকে সত্যিকারের ঠিকানা print করে দেখাবে, তারপর এক বাক্যে ওর প্রশ্নের উত্তর দেবে।

Memory হলো নম্বর দেওয়া byte-এর একটা সারি

Byte মানে 8 bit, sizeof যে এককে গোনে (Module 2 lesson 5)। চলমান একটা program-এর memory হলো byte-এর বিশাল লম্বা একটা সারি। প্রতিটা byte-এর একটা নম্বর আছে, মানে সারিতে তার জায়গা, আর সেই নম্বরটাই তার ঠিকানা (address)।

একটা variable তার type যত byte চায়, ততগুলো byte পাশাপাশি নেয়। তার ঠিকানা হলো তার প্রথম byte-এর ঠিকানা। Module 2 lesson 1 একটা run থেকে তিনটা ঠিকানা print করেছিল, কিন্তু সেগুলো নিয়ে কোনো কথা দেয়নি। এই lesson সেগুলো মেপে দেখবে।

তাই প্রতিটা variable-এর তিনটা পরিচয়: তার মান, তার মাপ, আর তার ঠিকানা।

Address-of operator একটা variable-এর ঠিকানা দেয়

Variable-এর নামের আগে একটা ampersand বসালেই তার ঠিকানা পাওয়া যায়। এই &-এর নাম address-of operator, আর &a পড়ো "a-এর ঠিকানা"। যার একটা বাক্স আছে, এমন যেকোনো কিছুর উপর এটা চলে: একটা variable, বা &marks[2]-এর মতো একটা বাক্স।

printf("%p\n", (void *)&name);

Hexadecimal হলো Module 1 lesson 4-এর base 16: 9-এর পরে আসে a থেকে f, যাদের মান 10 থেকে 15। সামনের 0x বলে দেয় সংখ্যাটা base 16-এ লেখা, ঠিক Module 3 lesson 1-এর মতো।

এই program সাতটা ঠিকানা print করে: প্রথমে তিনটা variable-এর, তারপর একটা array-র চারটা বাক্সের।

#include <stdio.h>

int main(void)
{
    int a = 1;
    int b = 2;
    double d = 3.0;
    int marks[4] = {70, 80, 90, 60};

    printf("&a = %p\n", (void *)&a);
    printf("&b = %p\n", (void *)&b);
    printf("&d = %p\n", (void *)&d);
    for (int i = 0; i < 4; i++) {
        printf("&marks[%d] = %p\n", i, (void *)&marks[i]);
    }
    printf("%d %d %.1f %d\n", a, b, d, marks[0]);
    return 0;
}

চালানোর আগে trace করো। এই table-এর ঠিকানাগুলো বানানো: ছোট, আর decimal-এ, যাতে সহজে পড়া যায়। আসল ঠিকানা hexadecimal-এ, আর প্রতি run-এ বদলায়।

শেষ লাইনটা প্রতিটা run-এ print করে 1 2 3.0 70। নড়ে শুধু তার উপরের সাতটা ঠিকানা।

তাই &x একটা সংখ্যা: x-এর প্রথম byte-এর ঠিকানা।

Playground-এ দুইটা run: নতুন সংখ্যা, একই দূরত্ব

এই হলো Playground-এ ওই program-এর দুইটা run, মাঝে কিছুই বদলানো হয়নি। শেষ কলামে আছে, প্রতিটা ঠিকানা &a থেকে কত byte দূরে।

দূরত্ব পড়তে শেষের digit-গুলো মেলাও। bc0 থেকে bc4 হলো 4। bc8 থেকে bd0 হলো 8, কারণ c8-এর পরে আসে c9, তারপর ca থেকে cf, তারপর d0। আর c মানে 12, তাই bd8 থেকে bdc হলো 4।

প্রতিটা ঠিকানা বদলে গেছে, অথচ প্রতিটা দূরত্ব একই আছে। এর পিছনে আছে ASLR, মানে address space layout randomisation। প্রতিবার run-এর সময় system program-এর memory শুরু করে একটা এলোমেলো জায়গা থেকে। তাই print হওয়া একটা ঠিকানা সত্যি শুধু সেই run-এর জন্য, যেটা ওটা print করেছে।

দূরত্বগুলোর ভিতরে আসলে দুই রকম তথ্য আছে। marks-এর ভিতরে 4 করে ধাপটা C-র নিয়ম, কারণ array-র বাক্সগুলো contiguous, মানে মাঝে ফাঁক ছাড়া পরপর বসে (Module 9 lesson 01)। কিন্তু a, b আর d কোন ক্রমে বসবে, সেটা শুধুই GCC-র পছন্দ। Module 2 lesson 1-এর run তিনটা int-কে বসিয়েছিল উল্টো ক্রমে, কমতে থাকা ঠিকানায়, আর সেটাও নিয়মের মধ্যেই ছিল।

তাই ঠিকানা মেলাও একই run-এর ভিতরে, কখনো দুই run-এর মধ্যে না।

Array-র ধাপ: এক বাক্সের sizeof

Module 9 lesson 01 কথা দিয়েছিল, বাক্স i কোথায় শুরু হয়, সেটা Module 11 print করে দেখাবে। ওপরের run দুইটা ঠিক সেটাই করেছে: marks-এর বাক্সগুলো 4 byte পরপর বসে। এই ধাপটা হলো sizeof marks[0], মানে এক বাক্সের মাপ।

ধাপটা type-এর উপর নির্ভর করে। চারটা ছোট array-র বাক্স 0 আর বাক্স 1 print করে, এমন একটা program Playground-এ একবার চালিয়ে পাওয়া গেছে এটা।

ওই run-এর sizeof-এর লাইন বলেছে 4, 1, 8 আর 8, ধাপগুলোর সাথে হুবহু এক। সাথে একটা ঠিকানার নিজের মাপও দিয়েছে: 8 byte, সেটা যেখানেই নিয়ে যাক।

তাই বাক্স i শুরু হয় বাক্স 0 থেকে i গুণ এক বাক্সের sizeof পরে, আর machine marks[i] খুঁজে পায় ঠিক এই হিসাবেই।

Memory-র ছবি: code, static area আর stack

Module 7 lesson 5 কথা দিয়েছিল, memory-র একটা ঠিকঠাক ছবি আঁকা হবে। এই হলো সেই ছবি, Playground-এর Linux-এ চলা একটা program-এর; সবচেয়ে ছোট ঠিকানা নিচে।

Code হলো তোমার program-এর instruction-গুলো। Static area-তে থাকে global আর static local, পুরো run জুড়ে (Module 7 lesson 5)। Stack-এ প্রতিটা চলমান call-এর একটা করে frame থাকে, আর তাতে থাকে সেই call-এর parameter আর local।

Module 8 নতুন frame-টা এঁকেছিল স্তূপের সবার উপরে। ঠিকানার হিসাবে কিন্তু সেটা বসে নিচে, কারণ stack memory-তে নিচের দিকে বাড়ে (Module 8 lesson 02)। আর heap, মানে program চলার সময় চেয়ে নেওয়া memory, সেটা Module 14-এর বিষয়।

এই lesson-এর প্রতিটা ঠিকানা শুরু হয় 0x7ff দিয়ে, কারণ a, b, d আর marks সবাই main-এর local, আর Linux stack রাখে ওখানেই। -O2-এ GCC অনেক local-কে register-এ রেখে দেয় (Module 7 lesson 5)। কিন্তু যে ঠিকানা print হয়, সেটাকে একটা সত্যিকারের বাক্সেই নিয়ে যেতে হয়।

তাই একটা local থাকে stack-এ, তার call-এর frame-এ, আর একটা global বা static থাকে static area-তে।

Pointer হলো এমন variable, যেটা একটা ঠিকানা ধরে রাখে

ঠিকানা তো একটা সংখ্যা, তাই একটা variable সেটা ধরে রাখতে পারে। যে variable একটা ঠিকানা ধরে রাখে, তার নাম pointer। সেটা যদি &score ধরে রাখে, তাহলে বলা হয় সেটা score-কে point করে।

ঠিকানারও type আছে। int score-এর বেলায় &score-এর type হলো int *, পড়ো "pointer to int"। এমন type-কে বলে pointer type। তাই Module 9-এ GCC-র 'int *', আর Module 10-এ string.h-এর char *, এরা আসলে সবসময়ই ঠিকানা ছিল।

Pointer declare করা, আর তার ভিতর দিয়ে পড়া আর লেখা, lesson 02-এর কাজ। আপাতত শুধু গড়নটা দেখে রাখো: int *where = &score; একটা pointer বানায়, নাম where, যেটা ধরে রাখে score-এর ঠিকানা।

তাই &score হলো int * type-এর একটা ঠিকানা, আর pointer সেটা ধরে রাখে।

scanf-এর কেন ampersand লাগে

এবার Maria-র প্রশ্ন। একটা call প্রতিটা argument-এর মান কপি করে নেয় (Module 7 lesson 3), আর কপিতে লিখলে আসলটার কিছুই বদলায় না। scanf-কে লিখতে হয় তোমার variable-এর ভিতরে, তাই ওর জানা দরকার variable-টা থাকে কোথায়। &age ওকে ঠিক সেটাই বলে দেয়।

#include <stdio.h>

void set_to_31(int n);

int main(void)
{
    int age = 0;

    set_to_31(age);
    printf("after set_to_31: age = %d\n", age);
    scanf("%d", &age);
    printf("after scanf:     age = %d\n", age);
    return 0;
}

void set_to_31(int n)
{
    n = 31;
    printf("inside set_to_31: n = %d\n", n);
}

Input 27 দিয়ে এটা trace করো, age-এর জন্য একটা বানানো ঠিকানা ধরে নিয়ে।

inside set_to_31: n = 31
after set_to_31: age = 0
after scanf:     age = 27

ওই output-টা input 27-এর জন্য। set_to_31 বদলেছে শুধু নিজের কপিটা। scanf পেয়েছে age-এর ঠিকানা, আর সেখানকার বাক্সে লিখে দিয়েছে 27। এতে Module 7 lesson 3-এর teaser-এর উত্তরও মিলে গেল: scanf বরাবরই তোমার variable বদলেছে তাদের ঠিকানা দিয়ে। এমন function নিজে কীভাবে লিখবে, সেটা দেখাবে lesson 04।

Module 3 lesson 4 একটা ব্যতিক্রমের কথা বলেছিল: scanf("%19s", word)-এ কোনো ampersand নেই। Module 9 lesson 05 বলেছিল, একটা function-কে array দিলে সে পায় বাক্সগুলো কোথায় আছে, সেই খবর। এই মানটার এবার একটা নাম হলো: বাক্স 0-এর ঠিকানা। নিচের program সেটা তিনভাবে print করে।

#include <stdio.h>

#define BOXES 3

void show_where(int a[], int n);

int main(void)
{
    int marks[BOXES] = {40, 55, 72};

    printf("main:       marks     = %p\n", (void *)marks);
    printf("main:       &marks[0] = %p\n", (void *)&marks[0]);
    show_where(marks, BOXES);
    return 0;
}

void show_where(int a[], int n)
{
    printf("show_where: a         = %p, n = %d\n", (void *)a, n);
}

বানানো ঠিকানা দিয়ে trace করো। show_where-এর frame বসে main-এর frame-এর নিচে।

Compiler Explorer-এ একবার run করে তিনটা লাইনেই একই ঠিকানা print হয়েছে। তোমার সংখ্যা আলাদা হবে, তবে তোমার তিনটা লাইনও একে অন্যের সাথে মিলবে। Parameter a ধরে রাখে marks[0]-এর ঠিকানা, আর এভাবেই Module 9-এর function-গুলো main-এর বাক্সে পৌঁছাত।

তাই ampersand-এর নিয়ম কখনো ভাঙেনি: & জিজ্ঞেস করে একটা বাক্স কোথায় থাকে, আর array-র নাম নিজেই সেটা বলে দেয়। Module 3-এর scanf("%d", roll) হাতে দিয়েছিল roll-এর ভিতরের সংখ্যাটা, আর scanf সেটাকেই ঠিকানা ভেবে নিয়েছিল।

#include <stdio.h>

#define BOXES 4

int main(void)
{
    int score = 87;
    double price = 7.5;
    char grade = 'B';
    int marks[BOXES] = {70, 80, 90, 60};

    printf("what      bytes\n");
    printf("score     %5zu\n", sizeof score);
    printf("price     %5zu\n", sizeof price);
    printf("grade     %5zu\n", sizeof grade);
    printf("marks     %5zu\n", sizeof marks);
    printf("&score    %5zu\n", sizeof &score);
    return 0;
}

what      bytes
score         4
price         8
grade         1
marks        16
&score        8

#include <stdio.h>

#define MARKS 4
#define PRICES 3

int main(void)
{
    int marks[MARKS] = {70, 80, 90, 60};
    double prices[PRICES] = {1.5, 2.5, 3.5};

    for (int i = 0; i < MARKS; i++) {
        printf("marks[%d]  starts %2zu bytes after marks[0]\n", i, i * sizeof marks[0]);
    }
    for (int i = 0; i < PRICES; i++) {
        printf("prices[%d] starts %2zu bytes after prices[0]\n", i, i * sizeof prices[0]);
    }
    return 0;
}

marks[0]  starts  0 bytes after marks[0]
marks[1]  starts  4 bytes after marks[0]
marks[2]  starts  8 bytes after marks[0]
marks[3]  starts 12 bytes after marks[0]
prices[0] starts  0 bytes after prices[0]
prices[1] starts  8 bytes after prices[0]
prices[2] starts 16 bytes after prices[0]

#include <stdio.h>

#define MAX_N 50

int main(void)
{
    char name[20] = {0};
    int n = 0;
    int marks[MAX_N] = {0};
    int total = 0;

    scanf("%19s", name);
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &marks[i]);
        total += marks[i];
    }

    printf("%s: %d marks, total %d\n", name, n, total);
    printf("first %d, last %d\n", marks[0], marks[n - 1]);
    return 0;
}

Amara: 5 marks, total 356
first 70, last 48

int score = 87;

printf("%d\n", &score);

printf("%p\n", &score);

printf("%p\n", (void *)&60);
printf("%p\n", (void *)&(score + 1));

char name[20] = {0};

scanf("%19s", &name);

#include <stdio.h>

#define BOXES 5

int main(void)
{
    int seats = 40;
    double price = 7.5;
    char row = 'C';
    int stock[BOXES] = {12, 0, 7, 3, 25};

    /* Print the address of seats, price and row, one per line.
       Then print the address of every box of stock, and
       sizeof stock[0]. Which step do you read between the boxes? */

    return 0;
}

#include <stdio.h>

int main(void)
{
    char letters[2] = {'a', 'b'};
    short years[2] = {2025, 2026};
    int seats[2] = {40, 42};
    long long views[2] = {1000000000000, 2000000000000};
    double prices[2] = {7.5, 9.25};

    /* For each array, print on one line: the type, sizeof one box,
       and the addresses of box 0 and box 1. Before you run it,
       write the step you expect for each type in a comment. */

    return 0;
}

এরপর Bob লেখে int *p;, তারপর *p = 5;, আর জিজ্ঞেস করে ওর 5 কোথায় গেল। Lesson 02 ঠিকভাবে একটা pointer declare করবে, তারপর সেটার পিছু পিছু তার বাক্স পর্যন্ত যাবে।